//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 *))
{
    //...
}