排序之插入排序

排序的稳定性

• 对于数据中相同的元素，他们在原始数据中的内容到顺序在排序后前后顺序不变

内部排序和外部排序

• 划分：是否在内存内
• 内部排序是完全在内存中进行，而外部排序有些是在内存外部进行的

排序的分类

• 插入排序
• 交换排序
• 选择排序
• 归并排序
• 计数排序

排序的操作

• 比较
• 移动

直接插入排序算法

int sqlis[]={6，1，87，14，89，15，78，12，67，23}；

void InsertSort(int aqlis[],int n)
{
    for(int i=1;i<n;i++)
    {
        if(sqlis[i]>sqlis[i-1)
        {
            swap(sqlis[i],sqlis[i-1]);
            for(int j=i-1;j>0&&sqlis[j]>sqlis[j-1];j--)
            {
                swap(sqlis[j],sqlis[j-1]);
            }
        }
    }
}

折半插入排序算法

void BInsertSort(int arr[],int n)
{
//找到要插入的位置，即high+1
    for(int i=2;i<n;i++)//此处用了arr[0]作为哨兵位，用来保存要排序的点的数值
    {
        arr[0]=arr[i];
        int low=1;
        int high=i-1;//因为是从1位置开始遍历排序，因此在i之前的数值都变成了有序的，因此才能使用折半插入排序，
        //因此是调整了i和他之前的所有数
        while(low<=high)
        {
            if(arr[0]>arr[mid])
                low=mid+1;
            else
                high=mid-1;
        }
    }
    //调整了i之前的数值顺序，因此high+1是要插入的点，但是一定比i位小
    //循环终止条件位j--后j=high+1时停止，而最后一次交换即为high+1与high+2位交换，
    //而high+1位单独赋值是为了在i=2时i=high+1就不用进入循环了
    for(int j=i;j>high+1;j--)
    {
        arr[j]=arr[j-1];
    }
    arr[high+1]=arr[0];
}

总结

• 要用0位作为记录排序的位置
• 折半插入排序必须是有序的，折半插入相当于二分法先找到，再进行插入，但是为了让数组成为有序的，在排序时，只能在查找点的位置前面，已经排好序的数据中进行使用二分法进行查找，之后再插入(通过循环，一一交换向前移动)。
• 相比于直接插入，减少了比较次数，但没有减少移动次数

2路插入排序

void TWayInsertSort(int arr[],int n)
{
    int *copy;
    copy[0]=arr[0];//此方法没有用0作为哨兵位，0位也是有有用值
    int head,tail;
    head=tail=0;
    for(int i=1;i<n;i++)
    {
        if(arr[i]<copy[head])//如果比头还小，就往前插
        {
            head=(head-1+n)%n;
            copy[head]=arr[i];
        }
        else if(arr[i]>copy[tail])//如果比尾大就往后插
        {
            tail++;
            copy[tail]=arr[i];
        }
        else//从尾部开始比较，如果比尾小，就要移动
        {
            tail++;
            copy[tail]=copy[tail-1];//绝对比尾部小，因此先将尾部向后移动一位
            for(int j=tail-1;arr[i]<copy[(j-1+n)%n];j=(j-1+n)%n;)//再从尾部向前面的数值一一比较，
            //如果小就交换，不过要注意是循环的数组
            {
                copy[j]=copy[(j-1+n)%n];
            }
            copy[j]=arr[i];
        }
    }
    for(int i=0;i<n;i++)//从copy[]头部将数据全部复制到arr[]上
    {
        arr[i]=copy[head];
        head=(head+1)%n;
    }
}

总结

• 此方法没有使用哨兵位
• 注意新建数组是循环的，因此-1时要(i-1+n)%n,+1时要(i+1)%n,在最后为原数组重新赋值时必须从拷贝数组的头部开始赋值
• 减少了移动次数

表插入排序

#define MAXVALUE 0x7FFFFFFF
typedef struct SLnode
{
    int data;
    int link;
}Slnode;
typedef SLnode Table[10];

void main()
{
    int arr[]={0,24,64,84,12,53,43,46,14};
    int n=9;
    Table tb;
    tb[0].data=MAXVALUE;
    tb[0].link=0;
    for(int i=1;i<n;i++)
    {
        tb[i].data=arr[i];
        tb[i].link=0;
    }
    TableInsertSort(arr,n);
}

void TableInsertSort(int arr[],int n)
{
    arr[0].link=1;
    int p,q;
    for(int i=2;i<n;i++)
    {
        p=arr[0].link;
        q=0;
        while(p!=0&&arr[p].data<=arr[i].data)//相当于链表从头开始遍历，然后判断是否有比arr[i]大的，
        //如果没有就进入循环，一直向后查找链表，如果有就将arr[i]放入arr[p]之前，用q记录p的前一个，将q指向i,i再指向p
        {
            q=p;
            p=t[p].link;
        }
        arr[i].link=arr[q].link;
        arr[q].link=i;
    }
}

总结

• 用0位置表示最小值，只记录了最小值的位置
• 开始时需要将0位初始化
• 与直接插入相比，只是把移动改成了修改2n次指针值，但是比较次数并未改变，时间复杂度仍为n^2
• 最终形成了有序链表，不能进行顺序查找，只能按照链表方式进行查找

插入排序之希尔排序

int dlta[]={5,3,2,1};
int t=sizeof(dlta)/sizeof(int);
void ShellSort(int arr[],int n,int dlta[],int t);

void ShellInsert(int arr[],int n,int dk)
{
    for(int i=dk+1;i<n;i++)
    {
        if(arr[i-dk]>arr[i])//比较前后两个数的大小，如果前面的数大，则需要调换位置
        {
            int j;//代表前面的数值
            arr[0]=arr[i];//将后面的数存到0下标的位置中去
            for(j=i-dk;j>0&&arr[0]<arr[j];j-=dk)//比较后面的数和前面的数的大小，通过0下标的位置调换他们两个的位置
            {
                arr[j+dk]=arr[j];
            }
            arr[j]=arr[0];
        }
    }
}
void ShellSort(int arr[],int n,int dlta[],int t)
{
    for(int k=0;k<t;k++)
    {
        ShellInsert(arr,n,dlta[k]);//传入递增数值
    }
}

总结

• 希尔排序让其基本有序，效率较高
• 但仍未得到一些较好的增量序列