Foro de elhacker.net

#include <stdio.h>
#include <stdlib.h>
 
 
struct _agenda{
	int dato;
	struct _agenda *siguiente;
};
 
struct _agenda *primero, *ultimo;
 
void mostrar_menu();
void agregar_elemento();
void mostrar_lista();
 
int main(void){
	char opcion, ch;
 
	primero = (struct _agenda *) NULL;
	ultimo = (struct _agenda *) NULL;
	do{
		mostrar_menu();
		opcion = getchar();
		while((ch = getchar()) != EOF && ch != '\n');
		switch ( opcion ){
			case '1': agregar_elemento();
				break;
			case '2':  printf("No disponible todavía!\n");
				break;
			case '3': mostrar_lista(primero);
				break;
			case '4': exit( 1 );
				default: printf( "Opción no válida\n" );
					printf( "\n Pulse una tecla para continuar..." ); getchar();
				break;
		}
	} while (opcion!='4');    
 
	return 0;
}
 
 
void mostrar_menu(){
	system( "clear" );
	printf( "\n\n ===== Menu =====" );
	printf( "\n\n 1 - Agregar elemento" );
	printf( "\n 2 - Borrar elemento" );
	printf( "\n 3 - Mostrar elementos" );
	printf( "\n 4 - Salir" );
 
 	printf("\n\n Escoge una opcion......: ");
}
 
void agregar_elemento(){
	struct _agenda *nuevo;
	int ch;
 
	nuevo = (struct _agenda *) malloc (sizeof(struct _agenda));
	if( nuevo == NULL){
		printf(" \n No hay memoria disponible");
	}
	printf( "\n ===== Nuevo elemento =====" );
	printf( "\n Dato.....:" );
	scanf( "%d", &nuevo->dato );
	while ((ch = getchar()) != EOF && ch != '\n');
 
	nuevo->siguiente = NULL;
 
	if( primero == NULL ){
		printf( "\n Primer elemento" );
		primero = nuevo;
		ultimo  = nuevo;
	}else{
		ultimo->siguiente = nuevo;
		ultimo = nuevo;
	}
}
 
 
void mostrar_lista(){
	struct _agenda *auxiliar; /* lo usamos para recorrer la lista */
	int i=0;
 
	auxiliar = primero;
	printf( "\n Mostrando la lista completa:\n ");
	while( auxiliar != NULL ){
		printf( "\n Dato....: %d", auxiliar->dato);
		auxiliar = auxiliar->siguiente;
		i++;
	}
	if( i==0 ){
		printf( "\n La lista esta vacia!!\n" );
	} 
	printf( "\n Pulse una tecla para continuar..." ); getchar();
}

void ordenar_lista( size_t cont){
	struct _agenda *auxiliar; //LsE008
	int tmp[cont], aux, i=0, j;
	auxiliar = primero;
 
	if( cont>1 ){ //LsE009
		printf( "\n Mostrando la lista ORDENADA (total %lu):\n ", cont);
		while( auxiliar != NULL ){
			tmp[i] = auxiliar->dato;
			auxiliar = auxiliar->siguiente;
			i++;
		}
 
		//LsE010
		for(i=0; i<cont-1; i++) {
			for(j=i+1; j<cont; j++) {
				if( tmp[i] > tmp[j] ){
					aux = tmp[i];
					tmp[i] = tmp[j];
					tmp[j] = aux;
				}
			}
		}
 
		for( i=0; i<cont; i++ ){
			printf( "\n %d", tmp[i] );	
		}	
		printf( "\n\n Pulse una tecla para continuar..." ); getchar();
	}else{
		printf( "\n No cuenta con suficientes elementos para ordenar.\n\n" 	
				" Pulse una tecla para continuar..."); getchar();
	}
}
 
 
 
/*	================ Ayuda ================
 
	LsE001 -> Con esta función añadimos un elemento al final de la lista. 
	LsE002 -> reservamos memoria para el nuevo elemento.
	LsE003 -> El campo siguiente va a ser NULL por ser el último elemento.
	LsE004 -> ahora metemos el nuevo elemento en la lista. lo situamos al final de la lista comprobamos
			  si la lista está vacía. si primero==NULL es que no hay ningún elemento en la lista.
	LsE005 -> El que hasta ahora era el último tiene que apuntar al nuevo.
	LsE006 -> Hacemos que el nuevo sea ahora el último.
	LsE007 -> Lo usamos para recorrer la lista.
	LsE008 -> Lo usamos para recorrer la lista
	LsE009 -> Verificamos si hay más de 1 dato para ordenar. de ser asi ponemos los datos
			  en un vector.
	LsE010 -> Ordenamos el vector.
*/

//Destruir una lista
void destruir_lista(struct _agenda *primero){
struct _agenda *pivote,*auxiliar  =primero;
while( auxiliar != NULL ){
			pivote = auxiliar->siguiente;
			free(auxiliar);
			auxiliar = pivote;
		}
 

int tmp[cont];

int tmp[cont];

#include <stdio.h>
 
int main()
{
    size_t n;
 
    printf("Ingresar longitud: ");
    scanf("%d", &n);
 
    int array[n];
 
    for(int i = 0; i < n; i++)
    {
	 array[i] = i + 1;
	 printf("%4d ", array[i]);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
 
//LsL001
 
struct nodo{
	int dato;
	struct nodo *siguiente;	
};
 
struct lista{
	struct nodo *primero;
	struct nodo *ultimo;
};
 
struct lista *agregar( struct lista *L, int dato );
struct nodo *crear( int dato );
 
int main( void ){
	struct lista *Lista = NULL;
 
	Lista = agregar( Lista, 1 );
	Lista = agregar( Lista, 2);
	Lista = agregar( Lista, 3);
 
	return 0;
}
 
struct lista *agregar( struct lista *L, int dato ){
	if( L != NULL ){
		struct nodo *e = crear( dato );
		printf( "\n Creando elemento con valor %d", dato );
		L->ultimo->siguiente = e;
		L->ultimo = e;
 
		return L;	
	}else{
		struct nodo *e = crear( dato );
		struct lista *l = calloc( sizeof( struct lista ), 1 );
		printf( "\n Inicializando la lista con valor %d", dato );
		l->primero = e;
		l->ultimo = e;
 
		return l;
	}
}
 
struct nodo *crear( int dato ){
	struct nodo *e = calloc( sizeof( struct nodo), 1 );
	e->dato = dato;
	e->siguiente = NULL;
 
	return e;	
}
 
/*
	============================== LsL001 ==============================
		- Definir estructura.
		- Inicializar.	
		- Agregar elementos.
		- Ordenar elementos.
		- Borrar elementos. 
 */

//While o for aquí 
//guardar valores de actual y siguiente
if(pivote->dato > actual->dato){
//hacer cambio de variable aqui.
}
//fin while o for
 

/*
Variable Entera
tmp
 
Variables Nodos:
Pivote									
Actual
 
Lista:
[200]->[150]->[100]->[50]->[0]->[40]->NULL
Primero                         Ultimo
*/
 

for(i=0; i<cont-1; i++) {
	for(j=i+1; j<cont; j++) {
		if( tmp[i] > tmp[j] ){
			aux = tmp[i];
			tmp[i] = tmp[j];
			tmp[j] = aux;
		}
	}
}
 

void ordenar_lista(struct lista *L)	{
	//Elegir metodo de ordenamiento
	// Burbuja
	struct nodo *pivote = NULL,*actual = NULL;
	int tmp;
	if(L != NULL)	{
 
		pivote = L->primero;		//i = 0
		while(pivote != L->ultimo)	{	//for(i=0; i<cont-1; i++) {
			actual = pivote->siguiente;	//j=i+1
			while(actual != NULL)	{	//for(j=i+1; j<cont; j++) {
				if(pivote->dato > actual->dato)	{	//if( tmp[i] > tmp[j] ){
					tmp = pivote->dato;	//aux = tmp[i];
					pivote->dato = actual->dato;	//tmp[i] = tmp[j];
					actual->dato = tmp;	//tmp[j] = aux;
				}
				actual = actual->siguiente;	//j++
			}
			pivote = pivote->siguiente;	//i++
		}
	}
	else	{
		printf("Error lista no inicializada");
	}
	/*
	Pivote									
	Actual
	[200]->[150]->[100]->[50]->[0]->[40]->NULL
	Primero                         Ultimo
 
	*/
}

• Si usas calloc, no se inicializa en NULL el elemento siguiente
• Si usas malloc, es necesario inicializar el elemento en NULL

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
struct nodo	{
	int dato;
	struct nodo *siguiente;
};
 
struct lista	{
	struct nodo *primero;
	struct nodo *ultimo;
	int elementos;
};
 
struct lista *agregar_elemento(struct lista *L, int dato);
struct nodo *crear_elemento(int dato);
void ordenar_lista(struct lista *L);
struct lista *eliminar_indice(struct lista *L, int indice);
int obtener_indice(struct lista *L,int indice);
 
int main()	{
	struct lista *Lista = NULL;
	int i = 0;
	srand(time(NULL));
	while(i < 30)	{
		Lista = agregar_elemento(Lista,rand() % 1000);
		i++;
	}
	ordenar_lista(Lista);
	i = 0;
	while(i < 30)	{
		printf("Elemento %i: %i\n",i+1,obtener_indice(Lista,i+1));
		i++;
	}
 
	/*
	Lista = agregar_elemento(Lista,2);
	Lista = agregar_elemento(Lista,3);
	Lista = eliminar_indice(Lista,3);
	Lista = eliminar_indice(Lista,2);
	Lista = eliminar_indice(Lista,1);
	printf("apuntador de la lista %p\n",Lista);
	Lista = eliminar_indice(Lista,1);
	*/
	return 0;
}
 
struct lista *agregar_elemento(struct lista *L, int dato)	{
	if(L != NULL)	{
 
	struct nodo *e = crear_elemento(dato);
		printf("Creando elemento con valor %i\n",dato);
		L->ultimo->siguiente = e;
		L->ultimo = e;
		L->elementos++;
		return L;
	}
	else	{
		struct nodo *e = crear_elemento(dato);
		struct lista *l = calloc(sizeof(struct lista),1);
		printf("Inicializando lista con valor %i\n",dato);
		l->primero = e;
		l->ultimo = e;
		l->elementos++;
		return l;
	}
}
 
struct nodo *crear_elemento(int dato)	{
	struct nodo *e = calloc(sizeof(struct nodo),1);
	e->dato = dato;
	e->siguiente = NULL; //Fines didacticos ya que Calloc devuelve en 0
	return e;
}
 
struct lista *eliminar_indice(struct lista *L, int indice)	{
	if(L != NULL)	{
		if(indice <= L->elementos && indice > 0)	{
			struct nodo *anterior = L->primero;
			struct nodo *pivote = L->primero;
			int i = 1;
			//printf("while");
			while(i < indice)	{
				//printf("Elemento actual %i\n",pivote->dato);
				anterior = pivote;
				pivote = pivote->siguiente;
				i++;
			}
			//pivote ya tiene el elemento a eliminar
			printf("Elemento a eliminar %i\n",pivote->dato);
			if(pivote->siguiente != NULL)	{
				printf("NO el ultimo elemento\n",pivote->dato);
				if(pivote != L->primero)	{
					printf("Y no es el primero\n");
					anterior->siguiente = pivote->siguiente;
					free(pivote);
				}
				else	{
					printf("Si es el primero\n");
					L->primero = pivote->siguiente;
					free(pivote);
				}
			}
			else	{
				printf("Es el ultimo elemento\n",pivote->dato);
				if(pivote != L->primero )	{
					anterior->siguiente = NULL;
					free(pivote);
					L->ultimo = anterior;
				}
				else	{
					printf("Y tamien es el primero\n");
					free(pivote);					
				}
			}
			L->elementos--;
			if(L->elementos == 0)	{
				printf("Eliminando Lista\n");
				free(L);
				return NULL;
			}
			else	{
				return L;
			}
		}
		else	{
			printf("El indice pedido es mayor que los elementos existentes\n");
			return L;			
		}
	}
	else	{
		printf("No se puede procesar una lista NO inicializada\n");
		return NULL;}
}
 
void ordenar_lista(struct lista *L)	{
	//Elegir metodo de ordenamiento
	// Burbuja
	struct nodo *pivote = NULL,*actual = NULL;
	int tmp;
	if(L != NULL)	{
 
		pivote = L->primero;		//i = 0
		while(pivote != L->ultimo)	{	//for(i=0; i<cont-1; i++) {
			actual = pivote->siguiente;	//j=i+1
			while(actual != NULL)	{	//for(j=i+1; j<cont; j++) {
				if(pivote->dato > actual->dato)	{	//if( tmp[i] > tmp[j] ){
					tmp = pivote->dato;	//aux = tmp[i];
					pivote->dato = actual->dato;	//tmp[i] = tmp[j];
					actual->dato = tmp;	//tmp[j] = aux;
				}
				actual = actual->siguiente;	//j++
			}
			pivote = pivote->siguiente;	//i++
		}
	}
	else	{
		printf("Error lista no inicializada");
	}
	/*
	Pivote									
	Actual
	[200]->[150]->[100]->[50]->[0]->[40]->NULL
	Primero                         Ultimo
 
	*/
}
 
int obtener_indice(struct lista *L,int indice)	{
	struct nodo *aux;
	int i = 1;
	aux = L->primero;
	while(i < indice)	{
		aux = aux->siguiente;
		i++;
	}
	return aux->dato;
}

int insertar_nodo_arbol(tuestruct *dato, int (*cmp)(struct1,struct2));
 

int intcmp(int a, int b)
{
    return a-b;
}
 

struct Cosa
{
    int x;
    char *s;
};
 
int cmp_cosa_int(struct Cosa *a, struct Cosa *b)
{
    return a->x - b->x;
}
 
int cmp_cosa_str(struct Cosa *a, struct Cosa *b)
{
    return strcmp(a->s , b->s);
}
 

int insertar_nodo_arbol(struct Cosa **raiz, struct Cosa *dato, int (*cmp)(struct Cosa *, struct Cosa *))
{
    //...
}
 

#include <stdio.h>
#include <stdlib.h>
 
struct nodo{
	int dato;
	struct nodo *siguiente;	
};
 
struct lista{
	struct nodo *primero;
	struct nodo *ultimo;
};
 
struct lista *ingresos( struct lista *L );
struct lista *agregar( struct lista *L, int dato );
struct nodo *crear( int dato );
struct lista *ordenar(struct lista *L);
void mostrar(struct lista *L);
 
 
int main( void ){
	struct lista *Lista = NULL;
 
	Lista = ingresos( Lista );
	Lista = ordenar( Lista );
	mostrar( Lista );
 
	free(Lista);
	return 0;
}
 
struct lista *ingresos( struct lista *L ){
	int i;
 
	for( i=8; i>0; i-- ){
		printf( "\n %d", i );
		L = agregar( L, i );
	}	
 
	return L;
}
 
 
struct lista *agregar( struct lista *L, int dato ){
	if( L != NULL ){
		struct nodo *e = crear( dato );
		L->ultimo->siguiente = e;
		L->ultimo = e;
 
		return L;	
	}else{
		struct nodo *e = crear( dato );
		struct lista *l = calloc( sizeof( struct lista ), 1 );
		l->primero = e;
		l->ultimo = e;
 
		return l;
	}
}
 
struct nodo *crear( int dato ){
	struct nodo *e = calloc( sizeof( struct nodo), 1 );
	e->dato = dato;
	e->siguiente = NULL;
 
	return e;	
}
 
struct lista *ordenar(struct lista *L){
	struct nodo *pivote = NULL,*actual = NULL;
	int tmp;
	if(L != NULL){
		pivote = L->primero;
		while(pivote != L->ultimo){
			actual = pivote->siguiente;
			while(actual != NULL){
				if(pivote->dato > actual->dato){
					tmp = pivote->dato;
					pivote->dato = actual->dato;
					actual->dato = tmp;
				}
				actual = actual->siguiente;
    		}
			pivote = pivote->siguiente;
    	}
	}
   	else{
    	printf("Error lista no inicializada");
    }
	return L;
}
 
void mostrar(struct lista *L){
	struct nodo *auxiliar;
	int i=0;
	auxiliar = L->primero;
 
    printf("\n\n Mostrando lista ordenada:\n");
 
	while (auxiliar!=NULL) {
		printf( "\n %d", auxiliar->dato);
		auxiliar = auxiliar->siguiente;
		i++;
	}
	if (i==0) printf( "\nLa lista está vacía!!\n" );		
}