Sorte de structure de noms (liste doublement chaînée)

Question

Je suis en train de trier mes structure basée sur des noms (par ordre alphabétique).Par exemple, j'ai cette structure:

struct person{
    char name[MAX];
    char num[MAX];
    char email[MAX];
    struct person *next;   
    struct person *previous;  
};

struct person *next, *first, *end;

et dans ma fonction principale :

int main()
{
 struct person p = {{0}}
 .
 .
 .
 switch(choice)
    {
    case 1 : 
        printf("Name   : "); scanf("%s", &p.name);
        printf("Num : "); scanf("%s", &p.num);
        printf("E-Mail   : "); scanf("%s", &p.email);
        input(p); //function to input data    
        break;
    case 2 : 
        sort(p); //function to sort the data
        break;
               }
}

Et dans mon prototype de la fonction:

void sort(struct person p)
{
    struct person *ptr, *ptr2, *temp;

    ptr=first;
    ptr2=first;

    for (ptr= first; ptr!= NULL; ptr= ptr->next)
    {
        for (ptr2= ptr2->next; ptr2!= NULL; ptr2= ptr2->next)
        {
            if (strcmp(ptr->name, ptr2->name) > 0)
            {
                temp = ptr;
                ptr= ptr2;
                ptr2= temp;
            }
        }
    }

}

Ok, donc j'ai un prototype de la fonction qui est en quelque sorte la structure sur la base de son élément, qui est le nom.J'ai essayé de trier en utilisant le même principe que bublesort mais cela n'a pas fonctionné pour moi.Pointeur ptr pointe vers le premier nœud dans la liste et ptr2 points pour le second nœud.Est mon algorithme de mal?Je ne peux pas l'air de trouver ce qui est mal.Principal problème est avec le tri.J'Espère que ma question est claire.

Answer 1

Boucle intérieure

    for (ptr2= ptr2->next; ptr2!= NULL; ptr2= ptr2->next)

devrait être

    for (ptr2= ptr->next; ptr2!= NULL; ptr2= ptr2->next)

(note de l' ptr2 vs ptr).

EDIT:

La permutation des pointeurs ne fonctionne pas, soit.Vous relier à des éléments qui nécessite helper variables dans les boucles.Les choses peuvent être plus élégant (--> traiter avec la tête de liste) lorsque l'on travaille avec les références:

static void swap(struct person **a, struct person **b)
{
    struct person       *tmp;

    if ((*a)->next)
        (*a)->next->prev = *b;

    if ((*b)->next)
        (*b)->next->prev = *a;

    tmp        = (*a)->prev;
    (*a)->prev = (*b)->prev;
    (*b)->prev = tmp;

    tmp        = (*a)->next;
    (*a)->next = (*b)->next;
    (*b)->next = tmp;

    tmp = *b;
    *b  = *a;
    *a  = tmp;
}

void foo()
{
    struct person **a;
    struct person *prev_a;

    for (a = &first; *a != NULL; a = &(prev_a->next)) {
        struct person **b;
        struct person *prev_b;

        prev_a = (*a)->prev;

        for (b = &(*a)->next; *b != NULL; b = &(prev_b->next)) {
            prev_b = (*b)->prev;

            if (strcmp((*a)->name, (*b)->name) > 0)
                swap(a, b);

            /* prev_b == NULL can not happen because inner loop is started
               in the middle of the list */
            prev_b = prev_b->next;
        }

        if (prev_a)
            prev_a = prev_a->next;
        else
            prev_a = first;
    }
}

EDIT:

La mise en œuvre de linux noyau, comme les listes chaînées (ayant une tête artificielle qui est lié à l'avant et la queue de la liste) rendre les choses plus facile dans la méthode d'échange en raison de pointeur NULL vérifications peuvent être omis.E. g.la liste pourrait ressembler

     ,------------> HEAD ------------\
    | +------------     <-----------\  \ 
    | |                              |  |
    | `-> elem_n --> ... --> elem_0 -`  |
     `---        <-- ... <--        <---'

Answer 2

Ne pas échanger des pointeurs, des swaps.Aussi, vous devez l'initialiser vide pointeurs de NULL, ils ne sont pas par défaut.