单链表的排序

/*单链表结点数据结构*/
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);
}