单链表排序

// 链表排序.cpp : 定义控制台应用程序的入口点。
//

include “stdafx.h”

include “stdio.h”

include “stdlib.h”

include “time.h”

typedef struct Node{
int num;
struct Node *next;
} node_t;

/*
选择排序的基本思想就是反复从还未排好序的那些节点中，
选出键值最小的节点，
依次重新组合成一个链表。
写链表这类程序，关键是理解：
head存储的是第一个节点的地址，head->next存储的是第二个节点的地址；
对单向链表来说,任意一个节点p的地址，只能通过它前一个节点的next来求得。
单向链表选择排序图示：
原始链表:
—->[1]—->[3]—->[2]…—->[n]—->[NULL]（原链表）
head 1->next 3->next 2->next n->next
有序链表初始值:
—->[NULL]（空链表）
first
tail
排序后:
—->[1]—->[2]—->[3]…—->[n]—->[NULL]（排序后链表）
first 1->next 2->next 3->next tail->next
总结如下:
1、先在原链表中找最小的，找到一个后就把它放到另一个空的链表中；
2、空链表中安放第一个进来的节点，产生一个有序链表,并且让它在原链表中分离出来（此时要注意原链表中出来的是第一个节点还是中间其它节点）；
3、继续在原链表中找下一个最小的，找到后把它放入有序链表的尾指针的next,然后它变成其尾指针；
*/
node_t *select_sort_small_2_large(node_t *head)
{
node_t first = NULL; /排列后有序链的表头指针*/
node_t tail = NULL; /排列后有序链的表尾指针*/
node_t p_min = NULL; /保留键值更小的节点的前驱节点的指针*/
node_t min = NULL; /存储最小节点,当前比较节点*/
node_t p = NULL; /另一个比较节点的前驱节点*/

first = NULL;
while (head != NULL) /*在链表中找键值最小的节点。*/
{
    /*注意：这里for语句就是体现选择排序思想的地方*/
    for (p = head, min = head; p->next != NULL; p = p->next) /*循环遍历链表中的节点，找出此时最小的节点。*/
    {
        if (p->next->num < min->num) /*找到一个比当前min小的节点。*/
        {
            p_min = p; /* 更小节点为p->next,保存找到"更小节点"的前驱节点：显然p->next的前驱节点是p。*/
            min = p->next; /* 保存键值更小的节点。*/
        }
    }

    /* 上面for语句结束后，就要做两件事；一是把它放入有序链表中；二是根据相应的条件判断，安排它离开原来的链表。*/

    /*第一件事*/
    if (first == NULL) /*如果有序链表目前还是一个空链表*/
    {
        first = min; /* 第一次找到键值最小的节点。*/
        tail = min; /* 注意：尾指针让它指向最后的一个节点。*/
    }
    else /* 有序链表中已经有节点*/
    {
        tail->next = min; /* 把刚找到的最小节点放到最后，即让尾指针的next指向它。*/
        tail = min; /* 然后尾指针再指向它。*/
    }

    /*第二件事*/
    if (min == head) /*如果找到的最小节点就是第一个节点*/
    {
        head = head->next; /* 显然让head指向原head->next,即第二个节点，就OK了 */
    }
    else /*如果不是第一个节点*/
    {
        p_min->next = min->next; /*前次最小节点的next指向当前min的next,这样就让min离开了原链表。*/
    }
}

if (first != NULL) /* 循环结束得到有序链表first*/
{
    tail->next = NULL; /* 单向链表的最后一个节点的next应该指向NULL!*/
}
head = first;
return head;

}

node_t *select_sort_large_2_small(node_t *head)
{
node_t first = NULL; /排列后有序链的表头指针*/
node_t tail = NULL; /排列后有序链的表尾指针*/
node_t p_min = NULL; /保留键值更小的节点的前驱节点的指针*/
node_t min = NULL; /存储最小节点,当前比较节点*/
node_t p = NULL; /另一个比较节点的前驱节点*/

first = NULL;
while (head != NULL) /*在链表中找键值最小的节点。*/
{
    /*注意：这里for语句就是体现选择排序思想的地方*/
    for (p = head, min = head; p->next != NULL; p = p->next) /*循环遍历链表中的节点，找出此时最小的节点。*/
    {
        if (p->next->num > min->num) /*找到一个比当前min大的节点。-->只需修改此 */
        {
            p_min = p; /* 更小节点为p->next,保存找到"更小节点"的前驱节点：显然p->next的前驱节点是p。*/
            min = p->next; /* 保存键值更小的节点。*/
        }
    }

    /* 上面for语句结束后，就要做两件事；一是把它放入有序链表中；二是根据相应的条件判断，安排它离开原来的链表。*/

    /*第一件事*/
    if (first == NULL) /*如果有序链表目前还是一个空链表*/
    {
        first = min; /* 第一次找到键值最小的节点。*/
        tail = min; /* 注意：尾指针让它指向最后的一个节点。*/
    }
    else /* 有序链表中已经有节点*/
    {
        tail->next = min; /* 把刚找到的最小节点放到最后，即让尾指针的next指向它。*/
        tail = min; /* 然后尾指针再指向它。*/
    }

    /*第二件事*/
    if (min == head) /*如果找到的最小节点就是第一个节点*/
    {
        head = head->next; /* 显然让head指向原head->next,即第二个节点，就OK了 */
    }
    else /*如果不是第一个节点*/
    {
        p_min->next = min->next; /*前次最小节点的next指向当前min的next,这样就让min离开了原链表。*/
    }
}

if (first != NULL) /* 循环结束得到有序链表first*/
{
    tail->next = NULL; /* 单向链表的最后一个节点的next应该指向NULL!*/
}
head = first;
return head;

}

define LEN (10)

int _tmain(int argc, _TCHAR* argv[])
{
{

    node_t *stu = NULL;
    node_t *head = NULL, *tail = NULL,*tmp = NULL;
    int i = 0, number = 0;
    srand((unsigned)time(NULL)); //用时间做种，每次产生随机数不一样 ,

    for (i = 0; i<LEN; i++)
    {
        number = rand() % 101; //产生0-100的随机数
        number = number - 50; // 产生-50~~50的随机数
        printf("-->(%d)", number);

        stu = (node_t *)malloc(sizeof(node_t));
        if (!stu)
        {
            printf("\n-->error:内存不足 or 其他异常.\n");
            exit(1);
        }

        stu->next = NULL;
        stu->num = number;
        if (!head)
        {
            head = tail = stu;
        }
        else{
            tail->next = stu;
            tail = stu;
        }
    }
    printf("\n以上为原始数据!\n以下为从链表中打印的数据:\n");
    tmp = head;
    while (tmp)
    {
        printf("-->(%d)",tmp->num);
        tmp = tmp->next;
    }

    head=select_sort_small_2_large(head);
    printf("\n链表排序后打印的数据:\n");
    tmp = head;
    while (tmp)
    {
        printf("-->(%d)", tmp->num);
        tmp = tmp->next;
    }

}

{

    node_t *stu = NULL;
    node_t *head = NULL, *tail = NULL, *tmp = NULL;
    int i = 0, number = 0;
    srand((unsigned)time(NULL)); //用时间做种，每次产生随机数不一样 ,
    printf("\n#####################################################开始\n");
    for (i = 0; i<LEN; i++)
    {
        number = rand() % 101; //产生0-100的随机数
        number = number - 50; // 产生-50~~50的随机数
        printf("-->(%d)", number);

        stu = (node_t *)malloc(sizeof(node_t));
        if (!stu)
        {
            printf("\n-->error:内存不足 or 其他异常.\n");
            exit(1);
        }

        stu->next = NULL;
        stu->num = number;
        if (!head)
        {
            head = tail = stu;
        }
        else{
            tail->next = stu;
            tail = stu;
        }
    }
    printf("\n以上为原始数据!\n以下为从链表中打印的数据:\n");
    tmp = head;
    while (tmp)
    {
        printf("-->(%d)", tmp->num);
        tmp = tmp->next;
    }

    head = select_sort_large_2_small(head);
    printf("\n链表排序后打印的数据:\n");
    tmp = head;
    while (tmp)
    {
        printf("-->(%d)", tmp->num);
        tmp = tmp->next;
    }

}

if(0){ 
    int i = 0, number = 0;
    srand((unsigned)time(NULL)); //用时间做种，每次产生随机数不一样 ,
    for (i = 0; i<50; i++)
    {
        number = rand() % 101; //产生0-100的随机数
        printf("%d ", number);
    }

}

return 0;

}