数据结构基于顺序表相关的排序算法

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define maxsize 500
//定义顺序表
typedef struct SSTable{
    int data[maxsize];
    int len;
}SSTable;
//初始化顺序表
void InitList(SSTable &ST){
    for(int i=0;i<maxsize;i++){
        ST.data[i]=0;
    }
    ST.len=0;
}
//打印顺序表
void print(SSTable ST){
    for(int i=0;i<ST.len;i++){
        printf( "%d\t",ST.data[i]);
    }
    printf("\n");
}
//交换函数
void swap(int &a,int &b){
    int temp;
    temp=a;
    a=b;
    b=temp;
}
//插入排序(不带哨兵)
void InsertList(SSTable &ST){
    int i,j,temp;
    //第一个数默认是有序的
    for(i=1;i<ST.len;i++){
        //如果比其前驱小，将变量保存在temp中，之后依次后移i之前的变量
        if(ST.data[i]<ST.data[i-1]){
            temp=ST.data[i];
            //j>temp && j>=0 j--
            for(j=i-1;j>=0 && ST.data[j]>temp;j--){
                ST.data[j+1]=ST.data[j];
            }
            //将该元素放回对应位置
            ST.data[j+1]=temp;
        }
    }
}
//插入排序(带哨兵)
void InsertList1(SSTable &ST){
    //定义相关变量
    int i,j;
    //依次遍历
    for(i=2;i<ST.len;i++){
        //比哨兵小,依次后移
        if(ST.data[i]<ST.data[i-1]){
            //设立哨兵
            ST.data[0]=ST.data[i];
            for(j=i-1;ST.data[j]>ST.data[0];j--){
                ST.data[j+1]=ST.data[j];
            }
            ST.data[j+1]=ST.data[0];
        }
    }
    //将第一个数组元素归0
    ST.data[0]=0;
}
//插入排序(折半查找,带哨兵)
void InsertList2(SSTable &ST){
    //定义相关变量
    int i,j,low,high,mid;
    //遍历整个顺序表
    for(i=2;i<=ST.len;i++){
        //如果比前驱小(折半查找，找到插入的位置)
        if(ST.data[i]<ST.data[i-1]){
            //存储相关变量
            ST.data[0]=ST.data[i];
            low=1;
            high=i-1;
            while(low<=high){
                mid=(low+high)/2;
                if(ST.data[0]<ST.data[mid])
                    high=mid-1;
                else
                    low=mid+1;
            }
            //将low到i-1都向后移动一位
            for(int j=i-1;j>=low;j--){
                ST.data[j+1]=ST.data[j];
            }
            ST.data[low]=ST.data[0];
        }
    }
}
//希尔排序(基本思路：将整个数列分成不同的表，将每个表中的数据进行排序，同时改变增量)
void ShellSort(SSTable &ST){
    //设置相关变量
    int i,j,d;
    //第一层循环(改变d的数值)
    for(d=ST.len/2;d>=1;d=d/2){
        //第二层循环(让d值每次增加1)
        for(i=d+1;i<=ST.len;i++){
            //开始比较(简单插入排序)
            if(ST.data[i]<ST.data[i-d]){
                //存储要被覆盖的元素值
                ST.data[0]=ST.data[i];
                //第三层排序(分块间简单插入排序)
                for(j=i-d;j>0 && ST.data[0]<ST.data[j];j-=d){
                    ST.data[j+d]=ST.data[j];
                }
                //将ST.data[j+d]赋值
                ST.data[j+d]=ST.data[0];
            }
        }
    }
}
//冒泡排序(从后往前冒泡)
void BubbleSort(SSTable &ST){
    int temp;
    //遍历每个元素
    for(int i=0;i<ST.len;i++){
        //设置标志位
        bool flag=false;
        //元素冒泡
        for(int j=ST.len-1;j>i;j--){
            if(ST.data[j-1]>ST.data[j]){
                //交换元素
                temp=ST.data[j-1];
                ST.data[j-1]=ST.data[j];
                ST.data[j]=temp;
                //表明元素发生了交换
                flag=true;
            }
        }
        //该趟冒泡排序没有发生交换
        if(flag==false)
            return;
    }
}
//冒泡排序(从前往后)
void BubbleSort1(SSTable &ST){
    int temp;
    for(int i=0;i<ST.len;i++){
        bool flag=false;
        for(int j=0;j<ST.len-1-i;j++){
            if(ST.data[j+1]<ST.data[j]){
                temp=ST.data[j+1];
                ST.data[j+1]=ST.data[j];
                ST.data[j]=temp;
                flag=true;
            }
        }
        if(flag==false)
            return;
    }
}
//快速排序
int Partition(int data[],int low,int high){
    int pivot=data[low];//第一个元素作为中枢元素
    while(low<high){
        //low对应的位置为空,对high找出相应的比中枢元素还要小的元素
        while(low<high && data[high]>=pivot)
            high--;
        data[low]=data[high];
        //high对应的位置为空,对low找出相应的比中枢元素还要大的元素
        while(low<high && data[low]<=pivot)
            low++;
        data[high]=data[low];
    }
    data[low]=pivot;
    return low;
}
void QuickSort(int data[],int low,int high){
    if(low<high){
        int pivotpos=Partition(data,low,high);
        Partition(data,low,pivotpos-1);
        Partition(data,pivotpos+1,high);
    }
}
//简单选择排序(基本思想:每次选择一个元素与其后面的每一个元素进行对比,把小的元素下标交换,最后把元素值交换)
void SelectSort(SSTable &ST){
    //设置最小值和相关变量
    int temp;
    //外循环(将每一个元素遍历一遍，最后一个元素不需要遍历，即n个元素遍历n-1次)
    for(int i=0;i<ST.len-1;i++){
        //每次将i元素设为最小的元素，与后面的元素进行对比
        int min=i;
        //内循环(每一趟中从第i个元素到最后一个元素与第i个元素对比)
        for(int j=i+1;j<ST.len;j++){
            //如果比第i个元素小,交换坐标和数值
            if(ST.data[j]<ST.data[min]){
                min=j;
            }
        }
        //如果最后元素不是自己本身,交换元素
        if(min!=i){
            temp=ST.data[min];
            ST.data[min]=ST.data[i];
            ST.data[i]=temp;
        }
    }
}
//堆排序
//调整为大根堆
void HeadAdjust(int data[],int k,int len){
    //暂存第一个根节点
    data[0]=data[k];
    //循环判断每一个i
    for(int i=2*k;i<=len;i*=2){
        //判断根节点左右两个孩子的大小
        if(i<len && data[i+1]>data[i])
            i++;
        //判断根节点和最大的孩子节点大小
        if(data[0]>=data[i])
            break;
        else{
            //将大的那个节点与根节点交换位置
            data[k]=data[i];
            k=i;
        }
    }
    data[k]=data[0];
}
//调整为小根堆
void HeapAdjust1(int data[],int k,int len){
    //暂存以k为根的元素
    data[0]=data[k];
    for(int i=k*2;i<=len;i*=2){
        //判断两个节点大小
        if(data[i+1]<data[i])
            i++;
        //判断根节点和节点大小
        if(data[0]<data[i])
            break;
        else{
            data[k]=data[i];
            k=i;
        }
    }
    data[k]=data[0];
}
//建立小根堆
void BuildMinHeap(int data[],int len){
    for(int i=len/2;i>0;i--){
        HeapAdjust1(data,i,len);
    }
}
//建立大根堆
void BuildMaxHeap(int data[],int len){
    for(int i=len/2;i>0;i--){
        HeadAdjust(data,i,len);
    }
}
//大根堆排序
void HeapSort(int A[],int len){
    BuildMaxHeap(A,len);
    for(int i=len;i>1;i--){
        //交换堆顶和堆底元素
        swap(A[1],A[i]);
        HeadAdjust(A,1,i-1);
    }
}
//小根堆排序
void HeapSort1(int data[],int len){
    BuildMinHeap(data,len);
    for(int i=len;i>1;i--){
        swap(data[1],data[i]);
        HeapAdjust1(data,1,i-1);
    }
}
//小根堆插入
void InsertMinHeap(int data[],int len,int e){
    int temp,k=len;
    //建立小根堆
    BuildMinHeap(data,len);
    //先插入小根堆的尾部
    data[k]=e;
    for(int i=len/2;i>=1;i/=2){
        if(data[i]>data[k]) {
            temp = data[i];
            data[i] = data[k];
            temp = data[k];
            k=i;
        }else{
            break;
        }
    }
}
//小根堆删除(基本思路:删除元素后，用最后一个元素补上，并且不断下坠)
void DeleteMinHeap(int data[],int len,int index){
    //用最后一个元素补上
    BuildMinHeap(data,len);
    data[index]=data[len-1];
    data[len-1]=0;
    //调用小根堆调整方法
    HeapAdjust1(data,index,len-index);
}
int *B=(int *)malloc(sizeof(int)*10);
//归并排序
//归并
void Merge(int A[],int low,int high,int mid){
    //定义相关变量
    int i,j,k;
    //将A中的元素复制到辅助数组B
    for(i=low;i<=high;i++){
        B[i]=A[i];
    }
    //开始归并
    for(i=low,j=mid+1,k=i;i<=mid && j<=high;k++){
        if(B[i]<=B[j])
            A[k]=B[i++];
        else
            A[k]=B[j++];
    }
    //剩余的元素归并
    while(i<=mid)
        A[k++]=B[i++];
    while(j<=high)
        A[k++]=B[j++];
}
//归并完整版
void MergeSort(int A[],int low,int high){
    if(low<high){
        int mid=(low+high)/2;
        MergeSort(A,low,mid);
        MergeSort(A,mid+1,high);
        Merge(A,low,high,mid);
    }
}
int main() {
    SSTable ST;
    InitList(ST);
    //输入对应的数据
    ST.data[0]=0;
    ST.data[1]=9;
    ST.data[2]=8;
    ST.data[3]=7;
    ST.data[4]=6;
    ST.data[5]=5;
    ST.data[6]=4;
    ST.data[7]=3;
    ST.data[8]=2;
    ST.data[9]=1;
    ST.len=10;
    print(ST);
    //InsertList2(ST);  
    //ShellSort(ST);
    //BubbleSort1(ST);
    //SelectSort(ST);
    //BuildMaxHeap(ST.data,10);
    //HeapSort(ST.data,ST.len);
    //BuildMinHeap(ST.data,ST.len);
    //InsertMinHeap(ST.data,ST.len,13);
    //DeleteMinHeap(ST.data,ST.len,3);
    MergeSort(ST.data,0,9);
    print(ST);
    return 0;
}