目录
一、简单选择排序
算法思想：每一趟找出一个最大值结点连接到新链表L中
指针作用：
*p:工作指针
*pre:始终指向工作指针的前驱，保证不断链
*max:指向最大值
*maxpre:指向最大值的前驱，保证不断链
*h全局指针，决定循环的总趟数
//简单选择排序链表形式实现
//算法思想：每一趟找出一个最大值结点连接到新链表L中
/*指针作用：
*p:工作指针
*pre:始终指向工作指针的前驱，保证不断链
*max:指向最大值
*maxpre:指向最大值的前驱，保证不断链
*h全局指针，决定循环的总趟数
*/
//链表的结构体定义
typedef struct LNode{
int data;
struct LNode* next;
}LNode,* LinkList;
//链表的选择排序实现（逆序）排序
void Link_Select_Sort(LinkList &L){
LNode* h=L;* p,* pre,*max,*maxpre;
L=NULL;//将L断开，之后L用作新的链表头指针
while(h!=NULL){//外层循环，即选择排序的总趟数
h=p=max;
maxpre=pre=NULL;//每趟排序结束都要把指针变为初始状态
while(p!=NULL){//每一趟排序的循环
//若指针p指向结点的值大于指针pre指向结点的值，则把max指针指向p，maxpre指向pre
if(p->data>pre->data){
max=p;
maxpre=pre;
}
pre=p;
p=p->next;
}
if(max==h){//如果该趟排序的最大值为第一个结点，只需要把指针h后移
h=h->next;
}
else{//最大结点为表中结点
maxpre->next=max->next;
}
max->next=L;//最后把最大值结点指向L
L=max;//使L指向链头
}
}
//数组实现
void swap(int x,int y){
int temp=x;
x=y;
y=temp;
}
void SelectSort(int A[],int n){
int i,j,min;
for(i=0;i<n-1;i++){//一共进行n-1趟排序
min=i;
for(j=i+1;j<n;j++){
if(A[j]<A[min])
min=j;
}
if(min!=i)
swap(A[min],A[i]);
}
}
二、冒泡排序
算法思想：每一趟排序把最大元素排到当前链尾
指针准备：
*p:工作指针
*q:指针p的后继，保证不断链
*tail:尾指针。原因：冒泡排序每一趟都会有一个最大元素放在表尾排序完成，而下一趟就不需要在比较最后一个元素了。tail每一趟都要变化
需要注意的点：
1.冒泡排序只剩下两个元素的时候一定有序。
2.冒泡排序每一趟都会有一个最大元素放在表尾排序完成，而下一趟就不需要在比较最后一个元素了，需要用尾指针tail实现。
3.结点的交换可以换值，也可以换结点。
//冒泡排序
//算法思想：每一趟排序把最大元素排到当前链尾
/*指针准备
*p:工作指针
*q:指针p的后继，保证不断链
*tail:尾指针。原因：冒泡排序每一趟都会有一个最大元素放在表尾排序完成，而下一趟就不需要在比较最后一个元素了。tail每一趟都要变化
*/
/*需要注意的点：
1.冒泡排序只剩下两个元素的时候一定有序。
2.冒泡排序每一趟都会有一个最大元素放在表尾排序完成，而下一趟就不需要在比较最后一个元素了，需要用尾指针tail实现。
3.结点的交换可以换值，也可以换结点。
*/
//一、（带头结点+交换结点的方式实现）
//结构体定义
typedef struct LNode{
int data;
struct LNode* next;
}LNode,*LinkList;
//初始化一个单链表（带头结点）
bool InitList(LinkList& L) {
L = (LNode*)malloc(sizeof(LNode));
if (L == NULL) //内存不足，分配失败
return false;
L->next = NULL; //头结点之后暂时还没有结点
return true;
}
void Link_Bubble_Sort(LinkList& L){
LNode *p,*q,*tail=NULL;
while(p->next->next!=NULL){
p=L;
q=p->next;
while(q->next!=NULL){
if(q->data<p->data){
//交换结点的方式
p->next=q->next;
q->next=q->next->next;
p->next=q;
q=p->next;//这一步很重要，因为交换结点后q会相当于后移了一位，这是p不再是q的前驱，所以需要把q重新调整为p的前驱。
}
p=q;
q=q->next;
}
tail=p;//指向未有序序列的最后一个元素
}
}
//二、（不带头结点+交换值的方式实现）
//结构体定义
typedef struct LNode{
int data;
struct LNode* next;
}LNode,*LinkList;
//初始化一个不带头结点的单链表
void InitList(LinkList& L) {
L=NULL;
}
//结点交换函数
void swap(LNode* p,LNode *q){
int temp=p->data;
p->data=q->data;
q->data=temp;
}
bool Link_Bubble_Sort(LinkList &L){
LNode* pre,* p,* tail;
if(!L)
return false;
int flag=false;//标记，为true即本趟排序发生了交换。
tail=NULL;
//当尾结点与头结点指向同一个结点是，说明只有一个元素待排序，冒泡结束
while(L!=tail){
pre=L;
//每次参与比较的都是尾结点tail前面的点
while(pre->next!=tail){
p=pre->next;
if(pre->data>p->data){
swap(pre,p);
flag=true;//本趟排序发生了交换
}
pre=pre->next;
}
if(flag==false)//如果本趟循环未发生元素交换，则冒泡排序完成，跳出外层循环
break;
tail=pre;
}
return true;
}
//数组实现
void swap(int x,int y){
int temp=x;
x=y;
y=temp;
}
void BubbleSort(int A[],int n){
int i,j;
for(i=0;i<n;i++){
int flag=false;
for(j=n-1;j>=i;j--){
if(A[j-1]>A[j]){
swap(A[j-1],A[j]);
flag=true;
}
}
if(flag==false)
return ;
}
}
三、插入排序
算法思想:，每一趟寻找一个最小值插入到链表表头位置
指针说明（没有三个指针解决不了的问题，如果有那就再加！）
*p:工作指针
*pre:p指针的前驱
*q:p指针的后继
//插入排序
//算法思想:，每一趟寻找一个最小值插入到链表表头位置
/*指针说明（没有三个指针解决不了的问题，如果有那就再加！）
*p:工作指针
*pre:p指针的前驱
*q:p指针的后继
*/
//结构体定义
typedef struct LNode{
int data;
struct LNode* next;
}LNode,* LinkList;
//(带头结点)
void Link_Insert_Sort(LinkList &L){
LNode *p,*q,*pre;
p=L->next->next;
L->next->next=NULL;//进行断链（核心）
while(p!=NULL){
q=p->next;
pre=L;
while(pre->next!=NULL&&pre->next->data<p->data)
pre=pre->next;
p->next=pre->next;
pre->next=p;
p=q;
}
}
//数组实现
void InsertSort(int A[],int n){
int i,j;
for(i=2;i<n;i++){//依次将A[2]-A[n]插入前面已排好序的序列
if(A[i]<A[i-1]){
A[0]=A[i];//哨兵
for(j=i-1;A[0]<A[j];--j)//与前面的所有元素一次比较找到待插位置
A[j+1]=A[j];//向后移位
A[j+1]=A[0];//复制到插入位置
}
}
}四、快速排序
算法思想：选一个基准，将小于基准的移动到左边，大于基准的移动到右端，然后左右两部分递归。
指针准备：
*p:q的前驱指针，保证不断链
*q:工作指针
//快速排序
//算法思想：选一个基准，将小于基准的移动到左边，大于基准的移动到右端，然后左右两部分递归。
/*
*p:q的前驱指针，保证不断链
*q:工作指针
*/
//结构体定义
typedef struct LNode{
int data;
struct LNode* next;
}LNode,* LinkList;
void swap(LNode *p,LNode *q){
int temp=p->data;
p->data=q->data;
q->data=temp;
}
//（带头结点）一趟快排
LNode* Partition(LNode *head,LNode *tail){
//链表为空或只有一个元素就返回head
if(!head||head->next=tail)
return head;
int pivot=head->data;//哨兵
LNode *p=head;//记录哨兵的位置
LNode *q=p->next;//用于遍历待排序链表的指针
while(q!=tail){
//发现比哨兵结点小的值就交换，保证p指针所指结点比哨兵小
if(q->data<pivot){
p=p->next;
swap(p,q);
}
q=q->next;
}
//交换哨兵和p指针的值，至此哨兵的位置就固定了
swap(head,p);
return p;
}
//快速排序
void Link_Quick_Sort(LNode *head,LNode *tail){
if(head!=tail){
LNode* pivotpos=Partition(head,tail);
Link_Quick_Sort(head,pivotpos);
Link_Quick_Sort(pivotpos->next,tail);
}
}
//数组实现
int Partition(int A[],int low,int high){
int pivot=A[0];//基准元素
while(low<high){
while(low<high&&A[high]>pivot)
--high;
while(low<high&&A[low]<pivot)
++low;
}
A[low]=pivot;//或者A[high+1]=pivot;枢轴元素存放在最终位置
return low;//返回枢轴元素最终位置
}
void QuickSort(int A[],int low,int high){
int pivotpos=Partition(A,low,high);
QuickSort(A,low,pivotpos-1);
QuickSort(A,pivotpos+1,high);
}
239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
