如何按字母顺序排列此链接列表？

Question

I am writing a program that has names and ages entered into it. The names can then be called and the age of the person will be printed out. If the person does not exist in the list it prints their age as -1. If a name is entered with a new age that is already in the list, the new entry is not added. Currently it appears the names are sorted by the order that I input them. How can I sort them alphabetically by only changing the code for the function add? This code is compileable and works as intended except for the non-alphabetized list.

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

typedef struct person {
    char *name;
    int age;
    struct person *next;
} Person;

void print(Person *); // prints the entire list
Person *add(Person *, char *, int); // adds a new node to the list
int getAge(Person *, char *); // returns the age of the person or -1 if not found

int main(void) {
    char input1[100];
    int input2;
    Person *myList = NULL;
    printf("Enter a person's name (one word) and age : ");
    scanf("%s %d", input1, &input2);
    while (input2 != 0) {
        myList = add (myList, input1, input2);
        printf("\n\nThe list is now : ");   print(myList);
        printf("Enter a name (one word) and age, enter 'xxx' and 0 to exit : ");
        scanf("%s %d", input1, &input2);
    }
    printf("\n\nThe final list is ");   print(myList);
    printf("\n\nEnter the name of a person to look up their age : ");
    scanf("%s", input1);
    while ( strcmp(input1, "xxx") != 0 ) {
        printf("\t%s is %d years old\n", input1, getAge(myList, input1) );
        printf("Enter a name to look up their age or 'xxx' to exit : ");
        scanf("%s", input1);
    }

    return 0;
}

void print(Person *ptr) {
    while (ptr) { printf("[%s-%d] ", ptr->name, ptr->age); ptr = ptr->next; }
    printf("\n");

    return;
}

//adds person to list if the person does not exist already
Person *add(Person *ptr, char *n, int a) {
    Person *newNode = malloc( sizeof(Person) );
    int duplicate = 1;
    Person *dummy = ptr;
    while (dummy) {
        if(strcmp(dummy->name, n) == 0) {
            printf("Name Already Exists in List! Please retry with other name..\n");
            duplicate=-1;
            break;
        }
        else
            dummy = dummy->next;
    }
    if (duplicate!=-1) {
        newNode->name = malloc( strlen(n) + 1 );
        strcpy(newNode->name, n);
        newNode->age = a;
        newNode->next = ptr;
        return newNode;
    }
    duplicate = 1;
    return ptr;
}

//function to find age of the passed person
int getAge(Person *ptr, char *name) {
    while (ptr) {//while loop to traverse entire linked list elements (All persons one by one)
        if(strcmp(ptr->name, name) == 0) //comparing person name in the list with the search key name
            return ptr->age; //if found, returning the age of that person
        else
            ptr = ptr->next; //if not found, check in next node of linked list
    }

    return -1; // if not found, even after visting all nodes, return -1
}

Answer 1

You can do an insertion sort. Each time you add a new record, you scan through the list to see where it belongs and insert it there. This could be combined with your scan for duplicates.

Person *add(Person *head, char *n, int a) {
  char empty[1] = "";
  Person sentinel = {0};
  sentinel.name = empty;
  sentinel.next = head;
  Person *p = &sentinel;
  while (p) {
    int cmp = p->next ? strcmp(n, p->next->name) : -1;
    if (cmp == 0) {
      printf("Name Already Exists in List! Please retry with another name..\n");
      break;
    }
    if (cmp < 0) {
      Person *newNode = malloc( sizeof(Person) );
      newNode->name = malloc( strlen(n) + 1 );
      strcpy(newNode->name, n);
      newNode->age = a;
      newNode->next = p->next;
      p->next = newNode;
      break;
    }
    p = p->next;
  }
  return sentinel.next;  // a possibly-updated copy of head
}

Insertion sort always compares the new element to the next element (rather than to the current element). This makes dealing with the first element awkward, especially in a list. We get around that with a temporary "sentinel" that we pretend is just before the head of the list.

There are other approaches. You can create the new node at the head of the list and then slide it down until it's in position. If you encounter a duplicate, you remove the new one and patch up the list. Insertion sorts in other data structures typically work from the tail back toward the head, but that won't work with a singly-linked list.

Answer 2

I wrote something similar where I sorted student ID's. You should try doing a swap. Declare a temp variable and used that to swap. The code is something like.

int temp,
    first_name,
    last_name;

temp = first_name;
first_name = last_name;
last_name = temp;

Hope that gives you an idea!

Edit: What the other person suggested is a good idea as well, an insertion sort.

Answer 3

Your question has already been answered, but I'd like to point out another approach to adding a node. The list is defined by its head node. When iserting elements, the head node may change. (It will change in your current code, which adds elements at the front.) In order to reflect the change, you return the new head:

myList = add(myList, input1, input2);

This is redundant, because you have to specify myList twice. It is also legal to discard the result returned from a function, so there is the possibility of an error. If you pass in a pointer to the head pointer, you will eliminate the redundancy.

add(&myList, input1, input2);

The ´& will indicate that myList` may change. And you can now use the return value for something else, for example a pointer to the newly inserted node or null if the name was already there.

Inserting a person at the front (unconditionally) looks like this:

Person *add_front(Person **ptr, const char *name, int age)
{
    Person *p = person_new(name, age);

    p->next = *ptr;
    *ptr = p;

    return p;
}

Inserting at the end requires to walk the list first:

Person *add_back(Person **ptr, const char *name, int age)
{
    Person *p = person_new(name, age);

    while (*ptr) {
        ptr = &(*ptr)->next;
    }

    p->next = *ptr;
    *ptr = p;

    return p;
}

Note how you do not need to treat the empty list as a special case. Adrian's solution eliminates the special case with a sentinel element. Here, it is eliminated by the pointer itself: ptr points to the list head pointer in the calling function at first. As you walk through the list, it points to the next pointer of the previous node. Updating *ptr updated the pointer that took us to the current node.

The function person_new creates a new node. I find it tidier to make this a separate function, which you could call from other functions:

Person *person_new( const char *name, int age)
{
    Person *p = malloc(sizeof(*p));

    p->name = malloc(strlen(name) + 1);
    strcpy(p->name, name);
    p->age = age;
    p->next = NULL;

    return p;
}

Now the function you want, which inserts the node in alphabetical order, looks like this:

Person *add(Person **ptr, const char *name, int age)
{
    while (*ptr && strcmp((*ptr)->name, name) < 0) {
        ptr = &(*ptr)->next;
    }

    if (*ptr == NULL || strcmp((*ptr)->name, name) != 0) {
        Person *p = person_new(name, age);

        p->next = *ptr;
        *ptr = p;

        return p;
    }

    return NULL;
}

When you look up a node by name, you can stop the search short when the current node is alphabetically larger than the name you're looking for:

const Person *find(const Person *ptr, const char *name)
{
    while (ptr) {
        int cmp = strcmp(ptr->name, name);

        if (cmp > 0) break;
        if (cmp == 0) return ptr;

        ptr = ptr->next; 
    }

    return NULL;
}

You can see the code in action here .