C语言的链表怎么排序

Posted 2023-04-29

==========================
功能：选择排序(由小到大)
返回：指向链表表头的指针
==========================
*/

/*
选择排序的基本思想就是反复从还未排好序的那些节点中，
选出键值（就是用它排序的字段，我们取学号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);
*/

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/northplayboy/archive/2005/12/14/552388.aspx 参考技术A 其实最简单的方法就是，重新建一个链表存储有序序列，把原链表里的元素一个一个地取出来，放到新链表里。放进去的时候二分一下当前序列（可能要比二分数组慢一点，因为要一个一个地往前或者往后找，没有直接按下标找方便），找到当前元素在序列里正确的位置。这种方法的时间复杂度大概在O(n*log2n)左右
基本流程：
初始状态：
原链表：1--->2--->4--->3--->NULL
新链表：NULL
第一次处理：
原链表：2--->4--->3--->NULL
新链表：1--->NULL
第二次处理：
原链表：4--->3--->NULL
新链表：1--->2--->NULL
第三次处理：
原链表：3--->NULL
新链表：1--->2--->4--->NULL
第四次处理：
原链表：NULL
新链表：1--->2--->3--->4--->NULL

或者建一个二叉树，类似于bst的结构（左子<根<右子），再中序遍历一下。

或者不用那些基于比较的排序，用基数排序一类的方法，可以在O(n)的时间内解决问题C+_+C 参考技术B 可以把链表设计成循环链表，用冒泡排序
在排序前设计一个交换标记，如在循环过程中有交换，则修改这个标记变量，如果在一次循环（当前节点为刚开始时节点，表示循环了一次）中，交换标记没有被修改，则表明该数列已排好序。
现在给一个双向循环链表的排序程序给你，该程序用了双向冒泡排序（也就是鸡尾酒排序法），希望对你有帮助
双向链表我用的鸡尾酒排序,也就是双向冒泡排序
#include
#define
LEN
sizeof(struct
list)
struct
list
//双向链表有两个指针域，一个指向前节点，一个指向后继节点
struct
list
*lp;
//lp为前节点指针，rp为后继节点指针
int
x;
struct
list
*rp;
;
int
n;
struct
list
*creat(void)
struct
list
*head;
struct
list
*p1,*p2;
//两个节点指针，p1是当前新建节点指针，p2为p1的前一个节点
n=0;
p1=p2=(struct
list*)malloc(LEN);
//申请内存空间
scanf("%d",&p1->x);
head=NULL;
//先把头指针设置为空
while(p1->x!=0)
n=n+1;
if(n==1)p1->lp=NULL;
head=p1;
//把head指向链表的第一个节点并把首节点的lp设为NULL
else
p1->lp=p2;
新建了一个节点，把它的lp指向前一个节点p2
p2->rp=p1;
把前节点的rp指针指向刚建立的节点
p2=p1;
进行迭代，p1变成下一个新节点的后继节点
p1=(struct
list*)malloc(LEN);
//每次新建节点都要向系统申请内存空间
scanf("%d",&p1->x);

p2->rp=NULL;
把随后的节点后继指针设为空
return(head);

void
print(struct
list
*head)
struct
list
*p;
printf("\nNow,Thess
%d
records
are
:\n",n);
p=head;
if(head!=NULL)
do
printf("%d
",p->x);
p=p->rp;
//这个是个迭代过程，把p的后继节点变成下一次要输出的节点
while(p!=NULL);

void
sort(struct
list
*head)
//排序用的双向排序法，提高排序效率
struct
list
*p,*bottom,*top;
int
f,temp;
p=head;
if(head!=NULL)

f=1;
bottom=NULL;
//bottom和top为数列左右冒泡的边界节点
top=NULL;
while(f==1)
//f为交换标记，如果没交换则f没变就推出循环
f=0;
do

if(p->x
>
(p->rp)->x)
temp=p->x;
p->x=(p->rp)->x;
(p->rp)->x=temp;
f=1;

p=p->rp;
while(p->rp!=top);
print(head);
top=p;
if((f==0)||(top==bottom))break;
f=0;
do

if(p->x<(p->lp)->x)

temp=p->x;
p->x=(p->lp)->x;
(p->lp)->x=temp;
f=1;

p=p->lp;
while(p->lp!=bottom);
bottom=p;
if(top==bottom)break;
print(head);



void
main()
//所有的函数都做成全局函数，可以随时调用
struct
list
*head;
head=creat();
//建立链表
print(head);
//输出链表
sort(head);
//排序
print(head);
//输出链表
system("PAUSE");
参考技术C /*
==========================
功能：直接插入排序(由小到大)
返回：指向链表表
头的指针
==========================
*/
/*
直接插入排序的基本思想就是假设链表的前面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;

c_cpp 排序已经按绝对值排序的链表 - GeeksforGeeks

/*
http://www.practice.geeksforgeeks.org/problem-page.php?pid=700234
http://www.geeksforgeeks.org/sort-linked-list-already-sorted-absolute-values/
*/
/* The structure of the Linked list Node is as follows:
struct Node
{
    Node* next;
    int data;
}; */

void sortList(Node** head)
{
    Node *prev = (*head);
    Node *current = (*head)->next;
    
    while(current != NULL){
        if(current->data < prev->data){
            prev->next = current->next;
            
            current->next = (*head);
            *head = current;
            current = prev;
        }else{
            prev = current;
        }
        current = current->next;
    }
}