如何按升序对双向链表进行排序？

Question

I am trying to perform an insertion-sort function on a doubly linked list in the C programming language. When I run the code with this function on a doubly linked list of 1<-->3<-->7<-->4<-->9 I get a sorted output. However, When I run this code on a doubly linked list of 5<-->3<-->7<-->4<-->9 I get a blank output (and yes it still compiles and runs).

I cannot figure out why it is returning a blank output when the first node has greater value than the second. I would guess it has something to do with my if statement?

void insertion_sort_increasing(struct List *list)
{
    struct Node *current_node = list->head; //initialize current_node
    struct Node *tempA;
    struct Node *tempB;
    struct Node *tempC;
    struct Node *tempD;

    if (current_node == NULL) {
        printf("Empty List.");
    } else {
        current_node = current_node->next;
        while (current_node != NULL) { //iterates doubly linked list
            if (current_node->prev->StudentID > current_node->StudentID) {
                tempA = current_node; //(3 in this case)
                tempB = current_node->prev->prev; //(NULL in this case)
                tempC = tempA->next->prev;
                tempD = tempB->next;

                tempA->next->prev = tempA->prev; // 5<--7
                tempB->next->prev = tempC;       // 3<--5
                tempB->next = tempA->prev->next; // NULL-->3
                tempA->prev->next = tempA->next; // 5-->7
                tempA->next = tempD;             // 3-->5
                tempA->prev = tempD->prev;       // NULL<--3
                if (tempB == NULL) {
                    list->head = tempB->next;    // 3 = head
                }
            }
            current_node = current_node->next;
        }
    }
}

Answer 1

There are multiple problems in your code:

• you perform a single scan through the list, swapping adjacent nodes that are out of order. This loop does not handle the case of a node that should move left by more than one position.
• the code crashes if tempB is null, ie: if the 2 initial nodes of the list should be swapped.
• list->head should be updated if the first node changes.
• the temporary variable names are confusing, esp tempC that is equal to tempA , and the initial order is not tempA -> tempB -> tempC -> tempD .
• for insertion sort, you should move the current node to its position among the nodes sorted so far and skip to the next node until you reach the end of the list.

Here is a modified version:

void insertion_sort_increasing(struct List *list)
{
    struct Node *current_node = list->head;

    while (current_node != NULL) {
        struct Node *next = current_node->next;
        while (current_node->prev && current_node->prev->StudentID > current_node->StudentID) {
            // swap current_node and its predecessor (tempC and tempB)
            struct Node *tempA = current_node->prev->prev;
            struct Node *tempB = current_node->prev;
            struct Node *tempC = current_node;
            struct Node *tempD = current_node->next;

            if (tempA) {
                tempA->next = tempC;
            } else {
                list->head = tempC;
            }
            tempC->prev = tempA;
            tempC->next = tempB;
            tempB->prev = tempC;
            tempB->next = tempD;
            if (tempD) {
                tempD->prev = tempB;
            } else {
                list->tail = tempB;
            }
        }
        current_node = next;
    }
}

Answer 2

You need to learn to separate concerns in your code. An insertion sort takes an input list or array and returns an output list or array. So to start with, you need a function that either takes a List** and returns void , or it takes a List* and returns a List* . Logically you need to do three things correctly, 1) iterate over the input list, 2) Remove a node from the input list without breaking 1, 3) insert into the output list at the correct position for the sort order. That amounts to three functions.

List *InsertionSort(List * pList) {...}
List *SortedInsert(List *pList, List *pNode) {...}
List *Remove(List *pNode) {...}

InsertionSort just loops over the it's input, calling Remove , without loosing track of the head or tail pointer, depending on which way you're moving through the list, and then calls SortedInsert with the node it just removed from the head or tail of the pList. SortedInsert then iterates through pList looking for the correct place to insert pNode and then returns the new head of the list, which might just be pNode .

It's just easier to think about one operation at a time, and the code you write will be simpler and easier to understand and debug. In fact, you can test SortedInsert first, to make sure it's working, then test Remove , and then move on to to InsertionSort . You'll need to learn how to use your debugger and make yourself familiar with stepping through your code and checking the state of your variables. A fourth function, PrintList is probably on order here as well.

I am not going to write a bunch of code or be really explicit about the algorithm details, because you can get that with an SO or Google search, and this seems like an obvious homework assignment.