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. -

struct lista *eliminarIndice( struct lista *L, int indice){
	int i = 1;
	if( L != NULL ){									// Verificamos que la lista no este vacia.
		if( indice <= 10 && indice > 0){						// Si indice es mayor a cero y menor o igual a la cant. de elemento continuamos.  
			struct nodo *anterior = L->primero;					// Grabamos en anterior la direc. del primer nodo.
			struct nodo *pivote = L->primero;					// Y lo mismo con pivote.
			while( i < indice ){							// Bucle para.... 
				anterior = pivote;
				pivote = pivote->siguiente;
				i++;
			}
			if( pivote->siguiente != NULL ){
				if( pivote->siguiente != L->primero ){
					anterior->siguiente = pivote->siguiente;
					free( pivote );				 
				}else{
					L->primero = pivote->siguiente;
					free( pivote );				 
				}
			}else{
				if( pivote != L->primero ){
					anterior->siguiente = NULL;
					free( pivote );
					L->ultimo = anterior; 				 
				}else{
					free( pivote );
				}
			} 
			L->elementos--;
			if( L->elementos == 0){
				free( L );
				return NULL; 
			}else{
				return L;
			}
		}else{
			printf( "\n El indice pedido es mayor que los elementos existentes..." );
			return L;		
		}
	}else{
		printf( "\n No se puede procesar una lista vacia..." );
		return NULL;	
	}
}

Saludos.

Hola, Alberto. -
Ya cambie la función para que no devuelva ningún valor (void) y funciona de maravilla, también debo agradecerte porque hiciste que me cayera la ficha, ahora si entiendo como funciona. -

Un abrazo.

Hola, buen día. -
Todavía no llegue a leer sobre arboles binarios solo sé que está dentro del capitulo que estoy estudiando, igual ya hice un enlace en mis apuntes para cuando llegue al tema tratar de interpretar tu propuesta. -
La consulta que les voy a efectuar tal vez les resulte infantil, pero créanme que hace más de un día que intento interpretar como funciona pero no hay caso. -
Les pregunto en que lugar de la función ordenar se modifica la estructura nodo, hay 2 punteros a estructura pivote y actual, pero no veo que en ningún lugar se iguale L con el puntero pivote, estoy escribiendo el hilo y regreso a la función para tratar de darme cuenta como funciona pero nada. -     

#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" );		
}
 

Saludos.

Que más se puede pedir, gracias por tu tiempo y ya me pongo a estudiar tú código. -
Es una buena oportunidad para decir algo que hace mucho disiento con la mayoría de los que responden en los foros, el tema de retacear código, por aquello de que no se hacen tareas y el prejuicio de que nadie aprende con copiar y pegar, digo, no les parece que es mejor(si tienen el tiempo necesario) escupir código, como leí por allí que un modelador retaba a un participante con esta frase y que los que preguntamos nos hagamos cargo de que es lo que nos conviene?.           

Saludos y un abrazo para todos.

Hola, ivancea96. -
Yo no puse las imágenes para que lo que está escrito sea relevante, solo para que me digan si tienen algún error de concepto. - 

---

Alberto, No puedo creer lo que estoy viendo, posteaste el código y yo sin enterarme, no lo puedo creer

Saludos.   

Hola, gente. -
Les pido un esfuerzo más, alguien que tenga mucho tiempo y ganas me podría decir si lo que puse en las imágenes es medianamente correcto. -




Saludos. 

Hola, que tengan un muy buen día. -
ivancea96, no lo intente de esa manera porque a la apurada leí que era muy costoso hacerlo directamente sobre la lista y como Alberto me sugirió hacerlo de la otra manera no lo pensé demasiado y lo intente, pero no hay caso no solo no me sale, sino que ahora también descubro que no tenía demasiado conocimiento de estructuras anidadas, en conclusión estoy en un pozo demasiado profundo y muy confundido. -
Descarte el código que deje en el primer post y lo estoy intentando con el programa que esta en el video de Alberto sin el borrado de nodo, lo que ocurre es que podría aprenderme la sintaxis de memoria y continuar pero tengo claro que esa no es la forma de estudiar en serio. -
En definitiva, voy a respirar muy profundo, pensar tranquilo e intentar interpretar lo que ahora me tiene ocupado que son las 2 estructuras, créanme que si los tuviera sentado frente a una computadora a algunos de Uds. ni siquiera así intentaría pedirles alguna ayuda dado que es algo que me da vueltas con respecto a las dos estructuras pero no logro expresar exactamente lo que no entiendo.
En conclusión, voy a seguir pensando en el tema y si me surge alguna duda concreta la voy a postear.

#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. 
 */

       

Saludos.   

Ahora me hiciste entrar la duda, ¿no se declara de esa manera un vector de enteros?, el programa funciona de maravillas, sin ninguna advertencia. -

 

Hola, MCKSys Argentina muchas gracias por tu tiempo, en realidad el método de la burbuja ya lo tenía lo que necesito es la manera para lograr ordenar una lista simplemente enlazada, dejo lo que tengo logrado, lo que ocurre es que no me doy cuenta como transformar el vector estático ordenado en una lista dinámica, les dejo lo que llevo hecho, espero que puedan guiarme con código o alguna idea. -
Alberto, ya sabrás que todo texto que valla dirigido a voz es un agradecimiento.

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.
*/

Saludos.
 

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. -

#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();
}

 
Saludos.