单链表的一些排序法

单链表排序：
前提：
typedef struct node
{
    in data;
    struct node * next;
}linklist;
插入排序：
void sortlist(linklist * head)
{
    linklist * newhead, * s, * pre ,* p;
    p=head->next;
    newhead=p->next;
    p->next=NULL;
    while(newhead)
    {
        s=newhead;
        newhead=newhead->next;
        pre=head;
        p=head->next;
        while(p!=NULL && p->data < s->data)
        {
            pre=p;
            p=p->next;
        }
        s->next=p;
        pre->next=s;
    }
}
选择排序：
void selectsort(linklist * head)
{
    linklist * p, * min , *q;
    int t;
    for( p=head->next;p->next!=NULL;p=p->next)
    {
        for(min=p,q=p->next;q!=NULL;q=q->next)
        {
            if(q->data < min->data)
                min=q;
        }
        if(min!=p)
        {
            t=p->data;
            p->data=min->data;
            min->data=t;
        }
    }
}
冒泡排序：
void bubblesort(linklist * head)
{
    linklist * end, * p , * q;//end用来记录排好序的最后一个元素地址，p，q分别为前驱，后继
    int temp;
    p=head->next;
    q=p->next;
    end=NULL;
    while(end!=head->next)
    //如果head所指结点的next成员为end，循环结束
    {
        p=head->next;//p结点从链表头结点开始
        q=p->next;//q指向p所指结点的下一个结点
        while(p->next!=end)
        //当p->next的值为end时，表示到链尾
        {
            if(p->data>q->data)//按照数据域从小到大排序
            {
                temp=p->data;
                p->data=q->data;
                q->data=temp;
            }
            p=q;
            q=q->next;
        }
        end=p;//使end指向每次排序的q所指的结点即尾结点
    }
}

单链表插入排序

//简单单链表排序 : 插入排序
ListNode* ListSort(ListNode* head)
{
    if(head == NULL) return NULL;
    ListNode *curNode = NULL,*preNode=NULL,*nextNode=NULL,*node = NULL;
    curNode = head->next;
    head->next = NULL;
    while(curNode)//当前要插入的节点
    {
        node = curNode->next;//保存下一个节点
        if(curNode->value < head->value)//比头结点还小，则成为新的头结点
        {
            curNode->next = head;
            head = curNode;
        }
        else
        {
            preNode = head, nextNode = head->next;
            while(nextNode && nextNode->value<curNode->value)//找到合适位置
            {
                preNode = nextNode;
                nextNode = nextNode->next;
            }
            curNode->next = preNode->next;
            preNode->next = curNode;
        }
        curNode = node;
    }
    return head;//返回新的头结点
}

简单测试：

    const int N = 10;
    string tmp[N]= {"9","3","7","8","1","5","4","0","2","6"};
    ListNode* root = new ListNode;
    root->value = tmp[0];
    ListNode* cur = root,*loopNode = NULL;
    int i = 1;
    while(i < N)
    {
        InsertAfter(cur,tmp[i]);
        cur = cur->next;
        ++i;
    }
    PrintList(root);
    root = ListSort(root);
    PrintList(root);