sorting linked list simplest way

问题

I am trying to code very basic sorting method for linked lists. I am getting unhandled exception. What is the mistake i am making? Here is my code:-

   struct LinkedNode// structure for linked list
        {
            int data;
            struct LinkedNode *next;
        }*start = NULL;

following function creates a linked list

 void CreateLinkedList()
        {
        LinkedNode *newNode, *current;
        printf("enter 5 numbers to create linked list\n");
        for(int i=0; i<5; i++)
            {
            newNode = (struct LinkedNode *)malloc(sizeof(LinkedNode));
            scanf("%d", &newNode->data);
            newNode->next = NULL;
            if(start == NULL)
                {
                start = newNode;
                current = newNode;
                }
            else
                {
                current->next = newNode;
                current = newNode;
                }
           }
        }

following function is used for sorting the linked list nodes

 void SortLinkedList()
    {
    struct LinkedNode *node=NULL, *temp = NULL;
    int tempvar;//temp variable to store node data
    node = start;
    temp = node->next;//temp node to hold node data and next link
    while(node != NULL && node->next != NULL)
    {
        for(int j=0; j<5; j++)//value 5 because I am taking only 5 nodes
        {
            if(node->data > temp->data)//swap node data
            {
                tempvar = node->data;
                node->data = temp->data;
                temp->data = tempvar;
            }
            temp = temp->next;
        }
        node = node->next;
      }
    }

回答1:

Try This code

void SortLinkedList()
    {
    struct LinkedNode *node=NULL, *temp = NULL;
    int tempvar;//temp variable to store node data
    node = start;
    //temp = node;//temp node to hold node data and next link
    while(node != NULL)
    {
        temp=node; 
        while (temp->next !=NULL)//travel till the second last element 
        {
           if(temp->data > temp->next->data)// compare the data of the nodes 
            {
              tempvar = temp->data;
              temp->data = temp->next->data;// swap the data
              temp->next->data = tempvar;
            }
         temp = temp->next;    // move to the next element 
        }
        node = node->next;    // move to the next node
    }
}

1 - outer while loop is use for the total number of pass that will require to sort the linked list..

2- In second while loop we are actually comparing the data of the nodes that we want to sort

回答2:

yeah sorting a linked list using nodes/links is a pretty hard job. Spend hours doing it myself but since i have done it why not help others.. What you need to do is simply find the minimum value in your list. Swap it with the head node and the recur for head->next. The code for sort is only of 3 to 4 lines if you have FindMin() and Swap() functions made.. here is the complete code for sort(),swap()and findmin().

void sort(node **start)
{
    if (((*start)->next == NULL) || (*start == NULL))
    {
        return;
    }
    node *min = findmin(*start);
    swap(*start, min, start);
    sort(&((*start)->next));
}

void swap(node *p1, node *p2, node **start)
{
    node *p1pre = NULL;
    node *p1curr = *start;
    while (p1curr!=p1)
    {
        p1pre = p1curr;
        p1curr = p1curr->next;
    }
    node *p2pre = NULL;
    node *p2curr = *start;
    while (p2curr != p2)
    {
        p2pre = p2curr;
        p2curr = p2curr->next;
    }
    if (p1pre != NULL)
    {
        p1pre->next = p2curr;
    }
    else
    {
        *start = p2curr;
    }
    if (p2pre != NULL)
    {
        p2pre->next = p1curr;
    }
    else
    {
        *start = p1curr;
    }
    node *temp = p2curr->next;
    p2curr->next = p1curr->next;
    p1curr->next = temp;
}

node* findmin(node *start)
{
    int flag = 0;
    if (start == NULL)
    {
        cout << "list is empty" << endl;
    }
    else
    {
        node *curr = start->next;
        node *min = start;
        while (curr->next != NULL)
        {
            if (min->value > curr->value)
            {
                min = curr;
                flag++;
            }
            curr = curr->next;
        }
        if ((curr->next == NULL) && (min->value > curr->value))
        {
            min = curr;
            flag++;
        }
        if (flag > 0)
        {
            return min;
        }
    }
}

回答3:

Instead of implementing your own sort, you can just use qsort. Of course, qsort requires an array, but that is easy enough to create.

In this case, you know that the list has 5 members. But, if you didn't know, you could just count them.

int size_of_list = 0;
struct LinkedNode *p;

for (p = start; p != NULL; p = p->next) ++size_of_list;

if (size_of_list == 0) {
    // Nothing to do
    return;
}

Now you can create your array;

struct LinkedNode *arr[size_of_list + 1], **arrp = arr;
for (p = start; p != NULL; p = p->next) *arrp++ = p;
*arrp = NULL;

Then, use qsort on arr. There are lots of examples, but the trick is writing an appropriate comparison function.

int cmp_LinkedNode(const void *a, const void *b) {
    const struct LinkedNode * const *aa = a;
    const struct LinkedNode * const *bb = b;
    return ((*aa)->data > (*bb)->data) - ((*aa)->data < (*bb)->data);
}

//...
qsort(arr, size_of_list, sizeof(*arr), cmp_LinkedNode);

And then, rewire the list into the sorted order.

for (int i = 0; i < size_of_list; ++i) arr[i]->next = arr[i+1];
start = arr[0];

来源：https://stackoverflow.com/questions/35914574/sorting-linked-list-simplest-way