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

 

 


Tema destacado: (TUTORIAL) Aprende a emular Sentinel Dongle By Yapis


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Estructuras Dinamicas
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Estructuras Dinamicas  (Leído 2,268 veces)
luiszoket

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Estructuras Dinamicas
« en: 19 Octubre 2017, 05:23 am »

¿Cómo puedo hacer, este código a Memoria Dinámica?

Código
  1. //********************************************************************/
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <time.h>
  6.  
  7. //********************************************************************//
  8.  
  9. //********************************************************************//
  10. #define TRUE 1
  11. #define FALSE 0
  12. #define ENTER 13
  13. #define ESC 27
  14. #define ESPACIO 32
  15. #define A 65
  16. #define Z 90
  17. #define N 5000
  18. //********************************************************************//
  19.  
  20. //********************************************************************//
  21. typedef struct nombre{
  22. char nombre[30];
  23. char appat[30];
  24. char apmat[30];
  25. }Tnombre;
  26.  
  27. typedef struct alumnos{
  28. Tnombre NombC;
  29. long matri;
  30. int sexo;
  31. }Talum;
  32.  
  33. //********************************************************************//
  34. void menu(void);
  35. Talum LlenarAut(Talum reg, long vect[], int pos);
  36. void ImprimirVect(Talum vect[], int tam);
  37. void Imprimir(Talum reg[], int pos);
  38. int BusqSec(Talum vect[], int tam, long matri);
  39. int BusquedaBin(Talum vect[], int tam, long matri);
  40. void OrdenacionShell(Talum vect[], int tam);
  41. void LlenarVect(long vect[], int tam, long ri, long rf);
  42. int Buscar(long vect[], int tam, long matri);
  43.  
  44.  
  45. int main(void){
  46. menu();
  47. srand(time(NULL));
  48. return 0;
  49. }
  50.  
  51. //********************************************************************//
  52.  
  53. void menu(void)
  54. {
  55. int op, i, j=0, x, pos=0, lleno=FALSE, orde=FALSE;
  56. long mat[N], matri;
  57. Talum reg, temp, vect[N];
  58.  
  59. LlenarVect(mat, N, 300000, 399999);
  60.  
  61. do{
  62. system("cls");
  63. printf("\n1.- Llenar Registros");
  64. printf("\n2.- Buscar");
  65. printf("\n3.- Ordenar");
  66. printf("\n4.- Imprimir");
  67. printf("\n5.- Salir");
  68. printf("\nSelecciona una opcion: ");
  69. scanf("%d",&op);
  70. switch(op)
  71. {
  72. case 1:
  73. system("cls");
  74. if(j<N)
  75. {
  76. system("cls");
  77. lleno=TRUE;
  78. if(j<400)
  79. {
  80. for(i=0; i<4000; i++)
  81. {
  82. temp=LlenarAut(reg, mat, pos);
  83. vect[j]=temp;
  84. j++;
  85. pos++;
  86. }
  87. printf("Los primeros %d registros han sido generados\n",i);
  88. system("pause");
  89. }
  90. else
  91. {
  92. system("cls");
  93. for(i=0; i<10; i++)
  94. {
  95. temp=LlenarAut(reg, mat, pos);
  96. vect[j]=temp;
  97. j++;
  98. pos++;
  99. }
  100. printf("%d registros mas agregados\n",i);
  101. orde=FALSE;
  102. system("pause");
  103. }
  104. }
  105. else
  106. {
  107. printf("Vector Lleno\n");
  108. system("pause");
  109. }
  110. break;
  111. case 2:
  112. system("cls");
  113. if(lleno==TRUE)
  114. {
  115. if(orde==TRUE)
  116. {
  117. system("cls");
  118. printf("Metodo Binario\n");
  119. printf("Digita la matricula: ");
  120. scanf("%ld",&matri);
  121. x=BusquedaBin(vect, j, matri);
  122. if(x!=-1)
  123. {
  124. Imprimir(vect, x);
  125. }
  126. else
  127. {
  128. system("cls");
  129. printf("Matricula no encontrada\n");
  130. system("pause");
  131. }
  132. }
  133. else
  134. {
  135. system("cls");
  136. printf("Metodo Secuencial\n");
  137. printf("Digita la matricula: ");
  138. scanf("%ld",&matri);
  139. x=BusqSec(vect, j, matri);
  140. if(x!=-1)
  141. {
  142. Imprimir(vect, x);
  143. }
  144. else
  145. {
  146. system("cls");
  147. printf("Matricula no encontrada\n");
  148. system("pause");
  149. }
  150. }
  151. }
  152. else
  153. {
  154. system("cls");
  155. printf("Vector Vacio\n");
  156. system("pause");
  157. }
  158. // system("pause");
  159. break;
  160. case 3:
  161. system("cls");
  162. if(lleno==TRUE)
  163. {
  164. if(orde==FALSE)
  165. {
  166. OrdenacionShell(vect, j);
  167. orde=TRUE;
  168. printf("Datos Ordenados\n");
  169. }
  170. else
  171. {
  172. system("cls");
  173. printf("El vector ya esta ordenado\n");
  174. }
  175. }
  176. else
  177. {
  178. system("cls");
  179. printf("Vector Vacio\n");
  180. }
  181.  
  182. system("pause");
  183. break;
  184. case 4:
  185. ImprimirVect(vect, j);
  186. break;
  187. }
  188. }while(op!=5);
  189. }
  190.  
  191. Talum LlenarAut(Talum reg, long vect[], int pos)
  192. {
  193. // Talum reg;
  194. int x=0;
  195.  
  196. char NombreH[40][40]={"LUIS","ALBERTO","HUGO","PEDRO","JUAN","JOSE","GOKU","GOHAN","MIGUEL","ANGEL",
  197.  "DIEGO","RAUL","ROBERTO","MARIO","RAFAEL","JAVIER","CARLOS","ARTURO","EMILIANO","ENRIQUE",
  198.  "FRANCISCO","RONALDO","PAUL","OSVALDO","SANTIAGO","THIAGO","ESTEBAN","NOEL","LEONEL","MARTIN",
  199.  "SAMUEL", "LUCAS", "MARCOS", "XAVI","ALONSO","RICARDO", "OMAR", "RENATO", "JONATHAN", "RUBEN"};
  200.  
  201. char NombreM[40][40]={"EMILY","JASMIN","LUCERO","NICOL","MARIA","CARMEN","ROCIO","CASANDRA","YESICA","VERONICA",
  202.  "PAOLA","KAREN","ALEJANDRA","ALEXANDRA","ENID","EDITH","CARLA","KARLA","FABIOLA","YOHANA",
  203.  "MONICA","JENIFER","LUCIA","KIMBERLY","AMANDA","PAULA","PERLA","MIA","STHEPHANIE","ALONDRA",
  204.  "CLEOPATRA","ANA","CLARA","DIANA","FRIDA","HELENA","JENA","LUCIA","NADIA","SILBIA"};
  205.  
  206. char Apellidos[40][40]={"PEREZ","LOPEZ","SANCHEZ","FERNANDEZ","MARQUEZ","ESPINOZA","RAMIREZ","PACHECO","PALCIOS","DONARUMA",
  207.    "DIAZ","PERALTA","AGUILAR","ALLI","ARTETA","ALARCON","DRAXLER","CAZORLA","SANTOS","JIMENEZ",
  208. "VIDAL","CISNEROS","MARCHESIN","SAMUDIO","TREJO","RAMOS","MARQUISIO","BONAVENTURA","ASENSIO","MODRIC",
  209.    "ETO", "ASENSIO", "VELA", "LAINEZ", "SAMBUEZA", "VOLPI", "IBARRA", "LEON", "SUAREZ", "VIETO"};
  210. x=1+rand()%2;
  211. reg.sexo=x;
  212. if(x==1)
  213. {
  214. x=1+rand()%40;
  215. strcpy(reg.NombC.nombre,NombreH[x]);
  216. }
  217. else
  218. {
  219. x=1+rand()%40;
  220. strcpy(reg.NombC.nombre,NombreM[x]);
  221. }
  222. x=1+rand()%40;
  223. strcpy(reg.NombC.appat,Apellidos[x]);
  224. x=1+rand()%40;
  225. strcpy(reg.NombC.apmat,Apellidos[x]);
  226.  
  227. reg.matri=vect[pos];
  228.  
  229. return reg;
  230. }
  231.  
  232. void ImprimirVect(Talum vect[], int tam)
  233. {
  234. int i=0, j, tecla;
  235.  
  236. do{
  237. system("cls");
  238. printf("\t|----------------------------------------------------------------------------------------------|\n");
  239. printf("\t|   N  |   Apellido paterno   |   Apellido materno   | Nombre(s)    | Matricula | Sexo |");
  240. printf("\n\t|----------------------------------------------------------------------------------------------|");
  241. for(j=0; j<40 && i<tam; j++, i++)
  242. {
  243. printf("\n\t|%5d |   %-18s |   %-18s |   %-18s |  %-8ld |  %-3d |", i+1, vect[i].NombC.appat, vect[i].NombC.apmat, vect[i].NombC.nombre, vect[i].matri, vect[i].sexo);
  244. }
  245. printf("\n\t|----------------------------------------------------------------------------------------------|");
  246. printf("\n\t|        Presione ESC para salir cualquie otra tecla para ver los siguientes registros         |");
  247. printf("\n\t|----------------------------------------------------------------------------------------------|");
  248. tecla=getch();
  249. }while(i<tam && tecla!=ESC);
  250. }
  251.  
  252. void Imprimir(Talum reg[], int pos)
  253. {
  254. system("cls");
  255. printf("Apellido paterno: %s\n",reg[pos].NombC.appat);
  256. printf("Apellido materno: %s\n",reg[pos].NombC.apmat);
  257. printf("Nombre(s): %s\n",reg[pos].NombC.nombre);
  258. printf("Matricula: %ld\n",reg[pos].matri);
  259. printf("Sexo: %d\n",reg[pos].sexo);
  260. printf("\n");
  261. system("pause");
  262. }
  263.  
  264. int BusqSec(Talum vect[], int tam, long matri)
  265. {
  266. int i;
  267. for(i = 0; i < tam; i++)
  268. {
  269. if(vect[i].matri == matri)
  270. {
  271. return i;
  272. }
  273. }
  274. return -1;
  275. }
  276.  
  277. int BusquedaBin(Talum vect[], int tam, long matri)
  278. {
  279. int central, bajo, alto;
  280. int valorcentral;
  281. bajo=0;
  282. alto=tam-1;
  283. while(bajo <= alto)
  284. {
  285. central = (bajo+alto)/2;
  286. valorcentral = vect[central].matri;
  287. if(matri == valorcentral)
  288. {
  289. return central;
  290. }
  291. else
  292. {
  293. if(matri < valorcentral)
  294. {
  295. alto=central-1;
  296. }
  297. else
  298. {
  299. bajo=central+1;
  300. }
  301. }
  302. }
  303. return -1;
  304. }
  305.  
  306. void OrdenacionShell(Talum vect[], int tam)
  307. {
  308. int intervalo, i, j , k;
  309.  
  310. intervalo = tam/2;
  311.  
  312. while(intervalo > 0)
  313. {
  314. for(i = intervalo; i < tam; i++)
  315. {
  316. j=i-intervalo;
  317. while(j >= 0)
  318. {
  319. k=j+intervalo;
  320. if(vect[j].matri<=vect[k].matri)
  321. {
  322. j=-1;
  323. }
  324. else
  325. {
  326. Talum temp;
  327. temp=vect[j];
  328. vect[j]=vect[k];
  329. vect[k]=temp;
  330. j-=intervalo;
  331. }
  332. }
  333. }
  334. intervalo=intervalo/2;
  335. }
  336. }
  337.  
  338. void LlenarVect(long vect[], int tam, long ri, long rf)
  339. {
  340. int i=0,x;
  341. long num;
  342.  
  343. do{
  344. num=ri+(rand()%(rf-ri)+1);
  345. x=Buscar(vect, tam, num);
  346. if(x == -1)
  347. {
  348. vect[i]=num;
  349. i++;
  350. }
  351. }while(i<tam);
  352.  
  353. // return vect;
  354. }
  355.  
  356. int Buscar(long vect[], int tam, long matri)
  357. {
  358. int i;
  359. for(i = 0; i < tam; i++)
  360. {
  361. if(vect[i] == matri)
  362. {
  363. return i;
  364. }
  365. }
  366. return -1;
  367. }
  368.  











· Los códigos deben ir en etiquetas GeSHi
>aquí las reglas del foro
-Engel Lex


« Última modificación: 19 Octubre 2017, 06:06 am por engel lex » En línea

srWhiteSkull


Desconectado Desconectado

Mensajes: 444



Ver Perfil WWW
Re: Estructuras Dinamicas
« Respuesta #1 en: 19 Octubre 2017, 16:37 pm »

Entiendo que ya has alcanzado un buen nivel de C, como aprecio en el código que muestras, ahora ya entiendes y tienes un dominio básico del lenguaje, y el siguiente paso es el divertido mundo de los punteros  ::)

Consiste en reservar memoria mediante malloc y compañía (en C++ se usa el new y el delete). Lee :

http://sopa.dis.ulpgc.es/fso/cpp/intro_c/introc75.htm

Es necesario que entiendas bien los conceptos de la memoria en el programa, que es algo que al parecer no pareces conocer, estudia eso antes de meterte en los punteros, es un consejo. Lee :

http://www.lcc.uma.es/~galvez/ftp/tci/tictema8.pdf


« Última modificación: 19 Octubre 2017, 16:40 pm por srWhiteSkull » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
estructuras dinamicas
Java
SAGA-gl 0 1,412 Último mensaje 26 Abril 2014, 21:22 pm
por SAGA-gl
estructuras dinamicas
Programación C/C++
MessageBoxA 3 2,633 Último mensaje 3 Noviembre 2014, 11:12 am
por eferion
Compilación C# - Estructuras Dinamicas
.NET (C#, VB.NET, ASP)
Castiel 6 5,663 Último mensaje 14 Febrero 2015, 23:52 pm
por Castiel
C# - Estructuras dinámicas: Listas tipo Pila - Problema de aplicación
Dudas Generales
Nolohagan 5 4,899 Último mensaje 15 Julio 2016, 22:48 pm
por ivancea96
ESTRUCTURAS DINAMICAS DE DATOS TIPO PILA
Programación C/C++
macabro5000 0 1,519 Último mensaje 23 Noviembre 2016, 01:25 am
por macabro5000
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines