C语言 排序算法 代码实现

#include<stdio.h>

//#include<string.h>

//#include<math.h>

#include<stdlib.h>

//函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

#define NULL 0

#define MAXSIZE 20//设记录不超过20个

//Status是函数的类型，其值是函数结果状态代码

typedef int Status;

typedef int KeyTpye;//设关键字为int型

//声明结点的类型和指向结点的指针类型

//定义每个记录（数据元素）的类型

typedef struct{

KeyTpye key;//关键字

InfoType otherinfo;//其他数据项

}RedType;

//定义顺序表的结构

typedef struct{

RedType r[MAXSIZE+1];//存储顺序表的向量，r[0]一般作哨兵或缓冲区

int length;//顺序表的长度

}SqList;

//直接插入排序——“哨兵”（从小到大排序）

void InsertSort(SqList &L){

int i,j;

for(i=2;i<=L.length;i++){

if(L.r[i].key<L.r[i-1].key){//若“<”，需将L.r[i]插入有序子表

L.r[0]=L.r[i];//复制为哨兵

for(j=i-1;L.r[0].key<L.r[j].key;j--){

L.r[j+1]=L.r[j];//记录后移

}

L.r[j+1]=L.r[0];//插入正确位置

}

}

}

//折半插入排序——“哨兵”

void BInsertSort(SqList &L){

int i,j;

for(i=2;i<=L.length;i++){

L.r[0]=L.r[i];//复制为哨兵

int low=1,high=i-1;//初始化查找的左右区间

while(low<=high){

int mid=(low+high)/2;//查找区间的中间位置

if(L.r[0].key<L.r[mid].key) high=mid-1;//在左边区间继续查找

else low=mid+1;//在右边区间继续查找

}//循环结束时，high+1则为插入位置

//腾出high+1的位置，将插入位置后面的元素后移

for(j=i-1;j>=high+1;j--) L.r[j+1]=L.r[j];

L.r[high+1]=L.r[0];//插入正确位置

}

}

//希尔排序

void ShellSort(SqList &L,int dlta[],int t){

//按增量序列 dlta[0..t-1]对顺序表L作希尔排序

for(int k=0;k<t;k++){

ShellInsert(L,dlta[k]);//增量为dlta[k]的插入排序

}

}

void ShellInsert(SqList &L,int dk){

//对顺序表L作增量为dk的shell排序，dk为步长因子

for(int i=dk+1;i<=L.length;i++){

if(L.r[i].key<L.r[i-dk].key){

L.r[0]=L.r[i];//复制为哨兵

for(int j=i-dk;j>0 && (L.r[0].key<L.r[j].key);j=j-dk) L.r[j+dk]=L.r[j];

L.r[j+dk]=L.r[0];

}

}

}

//冒泡排序

void bubble_sort(SqList &L){

int m,i,j,n=L.length;

RedType x;//交换时临时存储

for(m=1;m<=n-1;m++){

for(j=1;j<=n-m;j++){

if(L.r[j].key>L.r[j+1].key){//发生逆序

x=L.r[j];

//交换

L.r[j]=L.r[j+1];

L.r[j+1]=x;

}

}

}

}

//冒泡排序——改进

void bubble_sort(SqList &L){

int m,i,j,n=L.length,flag=1;//flag作为是否有交换的标记

RedType x;//交换时临时存储

for(m=1;m<=n-1 && flag==1;m++){

flag=0;//当前没有发生交换

for(j=1;j<=n-m;j++){

if(L.r[j].key>L.r[j+1].key){//发生逆序

flag=1;//本趟发生交换

x=L.r[j];

//交换

L.r[j]=L.r[j+1];

L.r[j+1]=x;

}

}

}

}

//快速排序

void QSort(SqList &L,int low,int high){

if(low<high){

int pivotloc=Partition(L,low,high);//将L.r[low..high]一分为二，pivotloc为枢轴元素排好序的位置

QSort(L,low,pivotloc-1);//对低子表递归排序

QSort(L,pivotloc+1,high);//对高子表递归排序

}

}

int Partition(SqList &L,int low,int high){

L.r[0]=L.r[low];//复制为哨兵

KeyTpye pivotkey=L.r[low].key;//选择枢轴元素

while(low<high){

while(low<high && L.r[high].key>=pivotkey) high--;//若右边的值>枢轴元素，则右指针high向左边移动

L.r[low]=L.r[high];//将右边的值搬到左边

while(low<high && L.r[low].key<=pivotkey) low++;//若左边的值<枢轴元素，则左指针low向右边移动

L.r[high]=L.r[low];//将左边的值搬到右边

}

L.r[low]=L.r[0];

return low;

}

//简单选择排序

void SelectSort(SqList &L){

for(int i=1;i<L.length;i++){

int min=i;//置最小位置为当前位置

for(int j=i+1;j<=L.length;j++){

if(L.r[j].key<L.r[min].key) min=j;//记录最小位置

}

if(min!=i){

L.r[0]=L.r[i];

//交换

L.r[i]=L.r[min];

L.r[min]=L.r[0];

}

}

}

//堆排序

void HeapSort(elem R[]){

int i;

for(i=n/2;i>=1;i--)HeapAdjust(R,i,n);//建立初始堆

for(i=n;i>1;i--){//进行n-1趟排序

Swap(R[1],R[i]);//根与最后一个元素交换

HeapAdjust(R,1,i-1);//对R[1]到R[i-1]重新建堆

}

}

//筛选

void HeapAdjust(elem R[],int s,int m){

//已知R[s..m]中记录的关键字除R[s]之外均满足堆的定义

//本函数调整R[s]的关键字，使R[s..m]成为一个大根堆

rc=R[s];

for(int j=2*s;j<=m;j*=2){//沿key较大的孩子结点向下筛选

if(j<m && R[j]<R[j+1]) j++;//j为key较大的记录的下标

if(rc>=R[j]) break;

//rc应插入在位置s上

R[s]=R[j];

s=j;

}

R[s]=rc;//插入

}

//

int main(){

return 0;

}