单链表的排序

/*单链表结点数据结构*/
typedef struct node
{
    int key;
    struct node *next;
}node_t, *list_t;

1移动结点上的值

1.1选择排序（时间复杂度为O(n^2)）

void list_select_sort(list_t h)
{
    int min = 0;
    list_t p = NULL;
    list_t q = NULL;
    list_t s = NULL;
    
    for (p = h; p != NULL; p = p->next)
    {
        min = p->key;
        s = p;
        for (q = p->next; q != NULL; q = q->next)
        {
            if (min > q->key)
            {
                min = q->key;
                s = q;
            }
        }
        s->key = p->key;
        p->key = min;
    }
    
    return ;
}

1.2快速排序（时间复杂度为O(nlogn)）

    声明两个指针p和q，两个指针均往next方向移动，移动过程中保持p之前的key都小于选定的key，p和q之间的key都大于选定的key，则当q走到末尾的时候便完成了一次支点的寻找。

/*交换数据*/
void swap(int *n, int *m)
{
    int temp;
    temp = *n;
    *n   = *m;
    *m   = temp;
}
/*分区操作*/
list_t partion(list_t bgn, list_t end)
{
    int key = bgn->key;
    list_t p = bgn;
    list_t q = bgn->next;

    while (q != end)
    {
        if (q->key < key)
        {
            p = p->next;
            swap(&p->key, &q->key);
        }
        q = q->next;
    }
    swap(&p->key, &bgn->key);
    return p;

}
/*快速排序*/
void list_quick_sort(list_t bgn, list_t end)
{
    if (bgn != end)
    {
        list_t part = partion(bgn, end);
        list_quick_sort(bgn, part);
        list_quick_sort(part->next, end);
    }
}

2移动结点

    类似快速排序，采用递归分治方法进行排序的，每次对原有的链表进行一次划分，每次划分取链表的左端的那个结点值作为枢轴，将小于枢轴的值用 t1 指针连接起来，将大于枢轴的值用 t2 指针连接起来，然后在分别对这 2 个短的链表进行递归排序。

list_t qsortL(list_t h, list_t lnext)  
{          
    node_t n1, n2;          
    list_t p, t1 = &n1, t2 = &n2;          

    if(h == NULL) return lnext;    
    
    for(p = h->next; p != NULL; p = p->next)
    {
         if (p->key < h->key)           
         {                          
             t1->next = p;                          
             t1 = p;                 
         }                  
         else                  
         {                         
             t2->next = p;                       
             t2 = p;                 
         }         
     }
     t1->next = t2->next = NULL;            
     h->next = qsortL(n2.next,lnext); 
     
     return qsortL(n1.next, h);  
}