Hola espero y te ayude, como te comente hay que hacerlo en papel a mano con todos los casos posibles y por haber, y asi validas que no se nos escapo ningun caso.

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.
//En el if anterior lo limitas a solo 10 elementos con lo cual pierde su utilidad para ser una lista de cualquier cantidad de elementos
			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 situarnos en el campo a eliminar
				anterior = pivote;							// Guardardamos el nodo previo al cual queremos eliminar para modifica sus valores (apuntador al siguiente nodo el cual va a cambiar)
				pivote = pivote->siguiente;
				i++;
			}
//A esta altura del ciclo, la variable pivote ya tiene el elemento a eliminar
			if( pivote->siguiente != NULL ){ //Si el nodo a eliminar no es el ultimo
				if( pivote->siguiente != L->primero ){ // Validamos si no es el primer elemento (Aqui deberia de ser if( pivote != L->primero ){)
					anterior->siguiente = pivote->siguiente;// Realizamos el cambio de variable... se iguala el apuntadorr a siguiente dentro de la variable anterior (que apuntaba al elemento a eliminar) al que la le seguia, (Ver comentario UNO)
					free( pivote );		// Se libera la memoria asignada al elemento a eliminar a esta altura del codigo nadie deberia de tener apuntado a este nodo que se libero
				}else{
// En este punto pivote es el primer elemento de la lista por lo cual el unico apuntador al elemento a eliminar era es que tiene la estructura lista, por lo cual se susituye por el elemento que le segua al que se va a eliminar
					L->primero = pivote->siguiente; 
					free( pivote );				 //En este el tambien es necesario liberar la memoria usada
				}
			}else{
//En este punto el elemento a liminar es el ultimo de la lista
				if( pivote != L->primero ){ // Se valida si tambien es el primero
// Si no es el primer elemento signifia que la variable anterior contiene un apuntador valido y hay que modificarla
					anterior->siguiente = NULL; //El apuntador a siguiente de la variable anterior se iguala a NULL por que actualmente ya no hay elementos siguientes
					free( pivote );//Liberamos memoria
					L->ultimo = anterior; 			//Como actualmente eliminamos el ultimo, hay que actualizar el apuntador de la estructura lista al que ahora es realmente el ultimo elemento, el cual es el nodo siguiente	 
				}else{
//En este punto el elemento a eliminar es el unico elemento de la lista, por lo cual es tanto el ultimo como el primero, entonces simplemente se elimina de la memoria
					free( pivote );
				}
			} 
			L->elementos--; // Decrementamos el contador de la lista
			if( L->elementos == 0){ // Si ya no hay elementos en la lista (Literamente hay 0 elementos) por lo tanto significa que la lista esta vacia hay que Liberar la Lista actual 
				free( L ); // Liberamos la memoria usada en la lista actual
				return NULL;  // Retornamos NULL para actualizar el apuntador que tiene la funcion que nos llamo, esto es la funcion principal, para que se entere que ya no hay lista valida
			}else{
				return L; // Si todavia quedan elementos retornamos el apuntador actual de la lista
			}
		}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;	
	}
}

Si tu progama va a usar una sola lista y quieres que tu variables primero y ultimo sean globales entonces podrias ahorrarte la estructura lista y de clarar simplemente.

struct nodo *primero, *ultimo;

Ahora imagina que tu programa va a usar 3 listas o 10 o 1000 o un número desconocido de listas algo random.

Como las declaras para mil?

struct nodo *primero[1000], *ultimo[1000];

Tal vez sirva, y como llevas el control de cuantos elementos tiene cada lista?

int elementos[1000];

Como te digo  tal vez sirva pero, las funciones deben de ser genéricas para cualquier numero de listas y no solo una.

¿Como se hace cuando no sabes cuantas listas se crearan?

En cuanto a memoria adicional usado en el programa por usar una  estructura adicional solo aumenta unos 4 o 8 bytes por lista adicional usada (adicional al numero de elementos y memoria que use cada nodo).


Imagínate que estas escribiendo el archivo lista_simple.h
Y lo vas a distribuir en internet para que cualquiera lo use. Tu biblioteca de funciones para libreria ofrecerá de manera generica funciones para agregar nodos eliminarlos y ordenarlos, como crees que sea mejor que solo funcione con una lista, o que funcione para Cualquier cantidad de listas.

Saludos