Y buen, si no te es tanto quilombo subila... yo la tengo para doble enlazada (me lo habían tomado en el parcial Jaja).

 //------------------------------------INTERCAMBIA NODOS-------------------------------//

struct nodo *intercambiar (struct nodo **Inicio, char *cadena1, char *cadena2)

{

  struct nodo *Actual, *T1, *T2, *Aux1, *Aux2;

  

  //Recorremos la lista desde su primer nodo.

  Actual=*Inicio;

  while (Actual!=NULL) //Mientras no se llegue el final de la lista...

  {

    if (comparar (Actual->nombre,cadena1)==0) //Al ser 0, quiere decir que las cadenas son iguales.

    {

      Aux1=Actual; //Guarda el nodo hallado (actual) en un auxiliar.

      break;

    }

    //Si no encontro el nodo que buscamos se mueve el siguiente nodo.

    else Actual=Actual->Siguiente; 

  }

  

  //Si el primer nodo fue encontrado...

  if (Aux1!=NULL)

  {

  //Recorremos la lista desde su primer nodo.

  Actual=*Inicio;

    while (Actual!=NULL) //Mientras no se llegue el final de la lista...

    {

      if (comparar (Actual->nombre,cadena2)==0) //Al ser 0, quiere decir que las cadenas son iguales.

      {

	Aux2=Actual; //Guarda todo el nodo hallado (actual) en un auxiliar.

	break;

      }

      //Si no encontro el nodo que buscamos se mueve el siguiente nodo.

      else Actual=Actual->Siguiente;

    }

  

    //Si el segundo nodo fue encontrado...

    if (Aux2!=NULL)

    {

      //Si el primer nodo es el primer elemento...

      if (Aux1==*Inicio)

      {

	//Muevo el segundo nodo al inicio de la lista.

	*Inicio=Aux2; 

	(Aux2->Anterior)->Siguiente=Aux1;

      }

      //Si el segundo nodo es el primer elemento...

      else if (Aux2==*Inicio)

      {

	//Muevo el primer nodo al inicio de la lista.

	*Inicio=Aux1;

	(Aux1->Anterior)->Siguiente=Aux2;

      }

      //Si ninguno de los dos nodos hallados es el primer elemento de la lista.

      else

      {

	(Aux2->Anterior)->Siguiente=Aux1;

	(Aux1->Anterior)->Siguiente=Aux2;

      }

      

      //Almaceno el puntero que apunta al nodo anterior del primer nodo en una variable

      //temporal.

      T1 = Aux1->Anterior;

      //Muevo el puntero que apunta al nodo anterior del segundo nodo al primer nodo.

      Aux1->Anterior = Aux2->Anterior;

      //Almaceno el puntero que apunta al nodo siguiente del primer nodo en una variable

      //temporal.

      T2 = Aux1->Siguiente;

      

      //Si el primer nodo no es el último elemento...

      if (Aux1->Siguiente!=NULL)

	(Aux1->Siguiente)->Anterior=Aux2;

      //Si es el último elemento...

      Aux1->Siguiente=Aux2->Siguiente;



      //Muevo el puntero que apunta al nodo anterior del primer nodo al segundo nodo.

      Aux2->Anterior = T1;

      //Si el segundo nodo no es el último elemento...

      if (Aux2->Siguiente!=NULL)

	(Aux2->Siguiente)->Anterior=Aux1;

      //Si es el último elemento...

      Aux2->Siguiente=T2;   

      

    return *Inicio; //Retorna el lo apuntado por el inicio de la lista.  

    }

    else return NULL; //Retorna el lo apuntado por el inicio de la lista.

  }

  else return NULL; //Retorna NULL si uno de los nodos no fue encontrado.

  

}

Eso te tomaron en un parcial?
que hdps..

Yo habia hecho esto para simple, pero vos ya lo hiciste para doble enlazada
El metodo de ordenamiento lo invente yo, con burbuja te va a andar mucho mejor

 void s_swap (nodo **lista, int pos1, int pos2) {

  

  nodo *ant1, *nodo1, *ant2, *nodo2, *aux;

  int i=0,j=0;

  

  ant1=NULL;

  nodo1=*lista;

  

  if (pos1==pos2) {

    printf ("\nSe ha indicado el mismo nodo. No se realiza ningun intercambio.");

    return;

  }

  

  while (nodo1!=NULL && i<(pos1-1)) {

    ant1=nodo1;

    nodo1=nodo1->sig;

    i++;

  }

  

  if (nodo1==NULL) {

    printf ("\nNo hay ningun nodo que contenga el dato indicado.");

    return;

  }

  

  ant2=NULL;

  nodo2=*lista;

  

  while (nodo2!=NULL && j<(pos2-1)) {

    ant2=nodo2;

    nodo2=nodo2->sig;

    j++;

  }

  

  if (nodo2==NULL) {

    printf ("\nNo hay ningun nodo que contenga el dato indicado.");

    return;

  }

  

  printf ("\npos1 %d dato1 %d -- pos2 %d dato2 %d\n", pos1,nodo1->dato,pos2,nodo2->dato);

  

  if (pos2<pos1) {  /** Caso de que nodo2 quede posicionado delante de nodo1 */

    aux=nodo1;

    nodo1=nodo2;

    nodo2=aux;

    aux=ant1;

    ant1=ant2;

    ant2=aux;

  }

  

  if (nodo1->sig==nodo2) { /** Nodos a intercambiar pegados entre si */

    

    aux=nodo2->sig; /** Almaceno la posicion del elemento siguiente al nodo2 que se perdera en los intercambios */

    

    if (ant1==NULL)

      (*lista)=nodo2;   /** Intercambiar primer nodo */

	else 

	  ant1->sig=nodo2;

	

    nodo2->sig=nodo1;

    nodo1->sig=aux; 

    

    return; /** Importante: si no vuelve al main, se cumple la condicion de abajo */

  }

  

  if (nodo1->sig!=nodo2) {

  

    aux=nodo2->sig; /** Almaceno la posicion del elemento siguiente al nodo2 que se perdera en los intercambios */

    

    if (ant1==NULL)

      (*lista)=nodo2;   /** Intercambiar primer nodo */

	else 

	  ant1->sig=nodo2;

	

    nodo2->sig=nodo1->sig;

    ant2->sig=nodo1;                                       

    nodo1->sig=aux;

    

    return;

  } 

}



//***********************************************************************************************************************//



void ordenar (nodo **lista) {

  

  nodo *ant,*act, *temp;

  

  

  if ((*lista)==NULL) {

    printf ("\nNo hay elementos en la lista.");

    return;

  }

  

  while (1) {

    

    temp=*lista;

    int n=1;

    

    ant=(temp);

    act=(temp)->sig;

    

    while ((act!=NULL) && ((ant->dato)<=(act->dato))) {

      ant=act;

      act=act->sig;

      n++; /** n indica ant, n+1 act */

      }

  

    if (act==NULL){ /** llego al final de la lista, la lista esta ordenada */

      return;

      }

  

   s_swap (lista, n, n+1); 

    

  }

  

  printf ("\nError!");

}



//***********************************************************************************************************************//

Yu funció de ordenar es muy similar a lo que estaba pensando yo... Jeje tan equivocado no estaba.
Ahora miro la de intercambiar.

He vuelto (?)
Traté de hacer algo medio casero, mirando un par de cositas de lo que posteó JulianD y no logro ordenar la puta lista (hace 3 días que vengo peleando con esto Jaja).
Bueno, acá va el código... si no se entiende algo pregunten:

 void OrdenarLista ( struct nodo **Cabeza ) //Paso el primer elemento de la lista.

{

  struct nodo *Actual, *Anterior, *Temp;

  

  Anterior = *Cabeza; //Primer elemento de la lista.

      

  while ( Anterior != NULL ) { //Mientras el recorrido desde el primer elemento no sea NULL...

    Actual = Anterior -> Siguiente; //Actual es el nodo siguiente a Prim, en esta primera

				//instancia sería el segundo de lista.

    while ( Actual != NULL ) { //Mientras el segundo elemento sea distinto a NULL...

      if ( strcmp ( Actual -> nombre , Anterior -> nombre ) < 0 ) { 

	//Si Actual es menor que Anterior...

	Temp = Actual; //Almaceno en una variable auxiliar a Actual.

	Actual = Anterior;

	Anterior = Temp;

	Temp = Anterior -> Siguiente;

	if ( Actual -> Siguiente != NULL ) //Si el nodo que sigue a Actual es el fin

					   //de la lista...

	  Anterior -> Siguiente = Actual -> Siguiente;

	else Anterior -> Siguiente = NULL;

	Actual -> Siguiente = Temp;

      }

      Actual = Actual -> Siguiente;

    }

    Anterior = Anterior -> Siguiente;

  }

  printf ("\nLista ordenada.\n"); //O al menos eso debería hacer...

}