此代码未按预期对链表进行完全排序

Question

I am new to programing and so I am trying out a program to sort a linked list by insertion sort algorithm. I want to swap the nodes and not just the elements. Although I have seen alternative implementations on the inte.net, but I'm curious to understand why my current implementation isn't giving the expected output.

My code returns immediately after one swap operation without going through the entire list. Here is my current implementation:

sort.h

/**
 * struct listint_s - Doubly linked list node
 *
 * @n: Integer stored in the node
 * @prev: Pointer to the previous element of the list
 * @next: Pointer to the next element of the list
 */

typedef struct listint_s
{
const int n;
    struct listint_s *prev;
    struct listint_s *next;
} listint_t;

void print_list(const listint_t *list);
void insertion_sort_list(listint_t **list);

sort.c

#include "sort.h"
/**
 * insertion_sort_list - Sorts a list of integers using insertion sort algorithm
 *
 * @list: list of integers to be sorted
 * Return: Nothing
 */


void insertion_sort_list(listint_t **list)
{
   listint_t *left, *right, *temp;

        if (list == NULL)
                return;
        left = *list;
        right = left->next;

        if (right == NULL)
                return;

        while (right)
        {
                while (1)
                {
                        if (right->n < left->n)
                        {
                                //swap operation

                                temp = left->prev;
                                left->next = right->next;
                                right->next = left;
                                left->prev = right;
                                right->prev = temp;

                                //incase of a list with only two elements                                                    
                                if (right->prev == NULL)
                                {
                                        *list = right;
                                        return;
                                }
                                  //update the swapped nodes with the rest of the list
                                else
                                {
                                        right->prev->next = right;
                                        left->next->prev = left;
                                }
                        }

                        //if no swap operation
                        else
                                break;

                        //if swap occurred, update the transversal positions
                        right = left;
                        left = right;

                        //prints list after each swap
                        print_list(*list);

                        //move a step backwards and reiterate the loop
                        if (left->prev != NULL)
                        {
                                right = right->prev;
                                left = left->prev;

                        }

                }

                //continue with the next iteration
                right = right->next;
                left = left->next;
        }
}

    #include <stdio.h>
#include <stdlib.h>
#include "sort.h"

/**
 * create_listint - Creates a doubly linked list from an array of integers
 *
 * @array: Array to convert to a doubly linked list
 * @size: Size of the array
 *
 * Return: Pointer to the first element of the created list. NULL on failure
 */
listint_t *create_listint(const int *array, size_t size)
{
    listint_t *list;
    listint_t *node;
    int *tmp;

    list = NULL;
    while (size--)
    {
        node = malloc(sizeof(*node));
        if (!node)
            return (NULL);
        tmp = (int *)&node->n;
        *tmp = array[size];
        node->next = list;
        node->prev = NULL;
        list = node;
        if (list->next)
            list->next->prev = list;
    }
    return (list);
}

/**
 * main - Entry point
 *
 * Return: Always 0
 */
int main(void)
{
    listint_t *list;
    int array[] = {19, 48, 99, 71, 13, 52, 96, 73, 86, 7};
    size_t n = sizeof(array) / sizeof(array[0]);

    list = create_listint(array, n);
    if (!list)
        return (1);
    print_list(list);
    printf("\n");
    insertion_sort_list(&list);
    printf("\n");
    print_list(list);
    return (0);
}

    #include <stdio.h>
#include "sort.h"

/**
 * print_list - Prints a list of integers
 *
 * @list: The list to be printed
 */
void print_list(const listint_t *list)
{
    int i;

    i = 0;
    while (list)
    {
        if (i > 0)
            printf(", ");
        printf("%d", list->n);
        ++i;
        list = list->next;
    }
    printf("\n");
}

I tried to sort a list with the following set of integers:

Input: 19, 48, 99, 71, 13, 52, 96, 73, 86, 7

Output: 19, 48, 71, 99, 13, 52, 96, 73, 86, 7 //swapped only 71

Expected output:

19, 48, 71, 99, 13, 52, 96, 73, 86, 7
19, 48, 71, 13, 99, 52, 96, 73, 86, 7
19, 48, 13, 71, 99, 52, 96, 73, 86, 7
19, 13, 48, 71, 99, 52, 96, 73, 86, 7
13, 19, 48, 71, 99, 52, 96, 73, 86, 7
13, 19, 48, 71, 52, 99, 96, 73, 86, 7
13, 19, 48, 52, 71, 99, 96, 73, 86, 7
13, 19, 48, 52, 71, 96, 99, 73, 86, 7
13, 19, 48, 52, 71, 96, 73, 99, 86, 7
13, 19, 48, 52, 71, 73, 96, 99, 86, 7
13, 19, 48, 52, 71, 73, 96, 86, 99, 7
13, 19, 48, 52, 71, 73, 86, 96, 99, 7
13, 19, 48, 52, 71, 73, 86, 96, 7, 99
13, 19, 48, 52, 71, 73, 86, 7, 96, 99
13, 19, 48, 52, 71, 73, 7, 86, 96, 99
13, 19, 48, 52, 71, 7, 73, 86, 96, 99
13, 19, 48, 52, 7, 71, 73, 86, 96, 99
13, 19, 48, 7, 52, 71, 73, 86, 96, 99
13, 19, 7, 48, 52, 71, 73, 86, 96, 99
13, 7, 19, 48, 52, 71, 73, 86, 96, 99

7, 13, 19, 48, 52, 71, 73, 86, 96, 99 //sorted list

Removing the break statement in the code threw it into an infinite loop. Please help.

Answer 1

What you have there is not an insertion sort. It's close, but there are a number of things breaking it, including the way you are thinking about it.

The main problem is that it is, as coded, too complicated to keep everything straight in your head, so you mixed things up. Part of that is also the names you are using.

Insertion Sort

Insertion sort divides a sequence up into two partitions: sorted and unsorted , in that order.

[1 2 3 4][7 8 0 6 9 5]
 ↑        ↑
 sorted   unsorted

You have already thought about this a little. The sort starts with a sorted partition of length 1.

[3][4 1 2 7 8 0 6 9 5]

Then, while there are unsorted elements (the unsorted partition is not empty), take the first unsorted and find its new position. Move it there, shifting all elements between the new position (inclusive) and old position (exclusive) rightward one .

[3 4][1 2 7 8 0 6 9 5]
[1 3 4][2 7 8 0 6 9 5]
[1 2 3 4][7 8 0 6 9 5]
...
[0 1 2 3 4 6 7 8 9][5]
[0 1 2 3 4 5 6 7 8 9][]

This is a pretty simple algorithm. Two loops: one to traverse the list, and one to scan backwards for the place to insert each time.

Doubly-Linked List Insertion Sort

Linked lists give us an interesting twist here. A normal insertion sort has to repeatedly swap the unsorted element leftward until it is in place. But with a linked list that is a lot of work.

Instead, we can simply unlink the node, and insert it in the correct position. There is no need to do repeated adjacent element swaps!

while (unsorted elements remain):
  found ⟵ scan back to find the node to insert after (this is your inner loop)
  node ⟵ extract first unsorted node
  if (found == NULL):
    insert node at front of list
  else:
    insert node after found

Graphically, that looks like this:

[1]→[3]→[4]→[2]→[7]→[8]→[0]→[6]→[9]→[5]
             ↑
             unsorted

Start searching backwards...

         found
         ↓
[1]→[3]→[4]→[2]→[7]→[8]→[0]→[6]→[9]→[5]
             ↑
             unsorted

...until we find a node where found->n ≤ unsorted->n

 found
 ↓
[1]→[3]→[4]→[2]→[7]→[8]→[0]→[6]→[9]→[5]
             ↑
             unsorted

Extract the unsorted node, making sure to update unsorted to point to the next available node (if any):

            extracted node
            ↓
 found     [2]
 ↓
[1]→[3]→[4]→[7]→[8]→[0]→[6]→[9]→[5]
             ↑
             (the new) unsorted

Insert the extracted node after the found found node:

 found
 ↓
[1]→[2]→[3]→[4]→[7]→[8]→[0]→[6]→[9]→[5]
     ↑           ↑
     node        unsorted

Done. Ready for the next loop.

[1]→[2]→[3]→[4]→[7]→[8]→[0]→[6]→[9]→[5]
                 ↑
                 unsorted

Extract and Insert Nodes

If you don't already, you will need some functions to unlink and insert nodes from/into a list. I recommend:

void unlink_node (listint_t **list, listint_t *node);

void append_node (listint_t **tail, listint_t *node);
void prepend_node(listint_t **head, listint_t *node);
// Unlike other list functions, `head` and `tail` need not point to the
// head of the list (though they could)! Their values are updated, however, 
// to maintain the whole list and their head/tail position in the sublist.

You should not be doing this manually inside your sort function. All it does is add complexity that makes it harder to see what you are doing. Abstract those operations elsewhere and keep your sort function short and clean.

My version of your insertion sort function is about 12 lines long. You should be able to do something similar — twenty lines maximum with heavy commentary.

Apologies

I know this is a bit to think about, and not a fix-your-code kind of answer. Honestly, you got lost and your code is pretty badly broken. Toss the sorting code you wrote and start over. The hints I give above are far more direct than you may think.

Always think about your algorithm before you start hacking out code. In this case we can see that it benefits us to have the link and unlink helper functions. That abstracts the complexity of those operations away so that we don't overwhelm ourselves when trying to sort. By breaking your code up into smaller chunks, everything you do is significantly less complex, letting you focus on a simpler problem without stumbling into the weeds.

Main

Here is the main function I wrote to play with this:

#include <stdio.h>
#include <stdlib.h>
#include "listint.h"

int main(int argc, char **argv)
{
    listint_t *list = NULL;

    // Convert program arguments into linked list of integers    
    listint_t *tail = list;
    for (int n = 1;  n < argc;  n++)
    {
        append_node(&tail, new_node(atoi(argv[n])));
        if (!list) list = tail;
    }
    
    // Sort the list and show the user
    insertion_sort_list(&list);
    print_list(&list);
    
    // Don’t forget to clean up!
    free_list(&list);  
    return 0;
}

And some example runs:

C:\Users\Dúthomhas\programming\cpp\foo> main 2 1 -7 34 5
-7 1 2 5 34

C:\Users\Dúthomhas\programming\cpp\foo> main 3 3 3
3 3 3

C:\Users\Dúthomhas\programming\cpp\foo> main 0
0

C:\Users\Dúthomhas\programming\cpp\foo> main 1 2 3
1 2 3

C:\Users\Dúthomhas\programming\cpp\foo> main 4 2
2 4

Consistency

Your linked list functions should be as consistent as possible. For example, the print_list() function should take a listint_t ** , just like all the other list functions. Even though it doesn't need a reference to the list, it makes using it work just like any other list function.

Your indentation and spacing is pretty good. I assume the inconsistencies were just where you were messing with it. Personally, eight spaces is a very wide indent. Switch to 2 or 4.

Names

Choose names that reflect what a thing is or does. You seem to be already aware of this to some degree. Choice of left and right in your algorithm suggests to me part of the logic you tried to implement (and why that logic failed — sorting a linked list is different than sorting an array).

As you think about the algorithm, before you even start writing code , you should be generating names for things that reflect what your algorithm is doing. My version of the sort uses the very same names I created when I thought through the algorithm above: unsorted , node , find .

Likewise, even the filenames you choose matter. The header file, for example, has as its primary purpose describing a doubly-linked list of integers and the operations that can be performed on them — one of which (the primary one for this homework, I assume) is sorting it. But sorting is still just an appendage to maintaining a list. Hence, the files I created to play with this are named:

listint.h
listint.c
main.c

Commentary and documentation

The header file is your primary source of documentation for any library. Put the primary doxygen markup there.

Remember, the purpose of documentation is for users of your library. Users should not care about anything except the interface presented to them.

Here we have a listint_t , and functions to work over a listint_t * .

#ifndef LISTINT_H
#define LISTINT_H

/**
 * listint_t - Doubly linked list node
 *
 * @n: Integer stored in the node
 * @prev: Pointer to the previous element of the list
 * @next: Pointer to the next element of the list
 */
typedef struct listint_s
{
    const int n;
    struct listint_s *prev;
    struct listint_s *next;
} listint_t;

/**
 * new_node() - Create a new node
 *
 * @n: Integer to store in the node
 *
 * Return: The new, unlinked node, or NULL on allocation failure.
 */
listint_t *new_node(int n);

/**
 * free_list() - Delete an entire list
 *
 * @list: Reference to the list to delete. May not be NULL.
 *        (The referenced list itself may be NULL, though.)
 */
void free_list(listint_t **list);

/**
 * append_node()
 * prepend_node()
 * unlink_node()  - Add or remove nodes in a list
 *
 * @tail: Reference to the last node in a sublist
 * @head: Reference to the first node in a sublist
 * @list: Reference to the list to modify.
 * @node: The node to add or remove. If adding,
 *        the node must not be part of any list.
 *        If removing, the node must be a member
 *        of the argument list.
 */
void append_node (listint_t **tail, listint_t *node);
void prepend_node(listint_t **head, listint_t *node);
void unlink_node (listint_t **list, listint_t *node);

/**
 * insertion_sort_list() - Sorts a list of integers using insertion sort algorithm
 *
 * @list: Reference to the list of integers to be sorted
 */
void insertion_sort_list(listint_t **list);

/**
 * print_list() - Print a list to stdout
 *
 * @list: Reference to the list
 */
void print_list(listint_t **list);

#endif

(Sorry for abusing the Doxygen markup a little, but my patience with it is thin for some fun question I found on the inte.net.)

This stuff is hard. But it will make sense eventually. Keep going!