常见的四种插入排序

一.直接插入排序(不带哨兵)

/*
直接插入排序(不带哨兵) --- 从小到大

空间复杂度:O(1)
时间复杂度:最好的时间复杂度为O(n),最坏为O(n^2)
稳定性:稳定
*/
void InsertSort(int data[],int n){
    int i,j,temp;
    for(i=1;i<n;i++){
        if(data[i]<data[i-1]){
            temp = data[i]; //保存data[i]的副本
            for(j=i-1;j>=0&&data[j]>temp;j--){
                data[j+1] = data[j];
            }
            data[j+1] = temp;
        }
    }
}

二.直接插入排序(带哨兵)

/*
直接插入排序(带哨兵) --- 从小到大排序
对于带哨兵的插入排序，数组的第一个位置是不允许用于存放数据的
*/
void InsertSortWithGuard(int data[],int n){
    int i,j;
    for(i=2;i<n;i++){
        if(data[i]<data[i-1]){
            data[0] = data[i];  //数组的第一个位置用于存放哨兵
            for(j=i-1;data[j]>data[0];j--){   //加入了哨兵的好处在于简化了for循环的判断条件
                data[j+1] = data[j];
            }
            data[j+1] = data[0];
        }
    }
}

三.折半插入排序

/*
折半插入排序
为什么可以优化？因为每次向前查找时,前面的数据都已经有序
*/
void InsertSortWithHalf(int data[],int n){
    int i,j,temp,mid,low,high;
    for(i=2;i<n;i++){
        if(data[i]<data[i-1]){
            temp = data[i];
            low=1,high=i-1;
            /*
            二分找出分界点,当temp的值大于mid的值时需要将区间缩小到[mid+1,h]
            即区间划分为[l,mid]和[mid+1,h]
            */
            while(high>low){
                mid = (low+high+1)/2;
                if(temp>data[mid]){
                    low = mid;
                } else {
                    high = mid-1;
                }
            }

            for(j=i-1;j>high;j--){
                data[j+1] = data[j];
            }
            data[high+1] = temp;
        }
    }
}

四.希尔排序

/*
希尔排序(从0开始排序)
该算法的思想:即从下标为0+d的位置依次对每个子表进行排序(我们也可以先完成一个子表的排序)

空间复杂度:O(1)
时间复杂度:最好的时间复杂度为O(n^1.3),最坏的时间复杂度为O(n^2)
稳定性:不稳定
*/
void ShellSort(int data[],int n){
    int d;  //每次希尔排序的步长
    int i,j;
    for(d=n/2;d>=1;d/=2){
        for(i=d;i<n;i++){
            if(data[i]<data[i-d]){  //完成从小到大的排序
                int temp = data[i];
                for(j=i-d;j>=0&&data[j]>temp;j-=d){
                    data[j+d] = data[j];
                }
                data[j+d] = temp;
            }
        }
    }
}

/*
希尔排序的第二种实现方式,每次都率先完成一个子表的处理,而不是同时进行多个子表的处理
*/
void ShellSort2(int data[],int n){
    int d,i,j;
    for(d=n/2;d>=1;d/=2){
        int count = 0;
        for(i=count+d;i<n;i+=d){
            if(data[i]<data[i-d]){
                int temp = data[i];
                for(j=i-d;j>=0&&data[j]>temp;j-=d){
                    data[j+d] = data[j];
                }
                data[j+d] = temp;
            }
        }
        i=0;
        count++;
    }
}