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 Mensajes
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 [14] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 ... 37
131  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. -
132  Programación / Programación C/C++ / Re: Borrar nodo en lista simplemente enlazada[C] en: 28 Julio 2016, 14:22 pm
Hola, que tengan un muy buen día. -
Alberto, muchas gracias funcionan a la perfección, me queda un consuelo que no estaba tan errado, solo me queda ahora lidiar con que el nodo a borrar no sea ni el primero ni el último. -

Un abrazo.

==================== EDITO ====================
Bueno al fin lo logre, por lo menos para mí no da ningún error, dejo la función borrar completa por si alguien la quiere consultar o corregir. -

Código
  1. struct lista *borrar( struct lista *L, struct nodo *borrar ){
  2.  
  3. 	if( L->elementos == 1 ){				//LSE001
  4. 		L = NULL;
  5. 		free( borrar );
  6. 	}
  7. 	else if( L->primero == borrar ){		//LSE002
  8. 		L->primero = borrar->siguiente;		//LSE003	
  9. 		L->elementos--;
  10. 		free( borrar );
  11. 	}	
  12. 	else if( borrar->siguiente == NULL){	//LSE004
  13. 		struct nodo *aux = L->primero;
  14.  
  15. 		while( aux->siguiente != borrar ){
  16. 			aux = aux->siguiente;
  17. 		}
  18. 		//LSE005
  19. 		L->ultimo = aux;					//LSE006
  20. 		L->elementos--;
  21. 		aux->siguiente = NULL;				//LSE007
  22. 		free( borrar );
  23. 	}
  24. 	else{									//LSE008
  25. 		struct nodo *aux = L->primero;
  26.  
  27. 		while( aux->siguiente != borrar ){	//LSE009
  28. 			aux = aux->siguiente;
  29. 		}
  30. 		aux->siguiente = borrar->siguiente;	//LSE010
  31. 		L->elementos--;						//LSE011
  32. 		free( borrar );						//LSE012	
  33. 	}
  34. 	return L;
  35. }
  36.  
  37. /*
  38. 	=============================== Ayuda ===============================
  39.  
  40. 	LSE001	Verificamos si la cantidad de ingresos es un solo dato, de ser así con L = NULL
  41. 			inicializamos toda la lista a cero, pero permanece en memoria para nuevos ingresos.
  42.  
  43. 	LSE002	En caso de no ser el único ingreso verificamos si es el primer Nodo,   
  44. 	LSE003	De ser así igualamos el primer Nodo a borrar->siguiente, de esa manera el que
  45. 			era el segundo pasa a ser el primero Nodo y el primero es borrado.  
  46.  
  47. 	LSE004	A esta altura el nodo a borrar es el último.
  48. 	LSE005	A esta altura el nodo aux es el penultimo.
  49. 	LSE006	El que antes era penúltimo ahora será el último.
  50. 	LSE007	El apuntador siguiente del último Nodo debe de apuntar a NULL.
  51.  
  52. 	LSE008	Por último, llegamos a este else porque el Nodo a borrar no es el único
  53. 			ni es el primero ni es el último, se encuentra entre estos dos.
  54.  
  55. 	LSE009	Con este bucle obtenemos la dirección de memoria donde está el nodo anterior 
  56. 			al que queremos borrar.
  57. 	LSE010	aux->siguiente ahora ya no apunta al Nodo siguiente que es el que queremos borrar	
  58. 			apunta al Nodo siguiente al que borraremos.
  59. 	LSE011	Decrementamos el contador de nodos.			
  60. 	LSE012	Liberamos memoria.			
  61. */  
133  Programación / Programación C/C++ / Re: Borrar nodo en lista simplemente enlazada[C] en: 28 Julio 2016, 02:37 am
Hola.
ivancea96 mucha gracia por ocuparte, con respecto a lo primero era para confirmar que estaba en lo cierto, no te olvides que estoy aprendiendo y necesitaba saber si las validaciones eran lo suficiente para hacer que el programa diera resultados correctos. -
Bueno ahora tengo inconvenientes desde la línea 230 a la 239, ¿alguien me podría dar una mano con esto? . -
El programa no me da ningún error, pero el resultado es incorrecto. -
Si el ingreso es 1 3 5 y trato de borrar el último nodo me da como resultado 1 3 0. -
El programa lo pongo completo porque tuve que efectuar algunas modificaciones. -

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. struct lista *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. struct lista *buscar( struct lista *L );
  24. void modificar( struct nodo *pivote );
  25. struct lista *borrar( struct lista *L, struct nodo *borrar );
  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: Lista = 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. struct lista *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: L = borrar( L, N );
  85. 				opc=3;
  86. 				break;
  87. 			case 3:
  88. 				break;
  89. 		}
  90. 	}while( opc != 3 );
  91.  
  92. 	return L;
  93. }
  94.  
  95. void limpiar( void ){
  96. 	system("cls||clear");	
  97. }
  98.  
  99. struct lista *agregar( struct lista *L ){
  100. 	int ok, ch, dto; 
  101.  
  102. 	do{
  103. 		limpiar();
  104. 		printf( "\n Ingrese dato (mayor a 0 y menor a %d)....: ", INT_MAX );	
  105. 		ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;
  106. 		while ((ch = getchar()) != EOF && ch != '\n'); 
  107. 	}while( !ok );
  108.  
  109. 	if( L != NULL ){
  110. 		struct nodo *e = crear( dto );
  111. 		L->ultimo->siguiente = e;
  112. 		L->ultimo = e;
  113. 		L->elementos++;
  114. 		return L;
  115. 	}else{
  116. 		struct nodo *e = crear( dto );
  117. 		struct lista *l = calloc( sizeof( struct lista ), 1 );
  118. 		l->primero = e;
  119. 		l->ultimo = e;
  120. 		l->elementos = 1;
  121. 		return l;
  122. 	}
  123. }
  124.  
  125. struct nodo *crear( int dato ){
  126. 	struct nodo *e = calloc( sizeof( struct nodo), 1 );
  127. 	e->dato = dato;
  128. 	e->siguiente = NULL;
  129.  
  130. 	return e;	
  131. }
  132.  
  133. void mostrar( struct lista *L ){
  134. 	struct nodo *auxiliar;
  135. 	int i=0;
  136.  
  137. 	if( L != NULL ){
  138. 		auxiliar = L->primero;
  139. 		while( auxiliar != NULL ){
  140. 			printf( "\n %d", auxiliar->dato );
  141. 			auxiliar = auxiliar->siguiente;
  142. 			i++;	
  143. 		}
  144. 	}else{
  145. 		printf( "\n La lista esta vacia..." );	
  146. 	}
  147.  
  148. 	printf( "\n Pulse una tecla para continuar..." );getchar();
  149. }
  150.  
  151. void ordenar( struct lista *L ){
  152. 	struct nodo *pivote = NULL, *actual = NULL;		
  153. 	int tmp;
  154.  
  155. 	if( L != NULL ){
  156. 		pivote = L->primero;	
  157. 		while( pivote != L->ultimo ){
  158. 			actual = pivote->siguiente;	
  159. 			while( actual != NULL ){
  160. 				if( pivote->dato > actual->dato ){
  161. 					tmp = pivote->dato;	
  162. 					pivote->dato = actual->dato;
  163. 					actual->dato = tmp;
  164. 				}	
  165. 				actual = actual->siguiente;
  166. 			}
  167. 			pivote = pivote->siguiente;
  168. 		}
  169. 		mostrar( L );	
  170. 	}else{
  171. 		printf( "\n La lista esta vacia..." );	
  172. 		printf( "\n Pulse una tecla para continuar..." );getchar();
  173. 	}
  174. }
  175.  
  176. struct lista *buscar( struct lista *L ){
  177. 	int ok, ch, dto, i=0; 
  178. 	struct nodo *pivote = NULL;
  179.  
  180. 	if( L != NULL ){
  181. 		do{
  182. 			limpiar();
  183. 			printf( "\n Ingrese el dato a buscar....: " );	
  184. 			ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;
  185. 			while ((ch = getchar()) != EOF && ch != '\n'); 
  186. 		}while( !ok );
  187.  
  188. 		pivote = L->primero;
  189. 		while( pivote != NULL ){
  190. 			if( pivote->dato == dto  ){
  191. 				L = menuUno( L, pivote );
  192. 				i++;
  193. 				break; 	
  194. 			}
  195. 			pivote = pivote->siguiente;
  196. 		}
  197. 		if( i == 0 ){
  198. 			printf( "\n El dato no existe..." );	
  199. 			printf( "\n Pulse una tecla para continuar..." );getchar();
  200. 		}
  201. 	}else{
  202. 		printf( "\n La lista esta vacia..." );	
  203. 		printf( "\n Pulse una tecla para continuar..." );getchar();
  204. 	}			
  205. 	return L;
  206. }
  207.  
  208. void modificar( struct nodo *pivote ){
  209. 	int ok, ch, dto; 
  210.  
  211. 	do{
  212. 		limpiar();
  213. 		printf( "\n Dato a modificar.....: %d \n Ingrese nuevo dato...: ", pivote->dato );	
  214. 		ok = scanf( "%d", &dto ) == 1 && dto >0 && dto <= INT_MAX;
  215. 		while ((ch = getchar()) != EOF && ch != '\n'); 
  216. 	}while( !ok );
  217. 	pivote->dato = dto;
  218. }
  219.  
  220. struct lista *borrar( struct lista *L, struct nodo *borrar ){
  221.  
  222. 	if( L->elementos == 1 ){
  223. 		L = NULL;
  224. 	}
  225. 	else if( borrar == L->primero){
  226. 		L->primero = borrar->siguiente;	
  227. 		L->elementos--;
  228. 		free( borrar );
  229. 	}	
  230. 	else if( borrar->siguiente == NULL){
  231. 		struct nodo *aux = L->primero;
  232. 		while( aux->siguiente != NULL ){
  233. 			aux = aux->siguiente;
  234. 		}	
  235. 		L->ultimo = aux;
  236. 		L->elementos--;
  237. 		aux->siguiente = NULL; 
  238. 		free( aux );
  239. 	}	
  240. 	else{
  241. 		printf( "\n Esta entre el primer dato y el ultimo..." );
  242. 	}
  243. 	return L;
  244. }
  245.  

Saludos y desde ya muchas gracias. -
134  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.
135  Programación / Programación C/C++ / Re: Crear un array de caracteres mediante una funcion. en: 21 Julio 2016, 16:29 pm
Hola.

Código
  1. void limpiarBuffer( char cadena[] ){
  2. 	char *p = NULL; 
  3. 	size_t ch;
  4.  
  5. 	if((p=strchr(cadena, '\n'))){ //LB01
  6. 		*p='\0';					
  7. 	}						
  8. 	else{
  9. 		while((ch = getchar()) !='\n' && ch!=EOF);  //LB02
  10. 	}	
  11. }

/*
LB01
   strchr busca un carácter dentro de una cadena, si lo encuentra devuelve la dirección en memoria
    donde se encuentra el carácter , en este caso '\n' (Enter) si lo encuentra lo remplaza por '\0' que es el carácter que marca el final de cadena en C.

LB02
   Si no lo encuentra es que en el buffer del teclado han quedado caracteres sin leer, con este bucle
   y la función getchar el buffer queda limpio, sin nada pendiente de lectura.-

Faltaria explicarte que pasa si el buffer queda con pendientes pero eso lo tengo entendido pero no me da para explicartelo.

Saludos.
136  Programación / Programación C/C++ / Re: Crear un array de caracteres mediante una funcion. en: 21 Julio 2016, 15:40 pm
Hola.
No tengo tiempo en este momento para explicarte soble esa función, pero fíjate que tiene mucho que ver con la imagen.



Saludos.
137  Programación / Programación C/C++ / Re: segmentation fault al mostrar lista simplemente ligada en lenguaje C. en: 20 Julio 2016, 17:03 pm
Hola.
Gracias, ya lo logre, juraría que en un momento lo intente de la manera que tú dices, pero algún otro error seguramente estaba cometiendo.

Código
  1. void mostrar( struct lista *L ){
  2. 	struct nodo *auxiliar;
  3. 	int i=0;
  4.  
  5. 	if( L != NULL ){
  6. 		auxiliar = L->primero;
  7. 		while( auxiliar != NULL ){
  8. 			printf( "\n %d", auxiliar->dato );
  9. 			auxiliar = auxiliar->siguiente;
  10. 			i++;	
  11. 		}
  12. 	}else{
  13. 		printf( "\n La lista esta vacia..." );	
  14. 	}
  15.  
  16. 	printf( "\n Pulse una tecla para continuar..." );getchar();
  17. }

Gracias Alberto y un abrazo.
138  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.
139  Programación / Programación C/C++ / Re: Documentar función para borrar nodo según petición del usuario en C. en: 16 Julio 2016, 02:59 am
Hola.
Mil disculpas por el error, que daría yo para encontrar ej. en la web tan bien documentados. -
Te debo una picada completa con cerveza, una lástima que tengas que comer vos solo porque yo hace muchos años que soy vegetariano. -

Saludos.
140  Programación / Programación C/C++ / Re: Documentar función para borrar nodo según petición del usuario en C. en: 15 Julio 2016, 14:31 pm
Hola, Alberto. -
Realmente hasta ayer no comprendía cuál ligado esta un papel y un lápiz y la programación, muchas gracias por el aporte. -
Ahora una duda que tengo con la siguientes líneas de código:
Que diferencias hay en declarar los punteros a la estructura de una u otra manera, leí por allí que no se debería declarar una nueva estructura que no era necesario o no era conveniente, no recuerdo. - 

Código
  1. struct lista{
  2. 	struct nodo *primero;
  3. 	struct nodo *ultimo;
  4. 	struct nodo *elementos;
  5. }
  6.  
Código
  1. struct lista *primero, *ultimo;

Saludos.
Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 [14] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 ... 37
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines