Lista SelectionSort

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct lista Lista;

Lista * lista_cria ();
Lista * lista_copia (Lista * p);
void lista_libera (Lista * p);
int lista_insere_inicio (Lista * p, char * elemento);
int lista_insere_final (Lista * p, char * elemento);
int lista_insere_posicao (Lista * p, char * elemento, int posicao);
int lista_remove_inicio (Lista * p);
int lista_remove_final  (Lista * p);
int lista_remove_posicao (Lista * p, int posicao);
char * lista_obtem_elemento  (Lista * p, int posicao); /* retorna elemento em uma posicao */
int lista_se_presente  (Lista * p, char * elemento); /* retorna posicao do elemento, ou zero se ausente */
int lista_obtem_tamanho  (Lista * p);
char * lista_imprime  (Lista * p);
void lista_ordena (Lista * p);
int lista_se_consistente (Lista * p);

char * private_char_copia (char * s) {
    char * aux = (char *) malloc (strlen(s)+1);
    strcpy(aux, s);
    return aux;
}
/* IMPLEMENTACAO POR ENCADEAMENTO DUPLO */
typedef struct no No;
struct no {
    struct no * anterior;
    char * elemento;
    struct no * proximo;
};
struct lista {
    No * cabeca;
    int tamanho;
};
Lista * lista_cria () {
    Lista * q = (Lista *) malloc(sizeof(Lista));
    if (q!=NULL) {
        q->cabeca = NULL;
        q->tamanho = 0;
    }
    return q;
}
Lista * lista_copia (Lista * p) {
    return NULL;
}
void lista_libera (Lista * p) {
    No * q = p->cabeca;
    int tamanho;
    for (tamanho = lista_obtem_tamanho(p); tamanho > 0; tamanho--) {
        No * aux = q->proximo;
        free(q);
        q = aux;
    }
    free(p);
}
int lista_insere_inicio (Lista * p, char * elemento) {
    No * no = (No *) malloc(sizeof(No));
    if (no==NULL)
        return 0; // insercao sem sucesso;
    no->elemento = (char *) malloc(strlen(elemento)+1);
    strcpy(no->elemento, elemento);
    if (!lista_obtem_tamanho(p)) {
        no->anterior = no;
        no->proximo  = no;
    } else {
        p->cabeca->anterior->proximo = no;
        no->anterior = p->cabeca->anterior;
        no->proximo  = p->cabeca;
        p->cabeca->anterior = no;
    }
    p->cabeca = no;
    p->tamanho = p->tamanho + 1;
    return 1; // insercao com sucesso
}
int lista_insere_final (Lista * p, char * elemento) {
    return 0; // insercao sem sucesso
}
int lista_insere_posicao (Lista * p, char * elemento, int posicao) {
    return 0; // insercao sem sucesso
}
int lista_remove_inicio (Lista * p) {
    return 0; // remocao sem sucesso
}
int lista_remove_final  (Lista * p) {
    return 0; // remocao sem sucesso
}
int lista_remove_posicao (Lista * p, int posicao) {
    return 0; // remocao sem sucesso
}
char * lista_obtem_elemento  (Lista * p, int posicao) {
    if ((posicao<1)||(posicao>lista_obtem_tamanho(p)))
        return NULL;
    No * q = p->cabeca;
    int i;
    for (i=0; i<posicao-1; i++)
        q = q->proximo;
    return private_char_copia(q->elemento);
}
int lista_se_presente  (Lista * p, char * elemento) {
    return 0; // elemento ausente
}
int lista_obtem_tamanho  (Lista * p) {
    return p->tamanho;
}
char * lista_imprime  (Lista * p) {
    char * retorno = (char *) malloc(lista_obtem_tamanho(p)*10+1);
    retorno[0] = '\0';
    No * q = p->cabeca;
    int i;
    for (i=0; i < lista_obtem_tamanho(p); i++) {
        char aux[50];
        sprintf(aux, "%s " , q->elemento);
        strcat(retorno, aux);
        q = q->proximo;
    }
    retorno = (char*) realloc (retorno, strlen(retorno)+1);
    return retorno;
}
void lista_ordena (Lista * p) {
    No *foco, *iterador, *menor; //foco -> posicao a trocar de valor | iterador -> ponteiro de comparacao | menor -> ponteiro do No com menor elemento ate o momento
    char *aux;
    if (p == NULL || lista_obtem_tamanho(p) < 1)
        return;

    foco = p->cabeca;
    while (foco->proximo != p->cabeca){ //Enquanto nao chega no fim da lista
        menor = foco;
        iterador = foco->proximo;
        while(iterador != p->cabeca){
            if (strcmp(menor->elemento, iterador->elemento) > 0){
                menor = iterador;
            }
            iterador = iterador->proximo;
        }
        //Troca dos elementos dos No
        aux = menor->elemento;
        menor->elemento = foco->elemento;
        foco->elemento = aux;

        //Proximo No a trocar de valor
        foco = foco->proximo;
    }
    return;
}
int lista_se_consistente (Lista * p) {
    if ( ! lista_obtem_tamanho(p) )
        return 1; // lista consistente
    No * aux = p->cabeca;
    int tam;
    for (tam = lista_obtem_tamanho(p); tam > 0; tam--)
        aux = aux->proximo;
    if (aux != p->cabeca)
        return 0; // lista nao consistente
    for (tam = lista_obtem_tamanho(p); tam > 0; tam--)
        aux = aux->anterior;
    if (aux != p->cabeca)
        return 0; // lista nao consistente
    return 1; // lista consistente
}

int main () {
    int n;
    char aux[30];
    Lista * p = lista_cria ();
    scanf ("%s", aux);
    while (strcmp(aux,"fim")) {
        lista_insere_inicio (p, aux);
        scanf ("%s", aux);
    }
    printf("[tamanho=%d] %s\n\n", lista_obtem_tamanho(p), lista_imprime(p));
    lista_ordena(p);
    printf("[tamanho=%d] %s\n", lista_obtem_tamanho(p), lista_imprime(p));
    printf("Lista consistente? Resposta: %s\n", lista_se_consistente(p)?"sim":"nao");
    lista_libera(p);
    return 0;
}