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

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


  Mostrar Temas
Páginas: 1 2 3 [4] 5 6 7 8 9 10
31  Programación / Programación C/C++ / Segmentation fault en programa con cola enl lenguaje C. en: 6 Agosto 2016, 22:06 pm
Hola, que tengan muy buen día. -
Repase el video de donde saque el Ej. una decena de veces y no logro hacer que el programa no me de el error  Segmentation fault, busque también en internet el error del compilador y nada.
Nota: Alberto, mil disculpas por no copiarlo de tu video que por cierto lo vi un par de veces pero este me pareció más acorde a mis conocimientos (así me fue). -
Si además de decirme como solucionarlo (cosa que descarto) si me pondrían poner un poco de teoría del porqué me seria de mucha utilidad para no repetir. -

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. typedef struct ElementoLista{
  6. 	char *dato;	
  7. 	struct ElementoLista *siguiente;
  8. }Elemento;
  9.  
  10. typedef struct ListaUbicacion{
  11. 	Elemento *inicio;	
  12. 	Elemento *fin;
  13. 	int tamanio;
  14. }Cola;
  15.  
  16. void inicializacion_cola( Cola *serie);
  17. int insertar_cola( Cola *serie, Elemento *actual, char *dato );
  18. int quitar_cola( Cola *serie );
  19. void imprimir_cola( Cola *serie );
  20.  
  21. int main( void ){
  22. 	Cola *serie;
  23. 	inicializacion_cola( serie );
  24.  
  25. 	insertar_cola( serie, serie->fin, "1" );
  26. 	insertar_cola( serie, serie->fin, "2" );
  27. 	insertar_cola( serie, serie->fin, "3" );
  28. 	insertar_cola( serie, serie->fin, "4" );
  29. 	insertar_cola( serie, serie->fin, "5" );
  30. 	insertar_cola( serie, serie->fin, "6" );
  31. 	insertar_cola( serie, serie->fin, "7" );
  32. 	insertar_cola( serie, serie->fin, "8" );
  33. 	insertar_cola( serie, serie->fin, "9" );
  34.  
  35. 	imprimir_cola( serie );
  36.  
  37. 	printf( "\n" );
  38.  
  39. 	quitar_cola( serie );
  40. 	quitar_cola( serie );
  41. 	quitar_cola( serie );
  42. 	quitar_cola( serie );
  43.  
  44. 	imprimir_cola( serie );
  45.  
  46. 	return 0;
  47. }
  48.  
  49. void inicializacion_cola( Cola *serie){
  50. 	serie->inicio = NULL;	
  51. 	serie->fin = NULL;	
  52. 	serie->tamanio = 0;	
  53. }
  54.  
  55. int insertar_cola( Cola *serie, Elemento *actual, char *dato ){
  56. 	Elemento *nuevo_elemento;
  57.  
  58. 	if( ( nuevo_elemento = (Elemento *)malloc( sizeof( Elemento ))) == NULL )
  59. 		return -1;
  60. 	if( (nuevo_elemento->dato = ( char * )malloc(50 * sizeof (char))) == NULL)
  61. 		return -1;
  62.  
  63. 	strcpy( nuevo_elemento->dato	, dato );		
  64.  
  65. 	if( actual == NULL ){
  66. 		if( serie->tamanio == 0 ){
  67. 			serie->fin = nuevo_elemento;	
  68. 		}	
  69. 		nuevo_elemento->siguiente = serie->inicio;
  70. 		serie->inicio = nuevo_elemento; 	
  71. 	}else if( actual->siguiente == NULL ){
  72. 		serie->fin = nuevo_elemento;	
  73.  
  74. 		nuevo_elemento->siguiente = actual->siguiente;
  75. 		actual->siguiente = nuevo_elemento; 	
  76. 	}		
  77. 	serie->tamanio++;
  78.  
  79. 	return 0;
  80. }
  81.  
  82. int quitar_cola( Cola *serie ){
  83. 	Elemento *sup_elemento;	
  84.  
  85. 	if( serie->tamanio == 0 ){
  86. 		return -1;
  87. 	}
  88. 	sup_elemento = serie->inicio;
  89. 	serie->inicio = serie->inicio->siguiente;
  90.  
  91. 	free( sup_elemento->dato );
  92. 	free( sup_elemento );
  93.  
  94. 	serie->tamanio--;
  95. 	return 0;
  96. }
  97.  
  98. void imprimir_cola( Cola *serie ){
  99. 	Elemento *actual;
  100. 	int i;	
  101. 	actual = serie->inicio;
  102.  
  103. 	for( i=0; i<serie->tamanio; i++ ){
  104. 		printf( "\n %p - %s", actual, actual->dato );
  105. 		actual = actual->siguiente;	
  106. 	}
  107. }
  108.  

Citar
Program received signal SIGSEGV, Segmentation fault.
0x00000000004007d2 in inicializacion_cola (serie=0x0) at Cola.c:50
50      serie->inicio = NULL;   
Saludos.   
32  Programación / Programación C/C++ / Agregar nodo a lista doblemente enlazada (lenguaje C) en: 31 Julio 2016, 18:18 pm
Hola, buen día para todos. -
Como me pareció tener claro listas simplemente enlazada http://foro.elhacker.net/programacion_cc/borrar_nodo_en_lista_simplemente_enlazadac-t455556.0.html me metí con lista doblemente enlazada y tengo una parte que no puedo solucionar, me parece que la función crear para el primer nodo funciona, pero cuando agrego 2,3,4 no puede el anterior apuntar a NULL, por más que practique no me sale, por momento parece en mi mente que es una bobada pero cuando lo llevo a la práctica no me resulta. -   
Si le es posible desearía que me digan si la función agregar es correcta. - 

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4.  
  5. struct nodo{
  6. 	int dato;	
  7. 	struct nodo *anterior, *siguiente;
  8. };
  9.  
  10. struct lista{
  11. 	struct nodo *primero, *ultimo;
  12. 	int elementos;
  13. };
  14.  
  15. void menu( void );
  16. void limpiar( void );
  17. struct lista *agregar( struct lista *L );
  18. struct nodo *crear( int dato ); 
  19.  
  20.  
  21. int main( void ){
  22.  
  23. 	menu();
  24.  
  25. 	return 0;
  26. }
  27.  
  28.  
  29. void menu( void ){
  30. 	struct lista *Lista = NULL;
  31. 	Lista->elementos=0;
  32. 	int opc, ok, ch;
  33.  
  34. 	do{
  35. 		do{
  36. 			limpiar();
  37. 			printf( "\n ========== Menu Principal ==========\n" );	
  38. 			if( Lista != NULL)
  39. 				printf( "\n Total de datos.....:%d\n", Lista->elementos );	
  40. 			printf(" \n 1 - Agregar\n 2 - buscar\n 3 - Ordenar " );
  41. 			printf(" \n 4 - Total\n 5 - Finalizar\n\n Ingrese Opcion....: "  );
  42. 			ok = scanf( "%d", &opc ) == 1 && opc > 0 && opc <= 5;
  43. 			while ((ch = getchar()) != EOF && ch != '\n'); 
  44. 		}while( !ok );	
  45.  
  46. 		switch ( opc ){
  47. 			case 1: Lista = agregar( Lista );
  48. 				break;
  49. 			case 2: //Lista = buscar( Lista );
  50. 				break;
  51. 			case 3: //ordenar( Lista );
  52. 				break;
  53. 			case 4: //mostrar( Lista );
  54. 				break;
  55. 			case 5:;
  56. 				free( Lista );
  57. 				break;
  58. 		}
  59. 	}while( opc != 5 );
  60.  
  61. }
  62.  
  63. void limpiar( void ){
  64. 	system("cls||clear");	
  65. }
  66.  
  67. struct lista *agregar( struct lista *L ){
  68. 	int ok, ch, dto; 
  69.  
  70. 	do{
  71. 		limpiar();
  72. 		printf( "\n Ingrese dato (mayor a 0 y menor a %d)....: ", INT_MAX );	
  73. 		ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;
  74. 		while ((ch = getchar()) != EOF && ch != '\n'); 
  75. 	}while( !ok );
  76.  
  77. 	if( L != NULL ){
  78. 		struct nodo *e = crear( dto );
  79. 		L->ultimo->siguiente = e;
  80. 		L->ultimo = e;
  81. 		L->elementos++;
  82. 		return L;		
  83. 	}else{
  84. 		struct nodo *e = crear( dto );
  85. 		struct lista *l = calloc( sizeof( struct lista ), 1 );
  86. 		l->primero = e;
  87. 		l->ultimo = e;
  88. 		l->elementos = 1;
  89. 		return l;		
  90. 	}	
  91.  
  92. 	return L;	
  93. }
  94.  
  95. struct nodo *crear( int dato ){
  96. 	struct nodo *e = calloc( sizeof( struct nodo), 1 );
  97.  
  98. 	e->dato = dato;
  99. 	e->siguiente = NULL;
  100. 	e->anterior = NULL;
  101.  
  102. 	return e;	
  103. }
  104.  

Un abrazo. -
33  Programación / Programación C/C++ / Borrar nodo en lista simplemente enlazada[C] en: 24 Julio 2016, 18:33 pm
Hola, que tengan un muy buen día. -
Tengo actualmente 2 dudas que se encuentran en las funciones menuUno y borrar. -
La primera: necesito alguna validación más o con estas cuatro es suficiente para saber si el nodo es el único y de no ser el único si es el primero o si es el último o está entre ambos. -
La restante es: si dentro de if( L->elementos == 1 )  pongo L=NULL, esto es suficiente y si la función llamadora se entera del cambio o tengo que hacer un return. -

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4.  
  5. struct nodo{
  6. 	int dato;	
  7. 	struct nodo *siguiente;
  8. };
  9.  
  10. struct lista{
  11. 	struct nodo *primero;	
  12. 	struct nodo *ultimo;	
  13. 	int elementos;
  14. };
  15.  
  16. void menu( void );
  17. void menuUno( struct lista *L, struct nodo *N );
  18. void limpiar( void );
  19. struct lista *agregar( struct lista *L );
  20. struct nodo *crear( int dato );
  21. void mostrar( struct lista *L );
  22. void ordenar( struct lista *L );
  23. void buscar( struct lista *L );
  24. void modificar( struct nodo *pivote );
  25. void borrar( struct lista *L, struct nodo *pivote );
  26.  
  27.  
  28. int main( void ){
  29. 	menu();
  30.  
  31. 	return 0;
  32. }
  33.  
  34.  
  35. void menu( void ){
  36. 	struct lista *Lista = NULL;
  37. 	int opc, ok, ch;
  38.  
  39. 	do{
  40. 		do{
  41. 			limpiar();
  42. 			printf( "\n ========== Menu Principal ==========\n" );	
  43. 			if( Lista != NULL)
  44. 				printf( "\n Total de datos.....:%d\n", Lista->elementos );	
  45. 			printf(" \n 1 - Agregar\n 2 - buscar\n 3 - Ordenar " );
  46. 			printf(" \n 4 - Total\n 5 - Finalizar\n\n Ingrese Opcion....: "  );
  47. 			ok = scanf( "%d", &opc ) == 1 && opc > 0 && opc <= 5;
  48. 			while ((ch = getchar()) != EOF && ch != '\n'); 
  49. 		}while( !ok );	
  50.  
  51. 		switch ( opc ){
  52. 			case 1: Lista = agregar( Lista );
  53. 				break;
  54. 			case 2: buscar( Lista );
  55. 				break;
  56. 			case 3: ordenar( Lista );
  57. 				break;
  58. 			case 4: mostrar( Lista );
  59. 				break;
  60. 			case 5:;
  61. 				free(Lista);
  62. 				break;
  63. 		}
  64. 	}while( opc != 5 );
  65. }
  66.  
  67. void menuUno( struct lista *L, struct nodo *N ){
  68. 	int opc, ok, ch;
  69.  
  70. 	do{
  71. 		do{
  72. 			limpiar();
  73. 			printf( "\n ========== Menu ==========\n" );	
  74. 			printf(" \n 1 - Modificar\n 2 - Borrar\n 3 - Salir"
  75. 				   " \n\n Ingrese Opcion....: " );
  76. 			ok = scanf( "%d", &opc ) == 1 && opc > 0 && opc <= 5;
  77. 			while ((ch = getchar()) != EOF && ch != '\n'); 
  78. 		}while( !ok );	
  79.  
  80. 		switch ( opc ){
  81. 			case 1: modificar( N );
  82. 				opc=3;
  83. 				break;
  84. 			case 2: borrar( L, N );
  85. 				opc=3;
  86. 				break;
  87. 			case 3:
  88. 				break;
  89. 		}
  90. 	}while( opc != 3 );
  91. }
  92.  
  93. void limpiar( void ){
  94. 	system("cls||clear");	
  95. }
  96.  
  97. struct lista *agregar( struct lista *L ){
  98. 	int ok, ch, dto; 
  99.  
  100. 	do{
  101. 		limpiar();
  102. 		printf( "\n Ingrese dato (mayor a 0 y menor a %d)....: ", INT_MAX );	
  103. 		ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;
  104. 		while ((ch = getchar()) != EOF && ch != '\n'); 
  105. 	}while( !ok );
  106.  
  107. 	if( L != NULL ){
  108. 		struct nodo *e = crear( dto );
  109. 		L->ultimo->siguiente = e;
  110. 		L->ultimo = e;
  111. 		L->elementos++;
  112. 		return L;
  113. 	}else{
  114. 		struct nodo *e = crear( dto );
  115. 		struct lista *l = calloc( sizeof( struct lista ), 1 );
  116. 		l->primero = e;
  117. 		l->ultimo = e;
  118. 		l->elementos = 1;
  119. 		return l;
  120. 	}
  121. }
  122.  
  123. struct nodo *crear( int dato ){
  124. 	struct nodo *e = calloc( sizeof( struct nodo), 1 );
  125. 	e->dato = dato;
  126. 	e->siguiente = NULL;
  127.  
  128. 	return e;	
  129. }
  130.  
  131. void mostrar( struct lista *L ){
  132. 	struct nodo *auxiliar;
  133. 	int i=0;
  134.  
  135. 	if( L != NULL ){
  136. 		auxiliar = L->primero;
  137. 		while( auxiliar != NULL ){
  138. 			printf( "\n %d", auxiliar->dato );
  139. 			auxiliar = auxiliar->siguiente;
  140. 			i++;	
  141. 		}
  142. 	}else{
  143. 		printf( "\n La lista esta vacia..." );	
  144. 	}
  145.  
  146. 	printf( "\n Pulse una tecla para continuar..." );getchar();
  147. }
  148.  
  149. void ordenar( struct lista *L ){
  150. 	struct nodo *pivote = NULL, *actual = NULL;		
  151. 	int tmp;
  152.  
  153. 	if( L != NULL ){
  154. 		pivote = L->primero;	
  155. 		while( pivote != L->ultimo ){
  156. 			actual = pivote->siguiente;	
  157. 			while( actual != NULL ){
  158. 				if( pivote->dato > actual->dato ){
  159. 					tmp = pivote->dato;	
  160. 					pivote->dato = actual->dato;
  161. 					actual->dato = tmp;
  162. 				}	
  163. 				actual = actual->siguiente;
  164. 			}
  165. 			pivote = pivote->siguiente;
  166. 		}
  167. 		mostrar( L );	
  168. 	}else{
  169. 		printf( "\n La lista esta vacia..." );	
  170. 		printf( "\n Pulse una tecla para continuar..." );getchar();
  171. 	}
  172. }
  173.  
  174. void buscar( struct lista *L ){
  175. 	int ok, ch, dto, i=0; 
  176. 	struct nodo *pivote = NULL;
  177.  
  178. 	if( L != NULL ){
  179. 		do{
  180. 			limpiar();
  181. 			printf( "\n Ingrese el dato a buscar....: " );	
  182. 			ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;
  183. 			while ((ch = getchar()) != EOF && ch != '\n'); 
  184. 		}while( !ok );
  185.  
  186. 		pivote = L->primero;
  187. 		while( pivote != NULL ){
  188. 			if( pivote->dato == dto  ){
  189. 				menuUno( L, pivote );
  190. 				i++;
  191. 				break; 	
  192. 			}
  193. 			pivote = pivote->siguiente;
  194. 		}
  195. 		if( i == 0 ){
  196. 			printf( "\n El dato no existe..." );	
  197. 			printf( "\n Pulse una tecla para continuar..." );getchar();
  198. 		}
  199. 	}else{
  200. 		printf( "\n La lista esta vacia..." );	
  201. 		printf( "\n Pulse una tecla para continuar..." );getchar();
  202. 	}			
  203. }
  204.  
  205. void modificar( struct nodo *pivote ){
  206. 	int ok, ch, dto; 
  207.  
  208. 	do{
  209. 		limpiar();
  210. 		printf( "\n Dato a modificar.....: %d \n Ingrese nuevo dato...: ", pivote->dato );	
  211. 		ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;
  212. 		while ((ch = getchar()) != EOF && ch != '\n'); 
  213. 	}while( !ok );
  214. 	pivote->dato = dto;
  215. }
  216.  
  217. void borrar( struct lista *L, struct nodo *pivote ){
  218.  
  219. 	if( L->elementos == 1 ){
  220. 		printf( "\n Es el unico dato..." );	
  221. 	}
  222. 	else if( pivote == L->primero){
  223. 		printf( "\n Es el primer dato..." );
  224. 	}	
  225. 	else if( pivote->siguiente == NULL){
  226. 		printf( "\n Es el ultimo dato..." );
  227. 	}	
  228. 	else{
  229. 		printf( "\n Esta entre el primer dato y el ultimo..." );
  230. 	}
  232. }
  233.  

Es todo por el momento, es probable que me surgen algunas otras dudas. -
Saludos.
34  Programación / Programación C/C++ / segmentation fault al mostrar lista simplemente ligada en lenguaje C. en: 20 Julio 2016, 16:28 pm
Hola, que tengan un muy buen día.
Nuevamente Danielito con algún inconveniente con lista enlazada, lo que ocurre es que si ingreso un dato o más todo bien pero si la lista está vacía me da el error que dejo en la imagen a continuación. -
   
                         

Encuentro muchos ejs., pero casi todos son sin ingreso por teclado sino con datos ingresados antes de compilar, me parece que tiene que ver conque la lista esta igualada a NULL o sea que no apunta a ninguna dirección en concreto pero no logro dar con la tecla

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <limits.h>
  4.  
  5. struct nodo{
  6. 	int dato;	
  7. 	struct nodo *siguiente;
  8. };
  9.  
  10. struct lista{
  11. 	struct nodo *primero;	
  12. 	struct nodo *ultimo;	
  13. 	int elementos;
  14. };
  15.  
  16. void menu( void );
  17. void limpiar( void );
  18. struct lista *agregar( struct lista *L );
  19. struct nodo *crear( int dato );
  20. void mostrar( struct lista *L );
  21.  
  22. int main( void ){
  23. 	menu();
  24.  
  25. 	return 0;
  26. }
  27.  
  28.  
  29. void menu( void ){
  30. 	struct lista *Lista = NULL;
  31. 	int opc, ok, ch;
  32.  
  33.  
  34. 	do{
  35. 		do{
  36. 			limpiar();
  37. 			printf( "\n ========== Menu ==========\n" );	
  38. 			printf(" \n 1 - Agregar\n 2 - Buscar\n 3 - Borrar\n 4 - Ordenar " );
  39. 			printf(" \n 5 - Total\n 6 - Finalizar\n\n Ingrese Opcion....: "  );
  40. 			ok = scanf( "%d", &opc ) == 1 && opc > 0 && opc <= 6;
  41. 			while ((ch = getchar()) != EOF && ch != '\n'); 
  42. 		}while( !ok );	
  43.  
  44. 		switch ( opc ){
  45. 			case 1: Lista = agregar( Lista );
  46. 				break;
  47. 			case 2: printf("\n Buscar");
  48. 				break;
  49. 			case 3: printf("\n Borrar");
  50. 				break;
  51. 			case 4: printf("\n Ordenar");
  52. 				break;
  53. 			case 5: mostrar( Lista );
  54. 				break;
  55. 			case 6:;
  56. 				free(Lista);
  57. 				break;
  58. 		}
  59. 	}while( opc != 6 );
  60. }
  61.  
  62. void limpiar( void ){
  63. 	system("cls||clear");	
  64. }
  65.  
  66. struct lista *agregar( struct lista *L ){
  67. 	int ok, ch, dto; 
  68.  
  69. 	do{
  70. 		limpiar();
  71. 		printf( "\n Ingrese dato (mayor a 0 y menor a %d)....: ", INT_MAX );	
  72. 		ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;
  73. 		while ((ch = getchar()) != EOF && ch != '\n'); 
  74. 	}while( !ok );
  75.  
  76. 	if( L != NULL ){
  77. 		struct nodo *e = crear( dto );
  78. 		L->ultimo->siguiente = e;
  79. 		L->ultimo = e;
  80. 		L->elementos++;
  81. 		return L;
  82. 	}else{
  83. 		struct nodo *e = crear( dto );
  84. 		struct lista *l = calloc( sizeof( struct lista ), 1 );
  85. 		l->primero = e;
  86. 		l->ultimo = e;
  87. 		l->elementos = 1;
  88. 		return l;
  89. 	}
  90. }
  91.  
  92. struct nodo *crear( int dato ){
  93. 	struct nodo *e = calloc( sizeof( struct nodo), 1 );
  94. 	e->dato = dato;
  95. 	e->siguiente = NULL;
  96.  
  97. 	return e;	
  98. }
  99.  
  100. void mostrar( struct lista *L ){
  101. 	struct nodo *auxiliar;
  102. 	int i=0;
  103. 	auxiliar = L->primero;
  104.  
  105. 	while( auxiliar != NULL ){
  106. 		printf( "\n %d", auxiliar->dato );
  107. 		auxiliar = auxiliar->siguiente;
  108. 		i++;	
  109. 	}
  110. 	if( i == 0 ) printf( "\n La lista esta vacia..." );	
  111.  
  112. 	printf( "\n Pulse una tecla para continuar..." );getchar();
  113. }
  114.  

Saludos.
35  Programación / Programación C/C++ / Documentar función para borrar nodo según petición del usuario en C. en: 15 Julio 2016, 00:26 am
Hola, gente.
como se podrán imaginar aveces hago post que se me ocurren a mí solamente, pero si los hago es porque me resulta de mucha ayuda para aprender en serio y no en distintas ocasiones tener que copiar y pegar. -   
Les dejo la función para que en primer lugar me ayuden a documentarla, yo hice algunas lineas para que la tomen como Ej. para que se entienda lo que necesito. -
Si alguien tiene otra versión y la quiere postear, mi agradecimiento. -

Código
  1. struct lista *eliminarIndice( struct lista *L, int indice){
  2. 	int i = 1;
  3. 	if( L != NULL ){									// Verificamos que la lista no este vacia.
  4. 		if( indice <= 10 && indice > 0){						// Si indice es mayor a cero y menor o igual a la cant. de elemento continuamos.  
  5. 			struct nodo *anterior = L->primero;					// Grabamos en anterior la direc. del primer nodo.
  6. 			struct nodo *pivote = L->primero;					// Y lo mismo con pivote.
  7. 			while( i < indice ){							// Bucle para.... 
  8. 				anterior = pivote;
  9. 				pivote = pivote->siguiente;
  10. 				i++;
  11. 			}
  12. 			if( pivote->siguiente != NULL ){
  13. 				if( pivote->siguiente != L->primero ){
  14. 					anterior->siguiente = pivote->siguiente;
  15. 					free( pivote );				 
  16. 				}else{
  17. 					L->primero = pivote->siguiente;
  18. 					free( pivote );				 
  19. 				}
  20. 			}else{
  21. 				if( pivote != L->primero ){
  22. 					anterior->siguiente = NULL;
  23. 					free( pivote );
  24. 					L->ultimo = anterior; 				 
  25. 				}else{
  26. 					free( pivote );
  27. 				}
  28. 			} 
  29. 			L->elementos--;
  30. 			if( L->elementos == 0){
  31. 				free( L );
  32. 				return NULL; 
  33. 			}else{
  34. 				return L;
  35. 			}
  36. 		}else{
  37. 			printf( "\n El indice pedido es mayor que los elementos existentes..." );
  38. 			return L;		
  39. 		}
  40. 	}else{
  41. 		printf( "\n No se puede procesar una lista vacia..." );
  42. 		return NULL;	
  43. 	}
  44. }

Saludos.
36  Programación / Programación C/C++ / Ordenar lista simplemente enlazada en lenguaje C. en: 5 Julio 2016, 02:50 am
Hola, que tengas un muy buen día.



En primer lugar, les consulto si la imagen refleja lo que es un nodo, sin tener en cuenta las direcciones de memoria que no necesariamente son continuas como un vector. -
Y la otra duda es, como debo hacer para que la lista quede ordenada. -
Les pediría un pequeño favor mas, si es posible me ayuden con pseudocódigo quiero encarar la solución por mí mismo, luego si se me queman los papeles les pediré algo de código. -

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4.  
  5. struct _agenda{
  6. 	int dato;
  7. 	struct _agenda *siguiente;
  8. };
  9.  
  10. struct _agenda *primero, *ultimo;
  11.  
  12. void mostrar_menu();
  13. void agregar_elemento();
  14. void mostrar_lista();
  15.  
  16. int main(void){
  17. 	char opcion, ch;
  18.  
  19. 	primero = (struct _agenda *) NULL;
  20. 	ultimo = (struct _agenda *) NULL;
  21. 	do{
  22. 		mostrar_menu();
  23. 		opcion = getchar();
  24. 		while((ch = getchar()) != EOF && ch != '\n');
  25. 		switch ( opcion ){
  26. 			case '1': agregar_elemento();
  27. 				break;
  28. 			case '2':  printf("No disponible todavía!\n");
  29. 				break;
  30. 			case '3': mostrar_lista(primero);
  31. 				break;
  32. 			case '4': exit( 1 );
  33. 				default: printf( "Opción no válida\n" );
  34. 					printf( "\n Pulse una tecla para continuar..." ); getchar();
  35. 				break;
  36. 		}
  37. 	} while (opcion!='4');    
  38.  
  39. 	return 0;
  40. }
  41.  
  42.  
  43. void mostrar_menu(){
  44. 	system( "clear" );
  45. 	printf( "\n\n ===== Menu =====" );
  46. 	printf( "\n\n 1 - Agregar elemento" );
  47. 	printf( "\n 2 - Borrar elemento" );
  48. 	printf( "\n 3 - Mostrar elementos" );
  49. 	printf( "\n 4 - Salir" );
  50.  
  51.  	printf("\n\n Escoge una opcion......: ");
  52. }
  53.  
  54. void agregar_elemento(){
  55. 	struct _agenda *nuevo;
  56. 	int ch;
  57.  
  58. 	nuevo = (struct _agenda *) malloc (sizeof(struct _agenda));
  59. 	if( nuevo == NULL){
  60. 		printf(" \n No hay memoria disponible");
  61. 	}
  62. 	printf( "\n ===== Nuevo elemento =====" );
  63. 	printf( "\n Dato.....:" );
  64. 	scanf( "%d", &nuevo->dato );
  65. 	while ((ch = getchar()) != EOF && ch != '\n');
  66.  
  67. 	nuevo->siguiente = NULL;
  68.  
  69. 	if( primero == NULL ){
  70. 		printf( "\n Primer elemento" );
  71. 		primero = nuevo;
  72. 		ultimo  = nuevo;
  73. 	}else{
  74. 		ultimo->siguiente = nuevo;
  75. 		ultimo = nuevo;
  76. 	}
  77. }
  78.  
  79.  
  80. void mostrar_lista(){
  81. 	struct _agenda *auxiliar; /* lo usamos para recorrer la lista */
  82. 	int i=0;
  83.  
  84. 	auxiliar = primero;
  85. 	printf( "\n Mostrando la lista completa:\n ");
  86. 	while( auxiliar != NULL ){
  87. 		printf( "\n Dato....: %d", auxiliar->dato);
  88. 		auxiliar = auxiliar->siguiente;
  89. 		i++;
  90. 	}
  91. 	if( i==0 ){
  92. 		printf( "\n La lista esta vacia!!\n" );
  93. 	} 
  94. 	printf( "\n Pulse una tecla para continuar..." ); getchar();
  95. }

 
Saludos.
37  Programación / Programación C/C++ / Trabajar los campos de una estructura con o sin punteros (ventajas/desventajas) en: 29 Junio 2016, 20:57 pm
Hola, que tengan un muy buen día. -
Tengo una duda con los miembros de las estructuras y es saber si hay alguna diferencia en declararla de una u otra manera, alguna de las 2 ofrece alguna ventaja, es conveniente hacerlo de una manera o de otra o es exactamente lo mismo, debería saber esto cuando estudiaba las cadenas, pero se nota que me lo saltee. -
Se entiende que me refiero a trabajar con o sin punteros. -

Código
  1. typedef struct{
  2. 	char nombre[30];
  3. 	char calle[30];	
  4. 	char ciudad[30];	
  5. 	size_t edad;
  6. }_contacto;

Código
  1. typedef struct{
  2. 	char *nombre;
  3. 	char *calle;	
  4. 	char *ciudad;	
  5. 	size_t edad;
  6. }_contacto;
  7.  

Saludos.
38  Programación / Programación C/C++ / Pasar vector de puntero a char a las funciones[C] en: 20 Junio 2016, 16:14 pm
Hola.
Tengo una duda que deseo evacuarla ahora porque me impide seguir estudiando y es: como se pasan los vectores de punteros a las funciones.

Código
  1. void ingreso( char *ptrFrases );
Código
  1. void ingreso( char ptrFrases[] );
Código
  1. int main( void ){
  2. 	char *ptrFrases = NULL;
  3.  
  4. 	ingreso( ptrFrases );
  5. 	ordenar( ptrFrases );
  6. 	mostrar( ptrFrases );
  7.  
  8. 	return 0;
  9. }
  10.  
Dejo el programa por si les hace falta para interpretar mejor la duda, luego tengo que continuar consultándolos porque la siguiente linea sé que estoy haciendo todo mal pero es la primera vez que lo intento y realmente no logro solucionarlo, hacer lo mismo con números me funciona a la perfección, en cambio, con cadenas no. -

Código
  1. tmp = (char*)realloc( ptrFrases+i, CARACTERES * sizeof(char) );
  2. 	if( tmp!=NULL ){
  3. 		strcpy( ptrFrases[i-1], tmp );
  4. 	}
  5.  

Código
  1. #include <stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4.  
  5. #define CARACTERES 21
  6. #define safeFree(p) saferFree((void**)&(p))
  7.  
  8. void ingreso( char *ptrFrases );
  9. void vaciarBuffer( char tmp[] );	
  10. void ordenar( char *ptrFrases );
  11. void mostrar( char *ptrFrases );
  12. void saferFree( void **pp );
  13.  
  14. int main( void ){
  15. 	char *ptrFrases = NULL;
  16.  
  17. 	ingreso( ptrFrases );
  18. 	ordenar( ptrFrases );
  19. 	mostrar( ptrFrases );
  20.  
  21. 	return 0;
  22. }
  23.  
  24.  
  25. void ingreso( char *ptrFrases ){
  26. 	int i = 0, ok, opc;
  27. 	char tmp[CARACTERES], ch;
  28.  
  29. 	while( 1 ){
  30. 		printf( "\n Ingrese una palabra(maximo %d caracteres).....:", CARACTERES-1 );
  31. 		fgets( tmp, CARACTERES, stdin );
  32. 		vaciarBuffer( tmp );	
  33.  
  34. 		do{
  35. 			printf( "\n 1 - Ingresa otra frase\n 0 - Finalisa\n Ingrese opcion...: " );
  36. 			ok = scanf( "%d", &opc ) == 1 && opc >= 0 && opc <=1;
  37. 			while ((ch = getchar()) != EOF && ch != '\n'); 
  38. 		}while( !ok );
  39. 		if( opc == 0){
  40. 			break;	
  41. 		}
  42. 		i++;
  43. 		tmp = (char*)realloc( ptrFrases+i, CARACTERES * sizeof(char) );
  44. 		if( tmp!=NULL ){
  45. 			strcpy( ptrFrases[i-1], tmp );
  46. 		}
  47. 		else{
  48. 			safeFree( ptrFrases );
  49. 			puts( "Error (re)allocating memory" );
  50. 			exit(1);
  51. 		}
  52. 	}	
  53.  
  54. }
  55.  
  56. void vaciarBuffer( char tmp[] ){
  57. 	char *p = NULL;
  58. 	size_t ch;
  59.  
  60. 	if((p=strchr(tmp, '\n'))){
  61. 		*p='\0';
  62. 	}
  63. 	else{
  64. 		while((ch = getchar()) !='\n' && ch!=EOF);
  65. 	}			
  66. }
  67.  
  68. void saferFree(void **pp) {
  69. 	if (pp != NULL && *pp != NULL) {
  70. 		free(*pp);
  71. 		*pp = NULL;
  72. 	}
  73. }
  74.  
  75. void ordenar( char *ptrFrases ){
  76. 	printf( "\n No desarrollado" );	
  77. }
  78. void mostrar( char *ptrFrases ){
  79. 	printf( "\n No desarrollado" );	
  80. }
  81.  
Saludos y gracias. -
39  Programación / Programación C/C++ / Concatenar cadenas con memoria dinámica en lenguaje C. en: 19 Junio 2016, 14:33 pm
Hola, gente.
Les quito un poco de tiempo porque si bien estoy leyendo que es lo que causa el doble free no logro solucionarlo por mí mismo y si lo lograra me quedarían dudas en la función concatenar, les digo esto porque si bien logre que no me diera error en la compilación lo hice a fuerza de prueba/error/solución pero no teniendo claro que es lo que estaba haciendo. -
Las cosas que no me quedan claras:

1): Porque debo hacer que la función se declare como un puntero a función.
2): Porque el error del doble free.
3): Como se hace para poner un espacio entre las dos frases (por programación, claro).-
  
Código
  1. #include <stdio.h>
  2. #include<string.h>
  3. #include<stdlib.h>
  4.  
  5. #define MAX 51
  6.  
  7. void ingreso( char origUno[], char origDos[] );
  8. void limpiarBuffer( char cadena[] );
  9. char *concatenar( char *origUno, char *origDos );
  10.  
  11. int main( void ){
  12. 	char origUno[MAX] = "", origDos[MAX] = "", *ptrConc = NULL;
  13.  
  14. 	ingreso( origUno, origDos );		
  15. 	ptrConc = concatenar( origUno, origDos );
  16.  
  17. 	printf("\n %s", ptrConc);
  18.  
  19. 	free(ptrConc);
  20.  
  21. 	return 0;
  22. }
  23.  
  24. void ingreso( char origUno[], char origDos[] ){
  25.  
  26. 	printf( "\n Ingrese una frase(maximo %d caracteres)............:", MAX-1 );
  27. 	fgets(origUno, MAX, stdin);
  28. 	limpiarBuffer( origUno );
  29.  
  30. 	printf( "\n Ingrese frase a concatenar (maximo %d caracteres)..:", MAX-1 );
  31. 	fgets(origDos, MAX, stdin);
  32. 	limpiarBuffer( origDos );
  33. }
  34.  
  35. void limpiarBuffer( char cadena[] ){
  36. 	char *p = NULL;
  37. 	size_t ch;
  38.  
  39. 	if((p=strchr(cadena, '\n'))){
  40. 		*p='\0';
  41. 	}
  42. 	else{
  43. 		while((ch = getchar()) !='\n' && ch!=EOF);
  44. 	}	
  45. }
  46.  
  47. char *concatenar( char *origUno, char *origDos ){
  48. 	size_t totCarac = strlen( origUno ) + strlen( origDos ) + 1;
  49. 	char *arr = ( char* )malloc( totCarac * sizeof(char) ); 
  50. 	arr = strcat( origUno, origDos ); 
  51.  
  52. 	return arr;
  53. }
  54.  

Saludos y desde ya muchas gracias. -
40  Programación / Programación C/C++ / matriz de punteros de una dimensión - liberar memoria[C] en: 10 Junio 2016, 21:28 pm
Hola, gente.
Tengo una pequeña duda con él programara que dejo a continuación y es si esta bien liberada la memoria. -

Código
  1. /*
  2.  matriz de punteros de una dimensión. 
  3. */
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <time.h>
  8.  
  9. #define MAX 5
  10.  
  11. int main(void) {
  12. 	int *arr[MAX], i;
  13. 	srand(time(NULL));
  14.  
  15. 	for( i=0; i<MAX; i++ ){
  16. 		*(arr+i) = (int*)malloc(sizeof(int));
  17. 		**(arr+i) = rand() % 100;
  18. 		printf( "\n %d", **(arr+i) );
  19. 	}
  20. 	for( i=0; i<MAX; i++ ){
  21. 		free(*(arr+i));
  22. 	}
  23.  
  24.  
  25. 	return 0;
  26.  
  27. }
Si tienen tiempo y lo desearían necesitaría un poco de teoría al respecto si esta mal como si estuviera bien. -
Saludos y desde muchas gracias como siempre.-
Páginas: 1 2 3 [4] 5 6 7 8 9 10
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines