本文文字说明来自：http://blog.csdn.net/northplayboy/article/details/552388
链表中的基本操作函数：http://blog.csdn.net/thystar/article/details/41154799
代码用C++实现
==========================
功能：选择排序(由小到大)
返回：指向链表表头的指针
==========================
选择排序的基本思想就是反复从还未排好序的那些节点中，
选出键值（就是用它排序的字段，我们取学号num为键值）最小的节点，
依次重新组合成一个链表。
我认为写链表这类程序，关键是理解：
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
图10：有N个节点的链表选择排序
1、先在原链表中找最小的，找到一个后就把它放到另一个空的链表中；
2、空链表中安放第一个进来的节点，产生一个有序链表,并且让它在原链表中分离出来（此时要注意原链表中出来的是第一个节点还是中间其它节点）；
3、继续在原链表中找下一个最小的，找到后把它放入有序链表的尾指针的next,然后它变成其尾指针；
*/
代码实现：
/*
链表排序
*/
#include<cstdlib>
#include<iostream>
using namespace std;
typedef int ElemType;
struct LNode
{
ElemType data;
LNode* next;
};
#include "SList.h"
//选择排序
LNode* SelectSort(LNode *head)
{
LNode* first; // 排列后有序链表的表头指针
LNode* tail; // 排列后有序链表的尾指针
LNode* p_min; // 保留键值最小的结点的前驱节点的指针
LNode* min; // 存储最小结点
LNode* p; // 当前比较的结点
first = NULL;
//在原始链表中寻找最小的结点
while(head != NULL)
{
p = head;
min = head;
//循环遍历表中的结点，找出最小的结点
for(; p->next != NULL; p = p->next)
{
if(p->next->data < min->data) //找到一个比当前min小的结点
{
p_min = p; // 保存找到结点的前驱结点，p->next的前驱结点是p
min = p->next; // 保存键值更小的结点
}
}
//for循环结束后，要做两件事
//1.把取得的最小值放入有序链表中
//2.根据相应的条件判断，安排它离开原来的链表，即在原来的联保中删除这个值。
//1.把取得的最小值放入有序链表中
if(first == NULL) //如果有序链表目前是个空链表
{
first = min; //第一次找到的键值最小的结点
tail = min; //为指针要指向最后一个结点
}
else //有序链表中已经有结点,向有序链表尾部添加结点
{
tail->next = min; //把刚找到的最小节点放到最后，即让尾指针的next指向它
tail = min; //尾指针也要指向它。
}
// 2. 根据相应的条件判断，安排它离开原来的链表，即在原来的联保中删除这个值。
if(min == head) //如果找到的最小节点就是第一个节点
{
head = head->next;
}
else //如果不是第一个结点
{
p_min->next = min->next; //前次最小节点的next指向当前min的next,这样就让min离开了原链表。
}
}
if(first != NULL) //循环结束得到有序链表first
{
tail->next = NULL;
}
head = first;
return head;
}
void main()
{
LNode *head;
InitList(head); //初始化链表
int i, num;
//随机生成10个数
for(i = 0; i < 10; i++)
{
num = rand()%100;
InsertRear(head,num);
}
cout<<"排序前："<<endl;
TraverseList(head); //遍历链表
//单链表排序
//选择排序
head = SelectSort(head);
cout<<"排序后（选择排序）："<<endl;
TraverseList(head);
}
/*
==========================
功能：直接插入排序(由小到大)
返回：指向链表表头的指针
==========================
*/
/*
直接插入排序的基本思想就是假设链表的前面n-1个节点是已经按键值
（就是用它排序的字段，我们取学号num为键值）排好序的，对于节点n在
这个序列中找插入位置，使得n插入后新序列仍然有序。按照这种思想，依次
对链表从头到尾执行一遍，就可以使无序链表变为有序链表。
单向链表的直接插入排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head 1->next 3->next 2->next n->next
---->[1]---->[NULL]（从原链表中取第1个节点作为只有一个节点的有序链表）
head
图11
---->[3]---->[2]...---->[n]---->[NULL]（原链表剩下用于直接插入排序的节点）
first 3->next 2->next n->next
图12
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
head 1->next 2->next 3->next n->next
图13：有N个节点的链表直接插入排序
1、先在原链表中以第一个节点为一个有序链表，其余节点为待定节点。
2、从图12链表中取节点，到图11链表中定位插入。
3、上面图示虽说画了两条链表，其实只有一条链表。在排序中，实质只增加了一个用于指向剩下需要排序节点的头指针first罢了。
这一点请读者务必搞清楚，要不然就可能认为它和上面的选择排序法一样了。
*/
// 插入排序
LNode* InsertSort(LNode* head)
{
LNode* first; //原链表剩下用于直接插入排序的节点头指针
LNode* t; //临时指针变量:插入结点
LNode* p, * q; // 临时指针变量
//插入排序认为第一个结点是排好序的
//head之后的结点均无序
//因此，first指向head之后的结点作为无序结点的表头
//head断开后面的指针作为有序链表的表头
first = head->next; //原链表剩下用于直接插入排序的节点链表：可根据图12来理解。
head->next = NULL; // 只含有一个节点的链表的有序链表：可根据图11来理解。
//遍历剩下的无序链表
while(first != NULL)
{
t = first;
q = head;
//这里while语句就是体现直接插入排序思想的地方
while((q != NULL) && (q->data < t->data)) //无序节点在有序链表中找插入的位置
{
p = q;
q = q->next;
}
//退出while循环，就是找到了插入的位置
first = first->next; //无序链表中的节点离开，以便它插入到有序链表中。
if(q == head) // 插到第一个结点之前
{
head = t;
}
else //p是q的前驱
{
p->next = t;
}
t->next = q; //完成插入动作
}
return head;
}调用与选择排序的方法相同。
/*
==========================
功能：冒泡排序(由小到大)
返回：指向链表表头的指针
==========================
*/
/*
直接插入排序的基本思想就是对当前还未排好序的范围内的全部节点，
自上而下对相邻的两个节点依次进行比较和调整，让键值（就是用它排
序的字段，我们取学号num为键值）较大的节点往下沉，键值较小的往
上冒。即：每当两相邻的节点比较后发现它们的排序与排序要求相反时，
就将它们互换。
单向链表的冒泡排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head 1->next 3->next 2->next n->next
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
head 1->next 2->next 3->next n->next
图14：有N个节点的链表冒泡排序
任意两个相邻节点p、q位置互换图示:
假设p1->next指向p，那么显然p1->next->next就指向q,
p1->next->next->next就指向q的后继节点，我们用p2保存
p1->next->next指针。即：p2=p1->next->next，则有：
[ ]---->[p]---------->[q]---->[ ]（排序前）
p1->next p1->next->next p2->next
图15
[ ]---->[q]---------->[p]---->[ ]（排序后）
图16
1、排序后q节点指向p节点，在调整指向之前，我们要保存原p的指向节点地址，即：p2=p1->next->next；
2、顺着这一步一步往下推,排序后图16中p1->next->next要指的是p2->next,所以p1->next->next=p2->next;
3、在图15中p2->next原是q发出来的指向，排序后图16中q的指向要变为指向p的，而原来p1->next是指向p的，所以p2->next=p1->next;
4、在图15中p1->next原是指向p的，排序后图16中p1->next要指向q,原来p1->next->next（即p2)是指向q的，所以p1->next=p2;
5、至此，我们完成了相邻两节点的顺序交换。
6、下面的程序描述改进了一点就是记录了每次最后一次节点下沉的位置，这样我们不必每次都从头到尾的扫描，只需要扫描到记录点为止。
因为后面的都已经是排好序的了。
*/
// 冒泡排序
LNode* BubbleSort(LNode* head)
{
LNode* endpt; //控制循环比较
LNode* p; //临时指针变量
LNode* p1, *p2;
p1 = new LNode;
p1->next = head; //注意理解：我们增加一个节点，放在第一个节点的前面，主要是为了便于比较。
//因为第一个节点没有前驱，我们不能交换地址。
head = p1; //让head指向p1节点，排序完成后，我们再把p1节点释放掉
for(endpt = NULL; endpt!=head; endpt = p) //结合第6点理解
{
for(p = p1 = head; p1->next->next != endpt; p1 = p1->next)
{
if(p1->next->data > p1->next->next->data)//如果前面的节点键值比后面节点的键值大，则交换
{
p2 = p1->next->next; //结合第1点理解
p1->next->next = p2->next; //结合第2点理解
p2->next = p1->next; //结合第3点理解
p1->next = p2; //结合第4点理解
p = p1->next->next; //结合第6点理解
}
}
}
p1 = head; //把p1的信息去掉
head = head->next; //让head指向排序后的第一个结点
delete p1; //释放p1
return head;
}完整的代码在下面给出：
/*
链表排序
*/
#include
#include
using namespace std;
typedef int ElemType;
struct LNode
{
ElemType data;
LNode* next;
};
#include "SList.h"
//选择排序
LNode* SelectSort(LNode *head)
{
LNode* first; // 排列后有序链表的表头指针
LNode* tail; // 排列后有序链表的尾指针
LNode* p_min; // 保留键值最小的结点的前驱节点的指针
LNode* min; // 存储最小结点
LNode* p; // 当前比较的结点
first = NULL;
//在原始链表中寻找最小的结点
while(head != NULL)
{
p = head;
min = head;
//循环遍历表中的结点，找出最小的结点
for(; p->next != NULL; p = p->next)
{
if(p->next->data < min->data) //找到一个比当前min小的结点
{
p_min = p; // 保存找到结点的前驱结点，p->next的前驱结点是p
min = p->next; // 保存键值更小的结点
}
}
//for循环结束后，要做两件事
//1.把取得的最小值放入有序链表中
//2.根据相应的条件判断，安排它离开原来的链表，即在原来的联保中删除这个值。
//1.把取得的最小值放入有序链表中
if(first == NULL) //如果有序链表目前是个空链表
{
first = min; //第一次找到的键值最小的结点
tail = min; //为指针要指向最后一个结点
}
else //有序链表中已经有结点,向有序链表尾部添加结点
{
tail->next = min; //把刚找到的最小节点放到最后，即让尾指针的next指向它
tail = min; //尾指针也要指向它。
}
// 2. 根据相应的条件判断，安排它离开原来的链表，即在原来的联保中删除这个值。
if(min == head) //如果找到的最小节点就是第一个节点
{
head = head->next;
}
else //如果不是第一个结点
{
p_min->next = min->next; //前次最小节点的next指向当前min的next,这样就让min离开了原链表。
}
}
if(first != NULL) //循环结束得到有序链表first
{
tail->next = NULL;
}
head = first;
return head;
}
// 插入排序
LNode* InsertSort(LNode* head)
{
LNode* first; //原链表剩下用于直接插入排序的节点头指针
LNode* t; //临时指针变量:插入结点
LNode* p, * q; // 临时指针变量
//插入排序认为第一个结点是排好序的
//head之后的结点均无序
//因此，first指向head之后的结点作为无序结点的表头
//head断开后面的指针作为有序链表的表头
first = head->next; //原链表剩下用于直接插入排序的节点链表：可根据图12来理解。
head->next = NULL; // 只含有一个节点的链表的有序链表：可根据图11来理解。
//遍历剩下的无序链表
while(first != NULL)
{
t = first;
q = head;
//这里while语句就是体现直接插入排序思想的地方
while((q != NULL) && (q->data < t->data)) //无序节点在有序链表中找插入的位置
{
p = q;
q = q->next;
}
//退出while循环，就是找到了插入的位置
first = first->next; //无序链表中的节点离开，以便它插入到有序链表中。
if(q == head) // 插到第一个结点之前
{
head = t;
}
else //p是q的前驱
{
p->next = t;
}
t->next = q; //完成插入动作
}
return head;
}
// 冒泡排序
LNode* BubbleSort(LNode* head)
{
LNode* endpt; //控制循环比较
LNode* p; //临时指针变量
LNode* p1, *p2;
p1 = new LNode;
p1->next = head; //注意理解：我们增加一个节点，放在第一个节点的前面，主要是为了便于比较。
//因为第一个节点没有前驱，我们不能交换地址。
head = p1; //让head指向p1节点，排序完成后，我们再把p1节点释放掉
for(endpt = NULL; endpt!=head; endpt = p) //结合第6点理解
{
for(p = p1 = head; p1->next->next != endpt; p1 = p1->next)
{
if(p1->next->data > p1->next->next->data)//如果前面的节点键值比后面节点的键值大，则交换
{
p2 = p1->next->next; //结合第1点理解
p1->next->next = p2->next; //结合第2点理解
p2->next = p1->next; //结合第3点理解
p1->next = p2; //结合第4点理解
p = p1->next->next; //结合第6点理解
}
}
}
p1 = head; //把p1的信息去掉
head = head->next; //让head指向排序后的第一个结点
delete p1; //释放p1
return head;
}
void main()
{
//单链表排序
LNode *head;
InitList(head); //初始化链表
int i, num;
//随机生成10个数
for(i = 0; i < 10; i++)
{
num = rand()%100;
InsertRear(head,num);
}
cout<<"排序前："<
结果
540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
