elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recopilación Tutoriales y Manuales Hacking, Seguridad, Privacidad, Hardware, etc


  Mostrar Mensajes
Páginas: 1 [2]
11  Foros Generales / Dudas Generales / duda al introducir un caracter en una variable entera en: 19 Octubre 2011, 15:19 pm
hello.. tengo una duda.. estoy haciendo un programa en c++ y necesito saber como hacerle para que cuando el usuario introduzca un caracter en la variable entera entre de nuevo al ciclo do-while por que lo que hace el programa cuando introducen un caracter es k despliega la tabla del cero y no se devuelve al ciclo do-whileel codigo es el siguiente :D les agradeceria su ayuda :D

#include "stdafx.h"
#include <iostream>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <Windows.h>


using namespace std;

void TablasDeMultiplicar()
{
   int Tabla = 0;
   do
   {
   cout<<"\n\n  Ingresa el numero de la Tabla de Multiplicar que quieras Aprender: \n\n";
   cout<<"  Solo Podras Ver las Tablas del 0 al 12\n\n";
   cout<<"  Tabla del : ";
   cin>>Tabla;
   if(Tabla<=12 && Tabla >=0)
   {
   
   for(int i = 0; i<=12; i++)
   {
      cout<<"\n"<<Tabla<<" X "<<i<<" = "<<Tabla*i<<endl;
   }
   cout<<"\n\n\n"<<endl;
   }
   else
   {
      cout<<"\n\nNumero no valido"<<endl;
   }
   cout<<"\n\n\n";
   system("PAUSE");
   system("cls");
   }while(Tabla>12 || Tabla <0 );
}
int main()
{
   char a;
   system("color 9B");

   TablasDeMultiplicar();
   
   system("PAUSE");
   return 0;
}
12  Programación / Programación C/C++ / Re: programando c++ con switch y case en: 25 Mayo 2011, 19:34 pm
no sera que tienes 2 veces main??? por que si lo compilas tal cual esta en el ejemplo te mandara error en primera por las cabezeras osea los .h i segundo por que tienes dos main en un programa solo pueden existir un main pero si pueden existir varias funciones ademas si kieres  k jale tu programa tal cual esta solo tienes k kitar el segundo main (con todas i sus llaves) y tmb los archivos de cabezera i mandar a llamar la funcion simplemente con el nombre de la funcion ej. nombrefuncion();
13  Programación / Programación C/C++ / Pila en C++ en: 25 Mayo 2011, 19:01 pm
Código
  1. //Pila.cpp
  2. //By Norochii
  3. //Estructura de Datos
  4. #include "StdAfx.h"
  5. #include "Pila.h"
  6. #include <iostream>
  7. using namespace std;
  8.  
  9. Pila::Pila(void) //Constructor. se inicializa el tope o cima de la pila en -1
  10. {
  11. top = -1;
  12. }
  13.  
  14.  
  15. Pila::~Pila(void) //Destructor. Destruye los datos de la pila
  16. {
  17. cout<<"Destruyendo datos"<<endl;
  18. }
  19.  
  20. void Pila::EmptyStack() //Verifica si la pila esta vacia,
  21. { //viendo si el tope esta en -1
  22. top = -1;
  23. }
  24.  
  25. void Pila::AddStack(int elemento) //Verifica si la Pila esta llena
  26. {
  27. if(FullStack()) //Si la pila esta llena emite el mensaje
  28. { //Desbordamiento pila
  29. cout<<"Desbordamiento pila :";
  30. }
  31. else //Sino el apuntador o subindice se incrementa con cima++
  32. {
  33.  
  34. top++; //y se almacena un elemento en el arreglo A[cima] automaticamente
  35. A[top] = elemento; //ya que se iguala. El elemento que entro se guarda en el arreglo A[]
  36.  
  37. }
  38. }
  39.  
  40.  
  41. void Pila::Push(int elemento) //Esta funcion coincide con la funcion AddStack()
  42. {
  43. AddStack(elemento);
  44. }
  45.  
  46.  
  47. int Pila::Pop() //Esta funcion extrae los elementos de la pila
  48. {
  49. int Aux; //Se crea una variable auxiliar o temporal para poder guardar
  50. if(top == -1) //dentro de la variable Aux el ultimo elemento en entrar
  51. {
  52. cout<<"Se intenta sacar un elemento de una Pila vacia"<<endl;
  53. }
  54. else
  55. {
  56. Aux = A[top]; //Aqui se guarda el elemento del tope osea el ultimo elemento en entrar
  57. top--; //se decrementa el tope y apunta al siguiente elemento y asi sucecivamente hasta que quede en -1
  58. }
  59. return Aux; //se retorna el ultimo elemento del arreglo A[] almacenado en la variable Aux
  60. }
  61.  
  62. int Pila::FirstStack() //comprueba que la pila no este vacia
  63. {
  64. if(top == -1) //Si esta vacia emite un mensaje
  65. {
  66. cout<<"Se intenta sacar un elemento de una Pila vacia"<<endl;
  67. }
  68. else //sino se dara el elemento del arreglo A[] almacenado en la posicion apuntada por la cima
  69. {
  70. return A[top];
  71. }
  72. }
  73.  
  74.  
  75. void Pila::ClearStack() //Se encarga de eliminar el ultimo elemento que entro en la pila
  76. {
  77. if(top == -1) //Primero comprueba que la pila no este vacia
  78. { //Si esta vacia emite un mensaje
  79. cout<<"Se intenta sacar un elemento de una Pila vacia"<<endl;
  80. }
  81. else //Sino se decrementa el tope en 1
  82. {
  83. top--;
  84. }
  85. }
  86.  
  87. bool Pila::FullStack()
  88. {
  89. return top == MaxTamPila-1; //En este caso la pila estara llena cuando el tope apunte al valor MaxTamPila-1
  90. }
  91.  
  92. void Pila::CuentaPila() //Esta funcion es para saber cuantos elementos hay en la pila
  93. {
  94. if(top == -1)
  95. {
  96. cout<<"Se han sacado los elementos anteriormente o aun no introduce ninguno"<<endl;
  97. }
  98. else
  99. cout<<"Elementos existentes en la pila : "<<top + 1<<" Elementos"<<endl;
  100. }
  101.  
  102. void Pila::Elementos() //Una funcion que lo unico que hace es mostrar un mensaje de cuantos elementos se han introducido hasta ese momento
  103. {
  104.  
  105. cout<<"Elemento "<<top +2 <<endl;
  106. }
  107.  
14  Programación / Programación C/C++ / Ordenamientos Burbuja, Insercion y Shell en C++ en: 25 Mayo 2011, 18:40 pm
Código
  1. // Ordenamientos.cpp
  2. //Tipos de ordenamientos con enteros y caracteres utilizando memoria dinamica
  3. //By Norochii
  4. //Estructura de Datos
  5.  
  6. #include "stdafx.h"
  7. #include <iostream>
  8. #include <string>
  9. #include "time.h"
  10.  
  11. using namespace std;
  12.  
  13. class ordenamientos
  14. {
  15. private:
  16. int j,i,temp,x;
  17. int *listaEnteros;
  18. char *listaCaracteres;
  19. public:
  20. ordenamientos();
  21. ~ordenamientos();
  22. void ordenamientoBurbuja();
  23. void ordenamientoInsercion();
  24. void ordenamientoShell();
  25.  
  26. };
  27.  
  28. ordenamientos::ordenamientos()
  29. {
  30. i=0;
  31. j=0;
  32. temp=0;
  33. x=0;
  34. }
  35.  
  36. ordenamientos::~ordenamientos()
  37. {}
  38.  
  39. void ordenamientos::ordenamientoBurbuja()
  40. {
  41.  
  42. int opc;
  43. cout<<"                                 Metodo Burbuja "<<'\n'<<endl;
  44. cout<<"                               Que deseas Ordenar"<<endl;
  45. cout<<"                                   1.- Numeros"<<endl;
  46. cout<<"                                   2.- Letras"<<endl;
  47. cout<<"                                    Opcion: ";
  48. cin>>opc;
  49. system("cls");
  50. switch(opc)
  51. {
  52.  
  53. case 1:
  54. cout<<"                     Introduzca el numero de elementos a insertar "<<endl;
  55.  
  56. cout<<"                               Numeros de Elementos: ";
  57.  
  58. cin>>x;
  59.  
  60. listaEnteros= new(nothrow) int[x];
  61.  
  62. system("cls");
  63.  
  64. cout<<"Introduzca los elementos de la lista"<<endl;
  65.  
  66.  
  67. for(i=0; i<x; i++)
  68. {
  69.  
  70. cin>>listaEnteros[i];
  71. }
  72.  
  73. for(i=0;i<x-1;i++)
  74. {
  75.  
  76. for(j=i+1;j<x;j++)
  77. {
  78.  
  79. if(listaEnteros[i]>listaEnteros[j])
  80. {
  81. temp=listaEnteros[i];
  82.  
  83. listaEnteros[i]=listaEnteros[j];
  84.  
  85. listaEnteros[j]=temp;
  86. }
  87. }
  88.  
  89. }
  90.  
  91.  
  92. system("cls");
  93.  
  94. cout<<"Elementos Ordenados :"<<endl;
  95.  
  96. for(i=0; i<x; i++)
  97. {
  98.  
  99. cout<<endl;
  100.  
  101. cout<<"Elemento "<< i+1<<": " <<listaEnteros[i]<<endl;;
  102. }
  103.  
  104. delete[] listaEnteros;
  105.  
  106. break;
  107. case 2:
  108.  
  109. cout<<"            Introduzca el numero de elementos a insertar "<<endl;
  110.  
  111. cout<<"                    Numeros de Elementos: ";
  112.  
  113. cin>>x;
  114.  
  115. listaCaracteres= new(nothrow) char[x];
  116.  
  117. system("cls");
  118.  
  119. cout<<"Introduzca los elementos de la lista"<<endl;
  120.  
  121. for(i=0; i<x; i++)
  122. {
  123.  
  124. cin>>listaCaracteres[i];
  125. }
  126.  
  127. for(i=0;i<x-1;i++)
  128. {
  129.  
  130. for(j=i+1;j<x;j++)
  131. {
  132. if(listaCaracteres[i]>listaCaracteres[j])
  133. {
  134. temp=listaCaracteres[i];
  135.  
  136. listaCaracteres[i]=listaCaracteres[j];
  137.  
  138. listaCaracteres[j]=temp;
  139. }
  140. }
  141.  
  142. }
  143.  
  144.  
  145. system("cls");
  146.  
  147. cout<<"Elementos Ordenados :"<<endl;
  148.  
  149. for(i=0; i<x; i++)
  150. {
  151.  
  152. cout<<endl;
  153.  
  154. cout<<"Elemento "<< i+1<<": " <<listaCaracteres[i]<<endl;
  155. }
  156.  
  157. delete[] listaCaracteres;
  158.  
  159. break;
  160.  
  161. }
  162. }
  163.  
  164. void ordenamientos::ordenamientoInsercion()
  165. {
  166. int opc;
  167.  
  168. cout<<"                              Metodo Por Insercion "<<'\n'<<endl;
  169.  
  170. cout<<"                            Que deseas Ordenar"<<endl;
  171.  
  172. cout<<"                               1.- Numeros"<<endl;
  173.  
  174. cout<<"                               2.- Letras"<<endl;
  175.  
  176. cout<<"                                Opcion: ";
  177.  
  178. cin>>opc;
  179.  
  180. system("cls");
  181.  
  182. switch(opc)
  183. {
  184.  
  185. case 1:
  186.  
  187. cout<<"            Introduzca el numero de elementos a insertar "<<endl;
  188.  
  189. cout<<"                    Numeros de Elementos: ";
  190.  
  191. cin>>x;
  192.  
  193. listaEnteros= new(nothrow) int[x];
  194.  
  195. system("cls");
  196.  
  197. cout<<"Introduzca los elementos de la lista"<<endl;
  198.  
  199. for(i=0; i<x; i++)
  200. {
  201.  
  202. cin>>listaEnteros[i];
  203. }
  204.  
  205. for (i = 1; i < x; i++)
  206. {
  207.  
  208. temp = listaEnteros[i];
  209.  
  210. j = i - 1;
  211.  
  212. while ( (listaEnteros[j] > temp) && (j >= 0) )
  213. {
  214.  
  215. listaEnteros[j + 1] = listaEnteros[j];
  216.  
  217. j--;
  218.  
  219. listaEnteros[j + 1] = temp;
  220. }
  221.  
  222.  
  223. }
  224. system("cls");
  225.  
  226. cout<<"Elementos Ordenados :"<<endl;
  227.  
  228. for(j=0; j<x; j++)
  229. {
  230.  
  231. cout<<endl;
  232.  
  233. cout<<"Elemento "<< j+1<<": " <<listaEnteros[j]<<endl;;
  234. }
  235.  
  236. delete[] listaEnteros;
  237.  
  238. break;
  239.  
  240.  
  241. case 2:
  242.  
  243. cout<<"            Introduzca el numero de elementos a insertar "<<endl;
  244.  
  245. cout<<"                    Numeros de Elementos: ";
  246.  
  247. cin>>x;
  248.  
  249. listaCaracteres= new(nothrow) char[x];
  250.  
  251. system("cls");
  252.  
  253. cout<<"Introduzca los elementos de la lista"<<endl;
  254.  
  255. for(i=0; i<x; i++)
  256. {
  257.  
  258. cin>>listaCaracteres[i];
  259. }
  260.  
  261. for(i=0;i<x-1;i++)
  262. {
  263.  
  264. for(j=i+1;j<x;j++)
  265. {
  266.  
  267. if(listaCaracteres[i]>listaCaracteres[j])
  268. {
  269.  
  270. temp=listaCaracteres[i];
  271.  
  272. listaCaracteres[i]=listaCaracteres[j];
  273.  
  274. listaCaracteres[j]=temp;
  275.  
  276. }
  277.  
  278. }
  279.  
  280.  
  281. }
  282.  
  283.  
  284.  
  285. system("cls");
  286.  
  287. cout<<"Elementos Ordenados :"<<endl;
  288.  
  289. for(j=0; j<x; j++)
  290. {
  291.  
  292. cout<<endl;
  293.  
  294. cout<<"Elemento "<< j+1<<": " <<listaCaracteres[j]<<endl;;
  295. }
  296.  
  297. delete[] listaCaracteres;
  298. break;
  299.  
  300. }
  301. }
  302.  
  303. void ordenamientos::ordenamientoShell()
  304. {
  305. int inter,x,n=0,i=0,j=0,k=0,temp;
  306. int opc;
  307.  
  308.  
  309. cout<<"                              Metodo de Shell "<<'\n'<<endl;
  310.  
  311. cout<<"                            Que deseas Ordenar"<<endl;
  312.  
  313. cout<<"                               1.- Numeros"<<endl;
  314.  
  315. cout<<"                               2.- Letras"<<endl;
  316.  
  317. cout<<"                                Opcion: ";
  318.  
  319. cin>>opc;
  320.  
  321. system("cls");
  322.  
  323. switch(opc)
  324. {
  325. case 1:
  326.  
  327. cout<<"            Introduzca el numero de elementos a insertar "<<endl;
  328.  
  329. cout<<"                    Numeros de Elementos: ";
  330.  
  331. cin>>x;
  332.  
  333. inter = x/2;
  334.  
  335. listaEnteros= new(nothrow) int[x];
  336.  
  337. system("cls");
  338.  
  339. cout<<"Introduzca los elementos de la lista"<<endl;
  340.  
  341. for(i=0; i<x; i++)
  342. {
  343.  
  344. cin>>listaEnteros[i];
  345. }
  346.  
  347.  
  348. while(inter>0)
  349. {
  350.  
  351. for(i=inter;i<x;i++)
  352. {
  353.  
  354. n++;
  355.  
  356. j=i-inter;
  357.  
  358. while(j>=0)
  359. {
  360.  
  361. k=j+inter;
  362.  
  363. if(listaEnteros[j]<=listaEnteros[k])
  364. {
  365. j--;
  366. }
  367.  
  368. else
  369. {
  370.  
  371. temp=listaEnteros[j];
  372.  
  373. listaEnteros[j]=listaEnteros[k];
  374.  
  375. listaEnteros[k]=temp;
  376.  
  377. j=j-inter;
  378. }
  379.  
  380. }
  381.  
  382. }inter = inter/2;
  383. }
  384.  
  385.  
  386. system("cls");
  387.  
  388. cout<<"Elementos Ordenados :"<<endl;
  389.  
  390. for(j=0; j<x; j++)
  391. {
  392.  
  393. cout<<endl;
  394.  
  395. cout<<"Elemento "<< j+1<<": " <<listaEnteros[j]<<endl;;
  396.  
  397. }
  398.  
  399. delete[] listaEnteros;
  400.  
  401. break;
  402.  
  403. case 2:
  404.  
  405. cout<<"            Introduzca el numero de elementos a insertar "<<endl;
  406.  
  407. cout<<"                    Numeros de Elementos: ";
  408.  
  409. cin>>x;
  410.  
  411. inter = x/2;
  412.  
  413. listaCaracteres= new(nothrow) char[x];
  414.  
  415. system("cls");
  416.  
  417. cout<<"Introduzca los elementos de la lista"<<endl;
  418.  
  419. for(i=0; i<x; i++)
  420. {
  421.  
  422. cin>>listaCaracteres[i];
  423. }
  424.  
  425. while(inter>0)
  426. {
  427.  
  428. for(i=inter;i<x;i++)
  429. {
  430.  
  431. n++;
  432.  
  433. j=i-inter;
  434.  
  435. while(j>=0)
  436. {
  437.  
  438. k=j+inter;
  439.  
  440. if(listaCaracteres[j]<=listaCaracteres[k])
  441. {
  442. j--;
  443. }
  444.  
  445. else
  446. {
  447.  
  448. temp=listaCaracteres[j];
  449.  
  450. listaCaracteres[j]=listaCaracteres[k];
  451.  
  452. listaCaracteres[k]=temp;
  453.  
  454. j=j-inter;
  455. }
  456.  
  457. }
  458.  
  459. }inter = inter/2;
  460. }
  461.  
  462.  
  463. system("cls");
  464.  
  465. cout<<"Elementos Ordenados :"<<endl;
  466.  
  467. for(j=0; j<x; j++)
  468. {
  469.  
  470. cout<<endl;
  471.  
  472. cout<<"Elemento "<< j+1<<": " <<listaCaracteres[j]<<endl;;
  473.  
  474. }
  475.  
  476. delete[] listaCaracteres;
  477.  
  478. break;
  479.  
  480. }
  481. }
  482.  
  483. void  main()
  484. {
  485. int inicio,fin,tiempo,opcion;
  486. inicio=clock();
  487. ordenamientos O;
  488. cout<<" Selecciones el Metodo de Ordenamiento: "<<endl;
  489. cout<<'\n'<<"                                  1.- Metodo Burbuja "<<endl;
  490. cout<<"                                2.- Metodo de Insercion "<<endl;
  491. cout<<"                                 3.- Metodo de Shell "<<endl;
  492. cout<<"                                     Metodo Numero: ";
  493. cin>>opcion;
  494. system("cls");
  495. switch(opcion)
  496. {
  497. case 1:
  498. O.ordenamientoBurbuja();
  499. break;
  500. case 2:
  501. O.ordenamientoInsercion();
  502. break;
  503. case 3:
  504. O.ordenamientoShell();
  505. break;
  506.  
  507.        fin = clock();
  508. tiempo = fin-inicio;
  509. cout<<'\n'<<"Tiempo de Ejecucion: "<<tiempo<<" Milisegundos"<<endl;
  510. system("PAUSE");
  511.  
  512. }
  513. }
  514. Saludos Espero dejen sus comentarios :D
  515.  
15  Programación / Programación C/C++ / Algunos Tipos de Ordenamientos en: 25 Mayo 2011, 18:29 pm
Código
  1. // Ordenamientos.cpp
  2. //Tipos de ordenamientos con enteros y caracteres utilizando memoria dinamica
  3. //By Norochii
  4. //Estructura de Datos
  5.  
  6. #include "stdafx.h"
  7. #include <iostream>
  8. #include <string>
  9. #include "time.h"
  10. #include <math.h>
  11. #define NUMELTS 20
  12.  
  13. using namespace std;
  14.  
  15. class ordenamientos
  16. {
  17. private:
  18. int j,i,temp,x;
  19. int *listaEnteros;
  20. char *listaCaracteres;
  21. public:
  22. ordenamientos();
  23. ~ordenamientos();
  24. void ordenamientoBurbuja();
  25. void ordenamientoInsercion();
  26. void ordenamientoShell();
  27.  
  28.  
  29. };
  30.  
  31. ordenamientos::ordenamientos()
  32. {
  33. i=0;
  34. j=0;
  35. temp=0;
  36. x=0;
  37. }
  38.  
  39. ordenamientos::~ordenamientos()
  40. {}
  41.  
  42. void ordenamientos::ordenamientoBurbuja()
  43. {
  44. int opc;
  45. cout<<"                                 Metodo Burbuja "<<'\n'<<endl;
  46. cout<<"                               Que deseas Ordenar"<<endl;
  47. cout<<"                                   1.- Numeros"<<endl;
  48. cout<<"                                   2.- Letras"<<endl;
  49. cout<<"                                    Opcion: ";
  50. cin>>opc;
  51. system("cls");
  52. switch(opc)
  53. {
  54.  
  55. case 1:
  56. cout<<"Introduzca el numero de elementos a insertar "<<endl;
  57. cout<<"Numeros de Elementos: ";
  58. cin>>x;
  59. listaEnteros= new(nothrow) int[x];
  60. system("cls");
  61. cout<<"Introduzca los elementos de la lista"<<endl;
  62. for(i=0; i<x; i++)
  63. {
  64. cin>>listaEnteros[i];
  65. }
  66. for(i=0;i<x-1;i++)
  67. {
  68. for(j=i+1;j<x;j++)
  69. {
  70. if(listaEnteros[i]>listaEnteros[j])
  71. {
  72. temp=listaEnteros[i];
  73. listaEnteros[i]=listaEnteros[j];
  74. listaEnteros[j]=temp;
  75. }
  76. }
  77.  
  78. }
  79. system("cls");
  80. cout<<"Elementos Ordenados :"<<endl;
  81. for(i=0; i<x; i++)
  82. {
  83. cout<<endl;
  84. cout<<"Elemento "<< i+1<<": " <<listaEnteros[i]<<endl;
  85. }
  86. delete[] listaEnteros;
  87. break;
  88. case 2:
  89.  
  90. cout<<"Introduzca el numero de elementos a insertar "<<endl;
  91. cout<<" Numeros de Elementos: ";
  92. cin>>x;
  93. listaCaracteres= new(nothrow) char[x];
  94. system("cls");
  95. cout<<"Introduzca los elementos de la lista"<<endl;
  96. for(i=0; i<x; i++)
  97. {
  98. cin>>listaCaracteres[i];
  99. }
  100. for(i=0;i<x-1;i++)
  101. {
  102. for(j=i+1;j<x;j++)
  103. {
  104. if(listaCaracteres[i]>listaCaracteres[j])
  105. {
  106. temp=listaCaracteres[i];
  107. listaCaracteres[i]=listaCaracteres[j];
  108. listaCaracteres[j]=temp;
  109. }
  110. }
  111.  
  112. }
  113. system("cls");
  114. cout<<"Elementos Ordenados :"<<endl;
  115. for(i=0; i<x; i++)
  116. {
  117. cout<<endl;
  118. cout<<"Elemento "<< i+1<<": " <<listaCaracteres[i]<<endl;
  119. }
  120. delete[] listaCaracteres;
  121. break;
  122.  
  123. }
  124. }
  125.  
  126. void ordenamientos::ordenamientoInsercion()
  127. {
  128. int opc;
  129. cout<<" Metodo Por Insercion "<<'\n'<<endl;
  130. cout<<" Que deseas Ordenar"<<endl;
  131. cout<<" 1.- Numeros"<<endl;
  132. cout<<" 2.- Letras"<<endl;
  133. cout<<"                                Opcion: ";
  134. cin>>opc;
  135. system("cls");
  136. switch(opc)
  137. {
  138. case 1:
  139.            cout<<" Introduzca el numero de elementos a insertar "<<endl;
  140.            cout<<"Numeros de Elementos: ";
  141.            cin>>x;
  142. listaEnteros= new(nothrow) int[x];
  143. system("cls");
  144. cout<<"Introduzca los elementos de la lista"<<endl;
  145. for(i=0; i<x; i++)
  146. {
  147. cin>>listaEnteros[i];
  148. }
  149. for (i = 1; i < x; i++)
  150. {
  151. temp = listaEnteros[i];
  152. j = i - 1;
  153. while ( (listaEnteros[j] > temp) && (j >= 0) )
  154. {
  155. listaEnteros[j + 1] = listaEnteros[j];
  156. j--
  157. listaEnteros[j + 1] = temp;
  158. }
  159. }
  160. system("cls");
  161. cout<<"Elementos Ordenados :"<<endl;
  162. for(j=0; j<x; j++)
  163. {
  164. cout<<endl;
  165. cout<<"Elemento "<< j+1<<": " <<listaEnteros[j]<<endl;;
  166. }
  167. delete[] listaEnteros;
  168. break;
  169. case 2:
  170.  
  171. cout<<"Introduzca el numero de elementos a insertar "<<endl;
  172. cout<<"  Numeros de Elementos: ";
  173. cin>>x;
  174. listaCaracteres= new(nothrow) char[x];
  175. system("cls");
  176. cout<<"Introduzca los elementos de la lista"<<endl
  177. for(i=0; i<x; i++)
  178. {
  179. cin>>listaCaracteres[i];
  180. }
  181.  
  182. for(i=0;i<x-1;i++)
  183. {
  184. for(j=i+1;j<x;j++)
  185. {
  186. if(listaCaracteres[i]>listaCaracteres[j])
  187. {
  188. temp=listaCaracteres[i];
  189. listaCaracteres[i]=listaCaracteres[j];
  190. listaCaracteres[j]=temp;
  191. }
  192. }
  193.  
  194. }
  195.  
  196. system("cls");
  197. cout<<"Elementos Ordenados :"<<endl;
  198. for(j=0; j<x; j++)
  199. {
  200. cout<<endl;
  201. cout<<"Elemento "<< j+1<<": " <<listaCaracteres[j]<<endl;;
  202. }
  203.  
  204. delete[] listaCaracteres;
  205. break;
  206.  
  207. }
  208. }
  209.  
  210.  
  211. void ordenamientos::ordenamientoShell()
  212. {
  213. int inter,x,n=0,i=0,j=0,k=0,temp;
  214. int opc;
  215. cout<<"Metodo de Shell "<<'\n'<<endl;
  216. cout<<"                            Que deseas Ordenar"<<endl;
  217. cout<<"                               1.- Numeros"<<endl;
  218. cout<<"                               2.- Letras"<<endl;
  219. cout<<"                                Opcion: ";
  220. cin>>opc;
  221. system("cls");
  222. switch(opc)
  223. {
  224. case 1:
  225. cout<<"Introduzca el numero de elementos a insertar "<<endl;
  226. cout<<"                    Numeros de Elementos: ";
  227.        cin>>x;
  228. inter = x/2;
  229. listaEnteros= new(nothrow) int[x];
  230. system("cls");
  231. cout<<"Introduzca los elementos de la lista"<<endl;
  232. for(i=0; i<x; i++)
  233. {
  234. cin>>listaEnteros[i];
  235. }
  236.            while(inter>0)
  237. {
  238.  
  239. for(i=inter;i<x;i++)
  240. {
  241.  
  242. n++;
  243.  
  244. j=i-inter;
  245.  
  246. while(j>=0)
  247. {
  248.  
  249. k=j+inter;
  250.  
  251. if(listaEnteros[j]<=listaEnteros[k])
  252. {
  253. j--;
  254. }
  255.  
  256. else
  257. {
  258.  
  259. temp=listaEnteros[j];
  260.  
  261. listaEnteros[j]=listaEnteros[k];
  262.  
  263. listaEnteros[k]=temp;
  264.  
  265. j=j-inter;
  266. }
  267.  
  268. }
  269.  
  270. }inter = inter/2;
  271. }
  272.  
  273.  
  274. system("cls");
  275.  
  276. cout<<"Elementos Ordenados :"<<endl;
  277.  
  278. for(j=0; j<x; j++)
  279. {
  280.  
  281. cout<<endl;
  282.  
  283. cout<<"Elemento "<< j+1<<": " <<listaEnteros[j]<<endl;;
  284.  
  285. }
  286.  
  287. delete[] listaEnteros;
  288.  
  289. break;
  290.  
  291. case 2:
  292.  
  293. cout<<"            Introduzca el numero de elementos a insertar "<<endl;
  294.  
  295. cout<<"                    Numeros de Elementos: ";
  296.  
  297. cin>>x;
  298.  
  299. inter = x/2;
  300.  
  301. listaCaracteres= new(nothrow) char[x];
  302.  
  303. system("cls");
  304.  
  305. cout<<"Introduzca los elementos de la lista"<<endl;
  306.  
  307. for(i=0; i<x; i++)
  308. {
  309.  
  310. cin>>listaCaracteres[i];
  311. }
  312.  
  313. while(inter>0)
  314. {
  315.  
  316. for(i=inter;i<x;i++)
  317. {
  318.  
  319. n++;
  320.  
  321. j=i-inter;
  322.  
  323. while(j>=0)
  324. {
  325.  
  326. k=j+inter;
  327.  
  328. if(listaCaracteres[j]<=listaCaracteres[k])
  329. {
  330. j--;
  331. }
  332.  
  333. else
  334. {
  335.  
  336. temp=listaCaracteres[j];
  337.  
  338. listaCaracteres[j]=listaCaracteres[k];
  339.  
  340. listaCaracteres[k]=temp;
  341.  
  342. j=j-inter;
  343. }
  344.  
  345. }
  346.  
  347. }inter = inter/2;
  348. }
  349.  
  350.  
  351. system("cls");
  352.  
  353. cout<<"Elementos Ordenados :"<<endl;
  354.  
  355. for(j=0; j<x; j++)
  356. {
  357.  
  358. cout<<endl;
  359.  
  360. cout<<"Elemento "<< j+1<<": " <<listaCaracteres[j]<<endl;;
  361.  
  362. }
  363.  
  364. delete[] listaCaracteres;
  365.  
  366. break;
  367.  
  368. }
  369. }
  370.  
  371.  
  372. void  main()
  373. {
  374. int inicio,fin,tiempo,opcion;
  375. inicio=clock();
  376. ordenamientos O;
  377. cout<<" Selecciones el Metodo de Ordenamiento: "<<endl;
  378. cout<<'\n'<<"                                  1.- Metodo Burbuja "<<endl;
  379. cout<<"                                2.- Metodo de Insercion "<<endl;
  380. cout<<"                                 3.- Metodo de Shell "<<endl;
  381. cout<<"                                     Metodo Numero: ";
  382. cin>>opcion;
  383. system("cls");
  384. switch(opcion)
  385. {
  386. case 1:
  387. O.ordenamientoBurbuja();
  388. break;
  389. case 2:
  390. O.ordenamientoInsercion();
  391. break;
  392. case 3:
  393. O.ordenamientoShell();
  394. break;
  395.  
  396.        fin = clock();
  397. tiempo = fin-inicio;
  398. cout<<'\n'<<"Tiempo de Ejecucion: "<<tiempo<<" Milisegundos"<<endl;
  399. system("PAUSE");
  400.  
  401. }
  402. }
  403.  
Páginas: 1 [2]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines