排序算法总结

这是对个人对于排序算法回顾和复习，所以可能写的很省略。如果之前没有学过可以看看参考列的博客。这篇博客在秋招后会删掉。写的太low了o(╯□╰)o

冒泡排序

通过前后相邻元素进行比较一次最大或最小值放到最后，思想很简单，不细说。

void BubbleSort(int A[], int n)
{
    int temp;
    for (int j = 0; j < n - 1; j++)
    {
        for (int i = 0; i < n - 1 - j; i++)
        {
            if (A[i] > A[i + 1])
            {
                temp=A[i];
                A[i]=A[i+1];
                A[i+1]=temp;
            }
        }
    }
}

简单选择排序

初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

第一趟{1,5,3,6,8,7,2,4}

第二趟{1,2,3,6,8,7,5,4}

第三趟{1,2,3,6,8,7,5,4}

第四趟{1,2,3,4,8,7,,5,6}

第五趟{1,2,3,4,5,7,8,6}

第六趟{1,2,3,4,5,6,8,7}

第七趟{1,2,3,4,5,6,7,8}

void SelectSort(int A[],int n)
{
    int min,temp;
    for(int i=0;i<n;i++)
    {
        min=i;
        for(int j=i+1;j<n;j++)
            if(A[j]<A[min])
                min=j;
        if(min!=A[i])
        {
            temp=A[i];
            A[i]=A[min];
            A[min]=temp;
        }
    }
}

插入排序

思想很简单，将前面当成已排序序列，然后从后往前插入数据。依次扩大已排序序列，从后往前插入。
还是以前面序列为例

{ 6, 5, 3, 1, 8, 7, 2, 4 }

第一趟:{5,6,3,1,8,7,2,4}

第二趟:{3,5,6,1,8,7,2,4}

第三趟:{1,3,5,6,8,7,2,4}

第四趟:{1,3,5,6,8,7,2,4}

第五趟:{1,3,5,6,7,8,2,4}

第六趟:{1,2,3,5,6,7,8,4}

第七趟:{1,2,3,4,5,6,7,8}

伪代码

void InsertSort(int A[],int n)
{
    int temp;
    for(int i=1;i<n;i++)
    {
        temp=A[i];
        int j;
        for(j=i-1;j>=0;j--)
        {
            if(temp<A[j])
                A[j+1]=A[j];
            else
                break;
        }
        A[j+1]=temp;
    }
}

二分插入排序
二分排序其实就是对上面插入排序的改进，将前面的顺序遍历查找改成了二分查找。

void BinarySort(int A[],int n)
{
    int low,high,temp;
    for(int i=1;i<n;i++)
    {
        temp=A[i];
        low=0;
        high=i-1;
        int mid;
        while(low<=high)
        {
            mid=(high+low)/2;
            if(A[mid]<temp)
                low=mid+1;
            else
                high=mid-1;
        }
        int j;
        for(j=i;j>low;j--)
            A[j]=A[j-1];
        A[low]=temp;
    }
}

希尔排序

算法思路：

先取一个正整数 d1(d1 < n)，把全部记录分成 d1 个组，所有距离为 d1 的倍数的记录看成一组，然后在各组内进行插入排序

然后取 d2(d2 < d1)

重复上述分组和排序操作；直到取 di = 1(i >= 1) 位置，即所有记录成为一个组，最后对这个组进行插入排序。一般选 d1 约为 n/2，d2 为 d1 /2， d3 为 d2/2 ，…， di = 1。
其中d1一般为n/2

还是以前面的序列为例

{ 6, 5, 3, 1, 8, 7, 2, 4 }

令d1=4

可以将上面分成四组{6,8}，{5,7}，{3,2}，{1,4}

然后进行插入排序{6,8}，{5,7}，{2,3}，{1,4}

第一趟结果{6,5,2,1,8,7,3,4}

d2=2

分成两组{6,2,8,3},{5,1,7,4}

第二趟{2,3,6,8},{1,4,5,7}

所以最终结果为{2,1,3,4,6,5,8,7}

d3=1

最终结果

{1,2,3,4,5,6,7,8}

void ShellSort(int A[],int n)
{
    int d1=n/2;
    int temp,j;
    while(d1>0)
    {
        //内部插入排序
        int num=n/d1;
        int p=0;
        while(p<num)
        {
            for(int i=d1;i<n;i+=d1)
            {
                temp=A[i];
                for(j=i-d1;j>=0;j-=d1)
                {
                    if(A[j]>temp)
                        A[j+d1]=A[j];
                    else
                        break;
                }
                A[j+d1]=temp;
            }
            p++;
        }
        d1=d1/2;
    }
}

归并排序

　　归并排序算法主要依赖归并(Merge)操作。归并操作指的是将两个已经排序的序列合并成一个序列的操作，归并操作步骤如下：

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针到达序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

{ 6, 5, 3, 1, 8, 7, 2, 4 }

L=4时，递归分组为{6,5,3,1},{8,7,2,4}

L=2时，递归分组为{6,5},{3,1},{8,7},{2,4}

L=1时，递归分组为{6},{5},{3},{1},{8},{7},{2},{4}.

合并

L=2 {5,6},{1,3},{7,8},{2,4}

L=4 {1,3,5,6},{2,4,7,8}

L=8 {1,2,3,4,5,6,7,8}

void Merge(int *a,int s,int m,int n)
{
    int *temp=new int[n];
    int i=s,q=s;
    int j=m+1;
    //将两个分组按顺序合并
    while(i<=m&&j<=n)
    {
        if(a[i]<a[j])
            temp[q++]=a[i++];
        else
            temp[q++]=a[j++];
    }

    while(i<=m)
        temp[q++]=a[i++];
    while(j<=n)
        temp[q++]=a[j++];
    for(int k=s;k<=n;k++)
        a[k]=temp[k];
    delete temp;
}

void MSort(int *a,int s,int t)
{
    int m;
    if(s==t)
        return;
    else
    {
        m=(s+t)/2;
        MSort(a,s,m);
        MSort(a,m+1,t);
        Merge(a,s,m,t);
    }
}

void MergeSort(int a[],int N)
{
    MSort(a,0,N-1);
}

堆排序

堆（二叉堆）可以视为一棵完全的二叉树，完全二叉树的一个“优秀”的性质是，除了最底层之外，每一层都是满的，这使得堆可以利用数组来表示（普通的一般的二叉树通常用链表作为基本容器表示），每一个结点对应数组中的一个元素。

将其用一个数组保存序列就是{80,60,70,50,40,30,20,10,1}
并且如果二叉树的序列是从0开始(对应数组下标从0开始)
则有叶子节点和根节点序列i的关系式为

• Leftchild=2i+1

• Rightchild=2i+2。
  堆排序分为两步

  1. 构建堆
  2. 调整堆

以序列{6,5,3,1,8,7,2,4}为例
构建堆的时候构建顺序是从下往上从右往左的进行。在构建过程中会破坏堆，这时候需要调整。调整的时候顺序是从上往下的。

//堆排序
void HeapAdjust(int A[],int s,int m)
{
    //保存根节点
    int temp=A[s];
    for(int j=2*s;j<=m;j=j+1)
    {
        //判断左子树右子树大小
        if(j<m&&A[j]<A[j+1])
            j++;
        //如果根节点较大，直接结束。
        if(temp>A[j])
            break;
        //重新调整子树
        A[s]=A[j];
        s=j;
    }
    A[s]=temp;
}

void HeapSort(int A[],int n)
{
    int temp;
    //构建堆
    for(int i=(n-1)/2;i>=0;i--)
        HeapAdjust(A,i,n-1);
    for(int j=n-1;j>0;j--)
    {
        //调整并构建堆
        temp=A[0];
        A[0]=A[j];
        A[j]=temp;
        HeapAdjust(A,0,j-1);
    }
}

快速排序

很经典，不多讲。

int Partition(int A[],int low,int high)
{
    int t=A[low];
    while(low<high)
    {
        while(A[high]>t&&low<high)
            high--;
        A[low]=A[high];
        while(A[low]<t&&low<high)
            low++;
        A[high]=A[low];
    }
    A[low]=t;
    return low;
}

void QuickSort(int A[],int low,int high)
{
    int i;
    if(low<high)
    {
        //求中枢
        i=Partition(A,low,high);
        QuickSort(A,low,i);
        QuickSort(A,i+1,high);
    }
}

int main()
{
    int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 };    // 从小到大冒泡排序
    int n = sizeof(A) / sizeof(int);
    QuickSort(A, 0,n-1);
    for(int i=0;i<n;i++)
        printf("%d ",A[i]);
    printf("\n");
    return 0;
}

参考资料

常用排序算法总结