数据结构各种排序汇总

#include <iostream>
#include <algorithm>
#define MAXSIZE 10000
#define OK 1
typedef int KeyType;
typedef char InfoType;
typedef int Status;
using namespace std;
typedef struct{
KeyType key;
InfoType otherinfo;
}RedType;
typedef struct{
RedType r[MAXSIZE+1];
int length;
}SqList;
Status InitList_Sq(SqList &L,int a[],int n)
{
L.length=n;
for(int i=1;i<=n;i++)
L.r[i].key=a[i];
return OK;
}
void ShowSqList(SqList L)
{
for (int i=1;i<=L.length;i++)
cout<<L.r[i].key<<" ";
cout<<endl;
}
//----------------快速排序-------------
int Partition(SqList &L ,int low,int high)
{
int pivotkey=L.r[low].key;
L.r[0]=L.r[low];
while(low<high)
{
while(low<high&&L.r[high].key>=pivotkey)
{
--high;
}
L.r[low]=L.r[high];
while(low<high&&L.r[low].key<=pivotkey)
{
++low;
}
L.r[high]=L.r[low];
}
L.r[low]=L.r[0];
for(int k=1;k<=L.length;k++)
cout<<" "<<L.r[k].key<<" ";
cout<<endl;
return low;
}
void QSort(SqList &L,int low,int high)
{
int pivotloc,j=0;
if(low<high)
{
pivotloc=Partition(L,low,high);
QSort(L,low,pivotloc-1);
QSort(L,pivotloc+1,high);
}
}
void Quicksort(SqList &L)
{
QSort(L,1,L.length);
}
//------------------堆排序-----------------
void HeapAdjust(SqList &L,int s,int m)
{
int j;
RedType rc=L.r[s];
for(j=2*s;j<=m;j*=2)
{
if(j<m&&L.r[j].key<L.r[j+1].key)
j++;
if(rc.key>=L.r[j].key)
break;
L.r[s]=L.r[j];
s=j;
}
L.r[s]=rc;
}
void CreatHeap(SqList &L)
{
for(int i=L.length/2;i>0;--i)
HeapAdjust(L,i,L.length);
}
void Heapsort(SqList &L)
{
CreatHeap(L);
for (int i=L.length;i>1;--i)
{
swap(L.r[1],L.r[i]);
HeapAdjust(L,1,i-1);
cout<<"第"<<L.length-i+1<<"趟重调整堆之后:";
for(int k=1;k<=L.length;k++)
cout<<" "<<L.r[k].key<<" ";
cout<<endl;
}
}
//---------------希尔排序------------
void ShellInsert(SqList &L,int dk)
{
int i,j;
for(i=dk+1;i<=L.length;i++)
if (L.r[i].key<L.r[i-dk].key)
{
L.r[0]=L.r[i];
for (j=i-dk;j>0&&L.r[0].key<L.r[j].key;j-=dk)
L.r[j+dk]=L.r[j];
L.r[j+dk]=L.r[0];
}
}
void Shellsort(SqList &L,int dt[],int t)
{
for(int i=0;i<t;i++){
ShellInsert(L,dt[i]);
cout<<i+1<<"趟排序结果：";
for(int k=1;k<=L.length;k++)
cout<<" "<<L.r[k].key<<" ";
cout<<endl;
}
}
//------------归并排序-----------
void Merge(RedType R[],RedType T[],int low,int mid,int high)
{
//将有序表R[low..mid]和R[mid+1..high]归并为有序表T[low..high]
int i=low,j=mid+1,k=low;
while(i<=mid&&j<=high){    //将R中记录由小到大地并入T中
if(R[i].key<=R[j].key) T[k++]=R[i++];
else T[k++]=R[j++];
}
while(i<=mid)   //将剩余的R[low..mid]复制到T中
T[k++]=R[i++];
while(j<=high)  //将剩余的R[j.high]复制到T中
T[k++]=R[j++];
}          //Merge
int x=1;
void MSort(RedType R[],RedType T[],int low,int high)
{
//R[low..high]归并排序后放入T[low..high]中
int mid;
if(low==high) T[low]=R[low];
else{
RedType *S=new RedType[high];
mid=(low+high)/2;
MSort(R,S,low,mid);
MSort(R,S,mid+1,high);
Merge(S,T,low,mid,high);
cout<<"第"<<x++<<"步骤的结果：";
for(int l=low;l<=high;l++)
cout<<" "<<T[l].key<<" ";
cout<<endl;
}
}
void MergeSort(SqList &L) {
//对顺序表L做归并排序
MSort(L.r,L.r,1,L.length);
}

//-----------------基数排序RadixSorting-------------------------
#define MAX_NUM_OF_KEY 8        //关键字项数的最大值
#define RADIX    10            //关键字基数，此时是十进制整数的基数
#define MAX_SPACE 10000
typedef int DataType ;
typedef struct
{
int data;        //数据
DataType keys[MAX_NUM_OF_KEY];        //每个数据的所有关键字
int  next;
}SLCell;    //静态链表的节点类型

typedef struct    Sllist
{
SLCell *R;     //静态链表的可利用空间，r[0]为头结点
int recnum;        //静态链表的当前长度
int keynum;        //当前数据的关键字个数
}Sllist, * SLList;    //静态链表类型

typedef int ArrType[RADIX];        //指针数组类型，声明两个指针数组，一个头指针，一个尾指针
void creatList(SLList &SLL)
{

int key, i=1,j,n,t;
cout<<"═════请输入数的个数：";
cin>>n;
cout<<"═════输入要进行排序的数据:";
for(int k=0;k<n;k++)
{
cin>>key;
t=1;
SLL->R[i].data = key;
for(j = 1;j<10; j++)
{
SLL->R[i].keys[j] = key % 10;
key /= 10;
if(key!=0) t++;
}
SLL->R[i-1].next=i++;
if(SLL->keynum<t) SLL->keynum=t;

}
SLL->recnum = i-1;
SLL->R[SLL->recnum].next=0;
}

void print(SLList &SLL)
{
for(int p=SLL->R[0].next; p; p=SLL->R[p].next)
{
cout<<SLL->R[p].data<<"  ";
}
cout<<endl;
}

void distribute(SLCell *R, int i, ArrType front, ArrType end)
{
//静态链表L的R域中记录已按(keys[0]...keys[i-1]有序)。
//本算法按第i个关键字keys[i]建立RADIX个子表，使同一子表中记录的keys[i]相同。
//front[0...RADIX-1]和end[0...RADIX-1]分别指向各子表中第一个和最后一个记录。
for(int j=0; j<RADIX; ++j)
front[j] = 0;        //各子表初始化为空表
for(int p=R[0].next; p; p=R[p].next)
{
int j;
j=R[p].keys[i];            //映射第i个关键字
if(!front[j])
front[j] = p;        //若front[j]为空，则把记录连接到front[j]的头指针上
else
R[end[j]].next = p;    //若front[j]的头指针已经连接过了，说明已j为关键字的数据已经有了，
//这时把上一个以j为关键字的数据指向当前的这个数，即下标为p的数据
end[j] = p;        //尾指针重新指到每次更新的数据上
}
}//distribute

void collect(SLCell *R, int i, ArrType front, ArrType end)
{
int j;
//本算法按keys[i]自小到大地将f[0...RADIX-1]所指各子表依次链接成为一个链表
for( j=0; !front[j]; j++);     //找到第一个不为空的子表
R[0].next=front[j];            //重整静态链表
int k=end[j];                    //k为当前子表的尾指针
while(j<RADIX)
{
for(++j; j<RADIX; j++)
if(front[j])        //找下一个非空子表
{
R[k].next=front[j];        //连接
k=end[j];
}
}
R[k].next=0;                    //k指向最后一个非空子表的尾指针
}//collect
void RadixSort(SLList &SLL){
ArrType front,end;
for(int i = 1; i <= SLL->keynum; i++)    //对各关键字进行分配和收集
{
distribute(SLL->R, i,front,end);    //第i趟分配
collect(SLL->R, i,front,end);        //第i趟收集
cout<<"═════第"<<i<<"分配和收集:";
print(SLL);
}
}
/*---------------------------------------------------------------------------------*/
void ShellSort()
{
cout<<"   ╔═════════════════════════════╗"<<endl;
cout<<"   ║                   希尔排序 ShellSort                 ║"<<endl;
cout<<"   ╚═════════════════════════════╝"<<endl;
int d[3]={5,3,1},R[MAXSIZE+1],n;
cout<<"═════请输入初始关键字个数:";
cin>>n;
cout<<"═════请输入"<<n<<"个数:";
for(int i=1;i<=n;i++) cin>>R[i];
cout<<"═════您输入的初始关键字序列为:";
for(int j=1;j<=n;j++){
cout<<R[j]<<" ";
}
cout<<endl;
SqList L;
cout<<"═════希尔排序的过程为："<<endl;
InitList_Sq(L,R,n);
Shellsort(L,d,3);
}

void QuickSort()
{
cout<<"   ╔═════════════════════════════╗"<<endl;
cout<<"   ║                   快速排序 QuickSort                 ║"<<endl;
cout<<"   ╚═════════════════════════════╝"<<endl;
cout<<"═════参考数值：49 38 65 97 76 13 27 49"<<endl;
cout<<"═════第一趟：27 38 13 49 76 97 65 49"<<endl;
cout<<"═════第二趟：13 27 38 49 76 97 65 49"<<endl;
cout<<"═════第三趟：13 27 38 49 49 65 76 97"<<endl;
cout<<"═════第四趟：13 27 38 49 49 65 76 97"<<endl;
int d[3]={5,3,1},R[MAXSIZE+1],n;
cout<<"请输入初始关键字个数:";
cin>>n;
cout<<"═════请输入"<<n<<"个数:";
for(int i=1;i<=n;i++) cin>>R[i];
cout<<"═════您输入的初始关键字序列为:";
for(int j=1;j<=n;j++){
cout<<R[j]<<" ";
}
cout<<endl;
SqList L;
cout<<"═════快速排序的过程为："<<endl;
InitList_Sq(L,R,n);
Quicksort(L);
}

void HeapSort()
{
cout<<"   ╔═════════════════════════════╗"<<endl;
cout<<"   ║                   堆排序 HeapSort                    ║"<<endl;
cout<<"   ╚═════════════════════════════╝"<<endl;
cout<<"═════参考数值：49 38 65 97 76 13 27 49"<<endl;
cout<<"═════第一趟：76 49 65 38 49 13 27 97"<<endl;
cout<<"═════第二趟：65 49 27 38 49 13 27 97"<<endl;
cout<<"═════第三趟：49 49 27 38 13 65 76 97"<<endl;
cout<<"═════第四趟：49 38 27 13 49 65 76 97"<<endl;
cout<<"═════第五趟：38 13 27 49 49 65 76 97"<<endl;
cout<<"═════第六趟：27 13 38 49 49 65 76 97"<<endl;
cout<<"═════第七趟：13 27 38 49 49 65 76 97"<<endl;
int d[3]={5,3,1},R[MAXSIZE+1],n;
cout<<"═════请输入初始关键字个数:";
cin>>n;
cout<<"═════请输入"<<n<<"个数:";
for(int i=1;i<=n;i++) cin>>R[i];
cout<<"═════您输入的初始关键字序列为:";
for(int j=1;j<=n;j++){
cout<<R[j]<<" ";
}
cout<<endl;
SqList L;
cout<<"═════堆排序的过程为："<<endl;
InitList_Sq(L,R,n);
Heapsort(L);
}

void MergingSort()
{
cout<<"   ╔═════════════════════════════╗"<<endl;
cout<<"   ║                 归并排序 MergingSort                 ║"<<endl;
cout<<"   ╚═════════════════════════════╝"<<endl;
cout<<"═════参考数值：49 38 65 97 76 13 27"<<endl;
cout<<"═════第一趟：38 49"<<endl;
cout<<"═════第二趟：65 97"<<endl;
cout<<"═════第三趟：38 49 65 97"<<endl;
cout<<"═════第四趟：13 76"<<endl;
cout<<"═════第五趟：13 27 76"<<endl;
cout<<"═════第六趟：13 27 38 49 65 76 97"<<endl;
int d[3]={5,3,1},R[MAXSIZE+1],n;
cout<<"═════请输入初始关键字个数:";
cin>>n;
cout<<"═════请输入"<<n<<"个数:";
for(int i=1;i<=n;i++) cin>>R[i];
cout<<"═════您输入的初始关键字序列为:";
for(int j=1;j<=n;j++){
cout<<R[j]<<" ";
}
cout<<endl;
SqList L;
cout<<"═════归并排序的过程为："<<endl;
InitList_Sq(L,R,n);
MergeSort(L);
}

int RadixSorting()
{
cout<<"   ╔═════════════════════════════╗"<<endl;
cout<<"   ║               基数排序 RadixSorting                ║"<<endl;
cout<<"   ╚═════════════════════════════╝"<<endl;
cout<<"═════参考数值：278 109 63 930 589 184 505 269 008 083"<<endl;
cout<<"═════第一趟：930 063 083 184 505 278 008 109 589 269"<<endl;
cout<<"═════第二趟：505 008 109 930 063 269 278 083 184 589"<<endl;
cout<<"═════第三趟：008 063 083 109 184 269 278 505 589 930"<<endl;
SLList SLL;
SLL=(SLList)malloc(MAX_SPACE*sizeof(Sllist));
SLL->R=(SLCell *)malloc(MAX_SPACE*sizeof(SLCell));
SLL->recnum=0;
creatList(SLL);
cout<<"═════排序前:";
print(SLL);
RadixSort(SLL);
return 0;
}

希尔排序、快速排序、堆排序、归并排序、基数排序