排序1

插入排序

基本思想

1.从前往后遍历，如果a[i-1]>a[i],则应当把temp=a[i]往前移动;
2.由于i-1之前的元素有可能比a[i]小；
3.则应以j=i-1为起始点进行一个小循环，把a[j]移到a[j+1],j–,即往前遍历并与temp比较;
4.若a[j]>temp,则把a[j-1]后移，j–,继续往前遍历并与temp比较;
5.若a[j]

代码

//升序
void InsertSort(int b[],int left,int right){
    int i,j;
    int temp;
    for(i=left+1;i<=right;i++){
        if(b[i]<b[i-1]){
            temp=b[i];
            j=i-1;
            do{
                b[j+1]=b[j];
                j--;
            }while(j>=left&&temp<b[j]);
            b[j+1]=temp;
        }
    }
}

---

折半插入排序

代码

//升序
void BinaryInsertSort(int b[],int left,int right){
    int low,middle,high,i,k;
    int temp;
    for(i=left+1;i<=right;i++){
        temp=b[i];low=left;high=i-1;
        while(low<=high){
            middle=(low+high)/2;
            if(temp<b[middle]){
                high=middle-1;
            }
            else {
                low=middle+1;
            }
        }
        for(k=i-1;k>=low;k--){
            b[k+1]=b[k];
        }
        b[low]=temp;
    }
}

---

希尔排序

基本思想

设待排序元素序列有n个元素，首先取一个整数$gap<n$作为间隔，将全部元素分为gap个子序列，所有举例为gap的元素放在同一个子序列中，在每个子序列中分别施行直接插入排序。然后缩小间隔gap，重复上述的子序列划分和排序工作。直到最后取gap==1，将所有元素放入同一个序列中排序为止。摘自《数据结构》殷人昆

代码

void ShellSort(int b[],int left,int right){
    //升序
    int gap,i,j,temp;
    gap=right-left+1;
    do{
        gap=gap/3+1;
        for(i=left+gap;i<=right;i++){
            if(b[i]<b[i-gap]){
                temp=b[i];j=i-gap;
                do{
                    b[j+gap]=b[j];
                    j=j-gap;
                }while(j>=left&&temp<b[j]);
                b[j+gap]=temp;
            }
        }
    }while(gap>1);
}

---

快速排序

基本思想

利用序列某个元素作为基准，将整个序列划分为作于两个子序列。算法中会执行一个循环，将小于基准的元素移到左端，将大于的移动到右端。

参考某个博客的

大神的解释：这里写链接内容

void QuickSort(int a[],int left,int right){
    //升序
    if(left<right){
        int z,y,t;
        y=right;
        t=a[left];
        while(z<y){
            while(z<y&&t<a[y]){
               y--;                 //从右往左找到第一个小于t的值的位置y
            }
            if(z<y){
                a[z++]=a[y];     //将第一个小于t的数移动到左端，并z++;
            }
            while(z<y&&t>a[z]){
                z++;                //从左往右找到第一个大于t的数的位置z；
            }
            if(z<y){
                a[y++]=a[z];
            }
        }
        a[z]=t;
        QuickSort(a,z+1,right);
        QuickSort(a,left,z-1);
    }
}

---

《参考数据结构》（清华大学出版社，殷人昆）

void quick_sort(int a[],int left,int right){
    //升序
    if(left<right){
        int pivotpos,t;
        pivotpos=left;
        t=a[left];
        for(int i=left+1;i<=right;i++){
            if(a[i]<t){             //小于t的移到左端
                pivotpos++;
                if(pivotpos!=i){
                    swap(a[i],a[pivotpos]);
                }
            }
        }
        a[left]=a[pivotpos];
        a[pivotpos]=t;
        quick_sort(a,left,pivotpos-1);
        quick_sort(a,pivotpos+1,right);
    }
}

三路划分的快速排序

基本思想：

适合处理带有大量重复排序码的序列
将排序码分为三部分，比基准小的，比基准大的，与基准相等的。
先将与排序相等的放到序列两端。然后在移动到中部。具体见代码。。

代码

参考自《参考数据结构》（清华大学出版社，殷人昆）

void TrQS(int b[],int left,int right){
    //升序
    if(right>=left){
        return ;
    }
    int i,j,z,y,k,pivot;
    i=left-1;j=right;
    z=left-1;y=right;
    pivot=b[left];
    while(1)
    {
        while(b[++i]<pivot){
            if(i==j){
                break;
            }
        }
        while(b[--j]>pivot){
            if(i==j){
                break;
            }
        }
        if(i>=j){
            break;
        }
        swap(b[i],b[j]);
        if(b[i]==pivot){
            z++;
            swap(b[i],b[z]);
        }
        if(b[j]==pivot){
            y++;
            swap(b[i],b[y]);
        }
    }
    if(b[i]>b[right]){
        swap(b[i],b[right]);
        k=right-1;
    }
    else {
        k=right;
    }
    j--;i++;
    while(k>=y){
        swap(b[k],b[i]);
        i++;k--;
    }
    for(k=left;k<=z;k++,j--){
        swap(b[j],b[k]);
    }
    //j<i
    TrQS(b,left,j);
    TrQS(b,i,right);
}

---