双向链表的插入排序 C

Question

I am trying to implement the insertion sort algorithm in a doubly linked list, here is my code:

void insertion_sort_list(listint_t **list)
{
        listint_t *head, *insert, *temp, *aux;

        head = *list;
        while (head)
        {
                insert = head->next;
                aux = head;
                while (aux && aux->n > insert->n)
                {
                        temp = aux->next->next;
                        aux->next = temp;
                        temp->prev = aux;
                        aux = aux->prev;
                }
                temp = aux->prev;
                insert->next = aux;
                insert->prev = temp;
                head = head->next;
        }
}

I have tried out the code but it gives me an infinite loop. When I am try to run it in my debugger it, I couldn't understand it (My executable is compiled from multiple files). Can some one help find out where my error is, and how can I find these kind of errors in the future(infinite loops)? And if possible can you refer me to a documentation, or anything, that will help me use the gdb to debug an executable compiled from multiple C files. Thank you.

Answer 1

I am going to answer my own question. So this problem has made me spend nearly two days trying to figure out how I can implement the insertion sort algorithm in a doubly linked list. I do not like copying other people code, because why would I learn if I do.

Here is how I solved my issue:

void insertion_sort_list(listint_t **list)
{
        listint_t *sorted, *curr, *next, *aux, *temp;

        sorted = NULL;
        curr = *list;

        while (curr != NULL)
        {
                next = curr->next;

                if (sorted == NULL || sorted->n > curr->n)
                {
                        curr->next = sorted;
                        sorted = curr;
                } else
                {
                        aux = sorted;

                        while (aux->next != NULL && aux->next->n <= curr->n)
                                aux = aux->next;

                        if (aux->next == NULL)
                        {
                                aux->next = curr;
                                curr->prev = aux;
                                curr->next = NULL;
                        } else
                        {
                                temp = aux->next;
                                aux->next = curr;
                                curr->prev = aux;
                                curr->next = temp;
                                temp->prev = curr;
                        }
                }

                curr = next;
        }

        *list = sorted;
}

As you can see, instead of traversing backward I made a dummy head so as I can make a sorted part of the list. This approach is much cleaner than my previous one. I have understood that algorithms are hard, and implementing them takes time. And I, having only implemented bubble sort before, have taken at least two days two come up with a solution. But it will make you understand more about the concept.