本文目录一览：
链表排序的原理是什么
==========================
功能：选择排序(由小到大)
返回：指向链表表头的指针
==========================
*/
/*
选择排序的基本思想就是反复从还未排好序的那些节点中，
选出键值（就是用它排序的字段，我们取学号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,然后它变成其尾指针；
*/
struct student *SelectSort(struct student *head)
{
struct student *first; /*排列后有序链的表头指针*/
struct student *tail; /*排列后有序链的表尾指针*/
struct student *p_min; /*保留键值更小的节点的前驱节点的指针*/
struct student *min; /*存储最小节点*/
struct student *p; /*当前比较的节点*/
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。*/
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;
}
/*
==========================
功能：直接插入排序(由小到大)
返回：指向链表表头的指针
==========================
*/
/*
直接插入排序的基本思想就是假设链表的前面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罢了。
这一点请读者务必搞清楚，要不然就可能认为它和上面的选择排序法一样了。
*/
struct student *InsertSort(struct student *head)
{
struct student *first; /*为原链表剩下用于直接插入排序的节点头指针*/
struct student *t; /*临时指针变量：插入节点*/
struct student *p; /*临时指针变量*/
struct student *q; /*临时指针变量*/
first = head-next; /*原链表剩下用于直接插入排序的节点链表：可根据图12来理解。*/
head-next = NULL; /*只含有一个节点的链表的有序链表：可根据图11来理解。*/
while (first != NULL) /*遍历剩下无序的链表*/
{
/*注意：这里for语句就是体现直接插入排序思想的地方*/
for (t=first, q=head; ((q!=NULL) (q-num t-num)); p=q, q=q-next); /*无序节点在有序链表中找插入的位置*/
/*退出for循环，就是找到了插入的位置*/
/*注意：按道理来说，这句话可以放到下面注释了的那个位置也应该对的，但是就是不能。原因：你若理解了上面的第3条，就知道了。*/
first = first-next; /*无序链表中的节点离开，以便它插入到有序链表中。*/
if (q == head) /*插在第一个节点之前*/
{
head = t;
}
else /*p是q的前驱*/
{
p-next = t;
}
t-next = q; /*完成插入动作*/
/*first = first-next;*/
}
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、下面的程序描述改进了一点就是记录了每次最后一次节点下沉的位置，这样我们不必每次都从头到尾的扫描，只需要扫描到记录点为止。
因为后面的都已经是排好序的了。
*/
struct student *BubbleSort(struct student *head)
{
struct student *endpt; /*控制循环比较*/
struct student *p; /*临时指针变量*/
struct student *p1;
struct student *p2;
p1 = (struct student *)malloc(LEN);
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-num p1-next-next-num) /*如果前面的节点键值比后面节点的键值大，则交换*/
{
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指向排序后的第一个节点*/
free(p1); /*释放p1*/
p1 = NULL; /*p1置为NULL，保证不产生“野指针”，即地址不确定的指针变量*/
return head;
}
/*
==========================
功能：插入有序链表的某个节点的后面(从小到大)
返回：指向链表表头的指针
==========================
*/
/*
有序链表插入节点示意图：
----[NULL]（空有序链表）
head
图18：空有序链表（空有序链表好解决，直接让head指向它就是了。）
以下讨论不为空的有序链表。
----[1]----[2]----[3]...----[n]----[NULL]（有序链表）
head 1-next 2-next 3-next n-next
图18：有N个节点的有序链表
插入node节点的位置有两种情况：一是第一个节点前，二是其它节点前或后。
----[node]----[1]----[2]----[3]...----[n]----[NULL]
head node-next 1-next 2-next 3-next n-next
图19：node节点插在第一个节点前
----[1]----[2]----[3]...----[node]...----[n]----[NULL]
head 1-next 2-next 3-next node-next n-next
图20：node节点插在其它节点后
*/
struct student *SortInsert(struct student *head, struct student *node)
{
struct student *p; /*p保存当前需要检查的节点的地址*/
struct student *t; /*临时指针变量*/
if (head == NULL) /*处理空的有序链表*/
{
head = node;
node-next = NULL;
n += 1; /*插入完毕，节点总数加1*/
return head;
}
p = head; /*有序链表不为空*/
while (p-num node-num p != NULL) /*p指向的节点的学号比插入节点的学号小，并且它不等于NULL*/
{
t = p; /*保存当前节点的前驱，以便后面判断后处理*/
p = p-next; /*后移一个节点*/
}
if (p == head) /*刚好插入第一个节点之前*/
{
node-next = p;
head = node;
}
else /*插入其它节点之后*/
{
t-next = node; /*把node节点加进去*/
node-next = p;
}
n += 1; /*插入完毕，节点总数加1*/
return head;
}
/*
测试代码如下：
*/
/*测试SelectSort():请编译时去掉注释块*/
/*
head = SelectSort(head);
Print(head);
*/
/*测试InsertSort():请编译时去掉注释块*/
/*
head = InsertSort(head);
Print(head);
*/
/*测试BubbleSort():请编译时去掉注释块*/
/*
head = BubbleSort(head);
Print(head);
*/
/*测试SortInsert():上面创建链表，输入节点时请注意学号num从小到大的顺序。请编译时去掉注释块*/
/*
stu = (struct student *)malloc(LEN);
printf("\nPlease input insert node -- num,score: ");
scanf("%ld,%f",stu-num,stu-score);
head = SortInsert(head,stu);
free(stu);
stu = NULL;
Print(head);
*/
golang 实现选择排序算法
选择排序提高了冒泡排序的性能，它每遍历一次列表只交换一次数据，即进行一次遍历时找 到最大的项，完成遍历后，再把它换到正确的位置。和冒泡排序一样，第一次遍历后，最大的数 据项就已归位，第二次遍历使次大项归位。这个过程持续进行，一共需要 n-1 次遍历来排好 n 个数 据，因为最后一个数据必须在第 n-1 次遍历之后才能归位。
golang 冒泡排序
冒泡排序要对一个列表多次重复遍历。它要比较相邻的两项，并且交换顺序排错的项。每对 列表实行一次遍历，就有一个最大项排在了正确的位置。大体上讲，列表的每一个数据项都会在 其相应的位置 “冒泡”。如果列表有 n 项，第一次遍历就要比较 n-1 对数据。需要注意，一旦列 表中最大(按照规定的原则定义大小)的数据是所比较的数据对中的一个，它就会沿着列表一直 后移，直到这次遍历结束
双向循环链表怎么实现排序冒泡排序
#include stdio.h
#include string.h
typedef struct Node
{
int num;
struct Node *pre;
struct Node *next;
}My_Node;
// head为双向链表表头
// dir为排序方向：0为升序，1为降序
void sort_list(My_Node *head, int dir)
{
if(head == NULL) return ;
My_Node *now_item = head;
My_Node *next_item = NULL;
int tmp = 0;
while(now_item-next != NULL)
{
next_item = now_item-next;
while(next_item != NULL next_item-pre != head (next_item-pre-num next_item-num) ^ dir)
{
tmp = next_item-num;
next_item-num = next_item-pre-num;
next_item-pre-num = tmp;
next_item = next_item-pre;
}
now_item = now_item-next;
}
}
//打印排序后结果
void print_list(My_Node *head)
{
My_Node *p = head-next;
while(p != NULL)
{
printf("%d ", p-num);
p = p-next;
}
printf("\n");
}
//测试数据
void test()
{
int list[10] = {4, 2, 5, 6, 1, 9, 7, 3, 8, 0};
int i;
My_Node *head = (My_Node *)malloc(sizeof(My_Node));
My_Node *p = NULL;
head-pre = head-next = NULL;
for(i=0; i10; i++)
{
p = (My_Node *)malloc(sizeof(My_Node));
p-num = list[i];
p-next = head-next;
if(head-next != NULL) head-next-pre = p;
head-next = p;
p-pre = head;
}
printf("原序列: ");
print_list(head);
sort_list(head, 0);
printf("升序排序: ");
print_list(head);
sort_list(head, 1);
printf("降续排序: ");
print_list(head);
}
int main()
{
test();
return 0;
}
//贴上来格式都没了。。
C++单向链表 冒泡排序
templateclass T
class ChainNode{
friend ChainT;
template class T friend ostream operator(ostream os, const ChainT c);
private:
T data;
ChainNodeT* link;
};
templateclass T
class Chain{
friend ChainIteratorT;
private:
ChainNodeT* first;
bool Bubble(ChainNodeT* current); // 递归函数，从链表的最后一对数开始冒泡至current
pubilc:
void InsertionSort(); //插入算法对链表进行升序排序，不得创建新结点和删除老结点
void BubbleSort(); // 冒泡排序
void SelectionSort(); // 选择排序
void RankSort(); // 计数排序
};
template class T
void ChainT::InsertionSort() //插入算法对链表进行升序排序，不创建新结点和删除老结点
{
if (first)
for (ChainNodeT* current = first; current-link;){ // current-link为当前要插入的数据
for (ChainNodeT* p = first; p-data current-link-data; p = p-link); // p指向表中第一个大于或等于当前要插入数据的数据
if (p == current-link){ // 表中没有比current-link大的数据
current = current-link;
continue; // 继续下一个数据插入
}
if (p!= current){ // 将要插入的数据挪到第一个比它大的数后面
ChainNodeT* n = current-link-link;
current-link-link = p-link;
p-link = current-link;
current-link = n;
}
else
current = current-link; // 如果已经在第一个比他大的数后面了，更新current-link
T x = p-link-data; //交换要插入元素和他前面那个比它大的元素
p-link-data = p-data;
p-data = x;
}
}
// 问题1：插入排序对于已排好序的链表仍需检验n(n - 1)次，能否及时终止插入排序？
template class T
bool ChainT::Bubble(ChainNodeT* current) // 递归函数，从链表的最后一对数开始冒泡至current
{
bool sorted = true; // 如果链表已排好序（未发生交换），返回true
if (current current-link current-link-link)
sorted = Bubble(current-link);
if (current-data current-link-data){
T temp = current-data;
current-data = current-link-data;
current-link-data = temp;
sorted = false;
}
return sorted;
}
template class T
void ChainT::BubbleSort() // 冒泡排序
{
bool sorted = false;
for (ChainNodeT* start = first; start start-link !sorted; start = start-link)
sorted = Bubble(start);
}
问题2：不使用递归函数能否以同样的检索次数排序？
template class T
void ChainT::SelectionSort() // 选择排序
{
bool sorted = false;
for (ChainNodeT* start = first; start start-link !sorted; start = start-link){
sorted = true;
for (ChainNodeT* current = start-link; current; current = current-link){
if (current-data start-data){ // 交换
T temp = current-data;
current-data = start-data;
start-data = temp;
}
if (sorted current-link current-data current-link-data) // 如果在链表中存在比后一项大的项，则表示未排序
sorted = false;
}
}
}
【golang】冒泡排序和选择排序
运行结果：
flag的作用：排序不一定会走完所有循环，有可能在中间就完成了排序。只要发现在某一轮的循环中，没有发生任何交换，就说明每一组都是前面的数比下一个数小，如此就不用再往下进行，终止循环。
运行结果：
