链表选择排序算法

A. 以单链表为存储结构，编写简单选择排序算法（需预先创建符合要求的单链表）

选择排序：从头至尾扫描序列，找出最小的一个元素，和第一个元素交换，接着从剩下的元素中继续这种选择和交换方式，最终得到一个有序序列。

出这题的人是个坑货，链表交换很麻烦。
每次遍历找最小值时候 还要用一个指针定位到它前面一个， 才好交换。

B. 如何用交换链表节点的方式对链表进行选择法排序

//链表的选择排序，以key为关键字进行排序
//交换整个节点（ data key..so on）
#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
int key;
int data;
//so..on
struct node*pro;
struct node*next;
}*linklist;
typedef struct node mylist;
//Create 函数创建链表并且给数据域赋值
// data 用首项为2 的公差为5的数组赋值
//key 为用户输入的数值 当输入-1时代表输入完毕
//输入时会看不到data的值
linklist Create()
{
linklist head,temp;
linklist p;
int num;
int num2=2,step=5;
head=(linklist)malloc(sizeof(mylist));
head->key=-1;
temp=head;
head->pro=NULL;
scanf("%d",&num);
while(num!=-1)
{
p=(linklist)malloc(sizeof(mylist));
/*temp->next=p;
p->pro=temp;*/
p->key=num;
p->data=num2;
temp->next=p;
p->pro=temp;
temp=p;
scanf("%d",&num);
num2+=step;
}
p->next=NULL;
return head;

}
int listlength(linklist head)
{
linklist p=head->next;
int n=0;
while(p!=NULL)
{
n++;
p=p->next;
}
return n;

}
void show(linklist head)
{
linklist p=head->next;
while(p)
{
printf("(%d,%d) ",p->data,p->key);
p=p->next;
}
printf("\n");

}
linklist findmax(linklist head)
{
linklist imax=NULL;
linklist p=head->next;
linklist prenode=head;
imax=p;
while(p)
{

if(p->key>=imax->key)
{
prenode=p->pro;
imax=p;
}
p=p->next;
}
/*假删除并没有free
只是让key最大的节点在这个表中消失，
并返回在另一个表中出现*/
prenode->next=imax->next;
if(imax->next)
imax->next->pro=prenode;

return imax;
}
linklist sort(linklist head)
{
linklist head2,newmax;
int length=listlength(head);
printf("length=%d\n",length);
head2=(linklist)malloc(sizeof(mylist));
head2->next=NULL;
head2->pro=NULL;
for(int i=0;i<length;i++)
{
newmax=findmax(head);
if(newmax!=NULL)
{
newmax->next=head2->next;
if(head2->next)
{
head2->next->pro=newmax;

}
newmax->pro=head2;
head2->next=newmax;
}
}
free(head);
return head2;

}
void main()
{
linklist p,p1;
p=Create();
show(p);

p1=sort(p);
show(p1);

}

C. 链表选择排序的C语言算法实现

common.h
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
linklist.h
#include common.h
typedef int ElemType;
typedef struct Node /*结点类型定义*/
{
ElemType data;
struct Node * next;
}Node, *LinkList; /* LinkList为结构指针类型*/
void CreateFromTail(LinkList L)
{
Node *r, *s;
char c;
int flag =1; /*设置一个标志，初值为1，当输入$时，flag为0，建表结束*/
r=L; /*r指针动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/
while(flag) /*循环输入表中元素值，将建立新结点s插入表尾*/
{
c=getchar();
if(c!='$')
{
s=(Node*)malloc(sizeof(Node));
s->data=c;
r->next=s;
r=s;
}
else
{
flag=0;
r->next=NULL; /*将最后一个结点的next链域置为空，表示链表的结束*/
}
}
} 尾插法创建链表程序
/*_*====尾插法创建链表，返回链表头指针====*_*/
LinkList CreateFromTail2()
{
LinkList L;
Node *r, *s;
int c;
int flag =1;
L=(Node * )malloc(sizeof(Node));
L->next=NULL;
r=L;
while(flag)
{
scanf(%d,&c);
if(c!=-1)
{
s=(Node*)malloc(sizeof(Node));
s->data=c;
r->next=s;
r=s;
}
else
{
flag=0;
r->next=NULL;
}
}
return L;
} void linkSort(LinkList l)
{
Node *p,*q,*m,*n;
Node *temp1,*temp2;
if(l->next==NULL)
printf(NO LINKLIST!!!);
else
{
p=l;q=l->next;
while(q->next!=NULL)
{
m=p->next;
n=q->next;
temp1=m;
while(temp1->next!=NULL)
{
if(temp1->next->data<q->data && temp1->next->data<n->data)
{
m=temp1;n=temp1->next;
}
temp1=temp1->next;
}/*_*====此循环用于找到基准(q)以后的序列的最小的节点=====*_*/
if(m!=p->next || (m==p->next && m->data>n->data))
{
p->next=n;
p=n;
m->next=q;
m=q;
q=q->next;
n=n->next;
p->next=q;
m->next=n;
}/*_*======此条件用于交换两个节点*_*/
else
{
p=p->next;
q=q->next;
}/*_*======此条件用于没有找到最小值时的p，q后移操作*_*/
}/*_*=====外循环用于从前往后扫描，通过移动p,q指针实现=======*_*/
temp2=l->next;
printf(List after sorting is: );
while(temp2!=NULL)
{
printf(%5d,temp2->data);
temp2=temp2->next;
}
}
printf( );
} void main()
{
Node *temp3;
LinkList l;
printf( =====(end by -1)====== press enter after input the nember each time: );
l=CreateFromTail2();
temp3=l->next;
if(temp3==NULL)
printf(NO LINKLIST!!!);
else
{
printf(List before sorting is: );
while(temp3!=NULL)
{
printf(%5d,temp3->data);
temp3=temp3->next;
}
}
printf( );
linkSort(l);
}

D. 设计一个用链表表示的直接选择排序算法，并用程序实现

#include<stdio.h>
#include<malloc.h>
#include<conio.h>
typedef struct VNode
{
int info;
struct VNode *next_node;
}Node;
void input(Node*head, int number)
{
if(number!=0)
{
int i;
Node *t;
t=(Node *)malloc(sizeof(Node));
head->next_node=t;
scanf("%d",&i);
t->info=i;
input(t,number-1);
}
}
void output(Node*head, int count)
{
Node *t;
if(count!=0)
{
t=head->next_node;
printf("%d ",t->info);
output(t,count-1);
}
}
void select(Node*head, int num)
{
int tem=0;
if(num!=0)
{
int min_node;
Node *t;
Node *r;
Node *q;
t=head->next_node;
r= head->next_node;
q=head;
min_node= t->info;
for(int i=0;i<num;i++)
{
if(min_node>t->info)
{
min_node= t->info;
r=t;
tem=i;
}
t=t->next_node;
}
for(int j=0;j<tem;j++)
q=q->next_node;
q->next_node=r->next_node;
r->next_node=head->next_node;
head->next_node=r;
select(head->next_node,num-1);
}
}
int main()
{
int num;
Node *head;
head=( Node *)malloc(sizeof(Node));
printf("请输入序列数据的个数：");
scanf("%d",&num);
printf("请输入序列的数据：\n");
input(head,num);
printf("\n选择排序后的序列为：\n");
select(head,num);
output(head,num);
getch();}

E. 以单链表为存储结构实现简单选择排序的算法

单向链表的相关操作
实现功能：
1. 创建一个新链表。

2. 插入节点。

3. 删除节点。
4. 插入法排序链表（从小到大）。

5. 选择法排序链表（从小到大）。

6. 显示当前链表。

0. 退出程序。

代码见参考资料

F. 对已经建好的单链表排序 （求算法）要准确

void SelectSort_LinkList(LinkList H)//选择排序，带头结点的单链表
{
int temp;
LNode*p=H->next,*q,*s;

if(p==NULL)
{
printf("空表\n");
return;
}
while(p->next!=NULL)
{
q=p;
s=p->next;
while(s!=NULL)
{
if(q->data>s->data)
q=s;
s=s->next;
}
if(q!=p)
{
temp=q->data;
q->data=p->data;
p->data=temp;
}
p=p->next;
}
}

G. 链表的选择排序

C语言

经典算法－－单链表选择排序第一种：
#include<stdio.h>
#include<stdlib.h>
typedef struct node{
int data;
struct node *next;
}*Linklist,Node;
Linklist creat(int n)
{Linklist head,r,p;
int x,i;
head=(Node*)malloc(sizeof(Node));
r=head;
printf("输入数字:\n");
for(i=n;i>0;i--)
{scanf("%d",&x);
p=(Node*)malloc(sizeof(Node));
p->data=x;
r->next=p;
r=p;}
r->next=NULL;
return head;
} void output(Linklist head)
{Linklist p;
p=head->next;
do{
printf("%3d",p->data);p=p->next;
}while(p);
printf("\n");
} void paixu(Linklist head)
{Linklist p,q,small;int temp;

for(p=head->next;p->next!=NULL;p=p->next)
{small=p;
for(q=p->next;q;q=q->next)
if(q->data<small->data)
small=q;
if(small!=p)
{temp=p->data;
p->data=small->data;
small->data=temp;}
} printf("输出排序后的数字:\n");
output(head);
} void main()
{Linklist head;
int x,j,n;
printf("输入数字的个数(n):\n");
scanf("%d",&n);
head=creat(n);
printf("输出数字:\n");
output(head);
printf("已排序的数字:\n");
paixu(head);
}
第二种：
#include<stdio.h>
#include<stdlib.h>
typedef struct node{
int data;
struct node *next;
}*Linklist,Node;
Linklist creat(int n)
{Linklist head,r,p;
int x,i;
head=(Node*)malloc(sizeof(Node));
r=head;
printf("输入数字:\n");
for(i=n;i>0;i--)
{scanf("%d",&x);
p=(Node*)malloc(sizeof(Node));
p->data=x;
r->next=p;
r=p;}
r->next=NULL;
return head;
} Linklist selectsort(Node *g)
{ Node *p,*q,*t,*s,*h;
h=(Node *)malloc(sizeof(Node));
h->next=g;
p=h;
while(p->next->next!=NULL)
{
for(s=p,q=p->next;q->next!=NULL;q=q->next)
if(q->next->data<s->next->data)
s=q;
if(s!=q)
{
t=s->next;
s->next=t->next;
t->next=p->next;
p->next=t;
}
p=p->next;
}
g=h->next;
free(h);
return g;
} void output(Linklist head)
{Linklist p;
p=head->next;
do{
printf("%3d",p->data);p=p->next;
}while(p);
printf("\n");
} void main()
{Linklist head;
int x,j,n;
printf("输入数字的个数(n):\n");
scanf("%d",&n);
head=creat(n);
printf("输出数字:\n");
output(head);
head=selectsort(head);
printf("已经排序的数字:\n");
output(head);
}

H. C语言做链表的排序

＃include＂stdafx．h＂
＃include＜stdlib．h＞
／／创建一个节点，data为value，指向NULL
Node＊Create（intvalue）｛
Node＊head＝（Node＊）malloc（sizeof（Node））；
head－＞data＝value；
head－＞next＝NULL；
returnhead；
｝
／／销毁链表
boolDestroy＿List（Node＊head）｛
Node＊temp；
while（head）｛
temp＝head－＞next；
free（head）；
head＝temp；
｝
head＝NULL；
returntrue；
｝
／／表后添加一个节点，Create（value）
boolAppend（Node＊head，intvalue）｛
Node＊n＝Create（value）；
Node＊temp＝head；
while（temp－＞next）｛
temp＝temp－＞next；
｝
temp－＞next＝n；
return0；
｝
／／打印链表
voidPrint＿List（Node＊head）｛
Node＊temp＝head－＞next；
while（temp）｛
printf（＂％d－＞＂，temp－＞data）；
temp＝temp－＞next；
｝
printf（＂＼n＂）；
｝
／／在链表的第locate个节点后（头节点为0）插入创建的节点Create（value）
boolInsert＿List（Node＊head，intlocate，intvalue）｛
Node＊temp＝head；
Node＊p；
Node＊n＝Create（value）；
if（locate＜0）
returnfalse；
while（locate－－）｛
if（temp－＞next＝＝NULL）｛
temp－＞next＝Create（value）；
returntrue；
｝
temp＝temp－＞next；
｝
p＝temp－＞next；
temp－＞next＝n；
n－＞next＝p；
returntrue；
｝
／／删除第locate个节点后（头节点为0）的节点
boolDelete＿List（Node＊head，intlocate）｛
Node＊temp＝head；
Node＊p；
if（locate＜0）
returnfalse；
while（locate－－）｛
if（temp＝＝NULL）｛
returnfalse；
｝
temp＝temp－＞next；
｝
p＝temp－＞next－＞next；
free（temp－＞next）；
temp－＞next＝NULL；
temp－＞next＝p；
returntrue；
｝
／／获取链表长度（不包括头节点）
intSize＿List（Node＊head）｛
Node＊temp＝head；
intsize＝0；
while（temp－＞next）｛
temp＝temp－＞next；
size＋＋；
｝
returnsize；
｝
／／链表的三种排序（选择，插入，冒泡）
boolSort＿List（Node＊head）｛
intt＝0；
intsize＝Size＿List（head）；
／／选择排序
／＊for（Node＊temp＝head－＞next；temp！＝NULL；temp＝temp－＞next）｛
for（Node＊p＝temp；p！＝NULL；p＝p－＞next）｛
if（temp－＞data＞p－＞data）｛
printf（＂换％d和％d＼n＂，temp－＞data，p－＞data）；
t＝temp－＞data；
temp－＞data＝p－＞data；
p－＞data＝t；
｝
｝
｝＊／
／／插入排序
／＊for（Node＊temp＝head－＞next－＞next；temp！＝NULL；temp＝temp－＞next）｛
for（Node＊p＝head；p－＞next！＝NULL；p＝p－＞next）｛
if（p－＞next－＞data＞temp－＞data）
｛
printf（＂换％d和％d＼n＂，temp－＞data，p－＞next－＞data）；
t＝temp－＞data；
temp－＞data＝p－＞next－＞data；
p－＞next－＞data＝t；
｝
｝
｝＊／
／／冒泡排序
for（Node＊temp＝head－＞next；temp－＞next！＝NULL；temp＝temp－＞next）｛
for（Node＊p＝head－＞next；p－＞next！＝NULL；p＝p－＞next）｛
if（p－＞data＞p－＞next－＞data）｛
t＝p－＞data；
p－＞data＝p－＞next－＞data；
p－＞next－＞data＝t；
｝
｝
｝
return0；
｝
(8)链表选择排序算法扩展阅读：
return表示把程序流程从被调函数转向主调函数并把表达式的值带回主调函数，实现函数值的返回，返回时可附带一个返回值，由return后面的参数指定。
return通常是必要的，因为函数调用的时候计算结果通常是通过返回值带出的。如果函数执行不需要返回计算结果，也经常需要返回一个状态码来表示函数执行的顺利与否（-1和0就是最常用的状态码），主调函数可以通过返回值判断被调函数的执行情况。

I. 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,然后它变成其尾指针；
*/
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