排序：直接插入排序、折半插入排序、希尔排序

//
// Created by lijing on 23-12-7.
//
//#include "SequentialTableStorageStructure.h"
#include "../../Define.h"
#define MAXSIZE 10                                 //顺序表的最大长度
typedef int KeyType; //定义关键字类型为整型
typedef int InfoType;
typedef struct{
    KeyType key;                                //关键字项
    InfoType otherinfo;                         //其他数据项
}RedType;                                       //记录类型
typedef struct{
    RedType r[MAXSIZE+1];                       //r[0]闲置或用做哨兵单元
    int length;                                 //顺序表长度
}SqList;//顺序表类型
//打印顺序表
void Print(SqList &L){
    for (int i = 1; i < L.length; ++i) {
        printf("%d ",L.r[i].key);

    }
}
//直接插入排序
//
void InsertSort(SqList &L){
    int j;
    for(int i=2;i<L.length;++i){//从第二个元素开始
        if (L.r[i].key<L.r[i-1].key){//如果当前元素小于前一个元素
           L.r[0]=L.r[i];//将当前元素赋值给哨兵单元
           L.r[i]=L.r[i-1];//r[i-1]后移
            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];//将哨兵单元的值插入到合适的位置
        }
    }
}
//折半插入排序
//折半插入排序仅减少了关键字间的比较次数，而记录的移动次数不变。
// 因此，折半插入排序的时间复杂度仍为O(n2)
//辅助空间r[0],空间复杂度为O(1)
//算法特点：1.稳定排序；2.折半查找只能用于顺序结构；3.适合初始记录无序、n较大
void BinaryInsertSort(SqList &L){
    int j;
    for (int 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;
        }
        for (j = i-1; j >= high + 1; --j) {
            L.r[j+1] = L.r[j];//记录逐个后移，直到找到插入为止
        }
        L.r[high+1] = L.r[0];//将哨兵单元的值插入到合适的位置
    }
}
//希尔排序
//（Shell's Sort）又称“缩小增量排序”（Diminishing Increment Sort）,跳跃式增大移动步幅：不稳定排序
//经过几次分组 直接插入排序后，整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序
//希尔排序的时间复杂度为O(n^1.3)，空间复杂度为O(1)
//算法特点：1.不稳定排序；2.适合初始记录无序、n较大
//直接插入排序可以看成一趟增量是1的希尔排序:
    //希尔排序子程序：直接插入排序
void ShellInsertSort(SqList &L,int dk){
    //对顺序表L进行dk步长的希尔排序
    int j;
    for(int i=1+dk ; i<=L.length ; ++i) {
        if (L.r[i].key < L.r[i - dk].key) {
            L.r[0] = L.r[i];//r[0]只是暂存单元，不是哨兵。当j≤0时，插入位置已找到。
            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){//dk值一次穿在dt[]中，t为趟数，如t=3
    //按增量序列dt[0...t-1]对顺序表L进行t趟排序
    //如何找到最佳dk序列目前尚未解决，最后的增量必须为1，没有除1之外的公因子
    for(int k=0;k<t;++k){
        //对顺序表L进行dk步长的希尔排序
        ShellInsertSort(L,dt[k]);
    }
    Print(L);
}

int main(){
    int arr[]={49,38,65,97,76,13,27,49,55,04};
    SqList L;
    for (int i = 0; i < 11; ++i) {
        L.r[i+1].key=arr[i];
    }
    L.length=10;
    int dk[]={5,3,1};
//    ShellSort(L,dk,3);
//    BinaryInsertSort(L);
    InsertSort(L);
    Print(L);
}