排序算法讲解2021-02-18

插入排序：

直接插入排序

void Insert_sort(int *a,int len)
{
    int now=1;
    while(now<len)
    {
        int tmp=a[now],i;
        for(i=now-1;i>=0;i--)
        {
            if(a[i]<=tmp)
            {
                a[i+1]=tmp;
                break;
            }
            a[i+1]=a[i];
        }
        if(i<0)
            a[0]=tmp;
        now++;
    }
}

希尔排序：

 希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因 D.L.Shell 于 1959 年提出而得名。

希尔排序的时间的时间复杂度为o（n的三分之二次方 )，希尔排序时间复杂度的下界是n*log2n。希尔排序没有快速排序算法快 O(n(logn))，因此中等大小规模表现良好，对规模非常大的数据排序不是最优选择。但是比O(n的平方 )复杂度的算法快得多。

 

 

插入排序在对一个有序的序列进行排序是时间复杂度为o（n）。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

1. 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。

2. 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

原理：对于n个待排序的数列，取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列，所有距离为gap的倍数的记录放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是有序的。然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。

void shell_sort(int *a, int len)
{
    for(int gap=len/2;gap>0;gap/=2)//gap为步长每次减为原来的一半。
    {
        //共gap个组，对每一组都执行直接插入排序
        for(int i=0;i<gap;i++)
        {
            int now=i+gap;
            while(now<len)
            {
                int tmp=a[now],j;
                for(j=now-gap;j>=0;j-=gap)
                {
                    if(a[j]<=tmp)
                    {
                        a[j+gap]=tmp;
                        break;
                    }
                    a[j+gap]=a[j];
                }
                if(j<0)
                    a[j+gap]=tmp;
                now+=gap;
            }
        }
    }
}

堆排序：

https://www.cnblogs.com/chengxiao/p/6129630.html

#include <bits/stdc++.h>

using namespace std;

int a[100005];

// 递归方式构建大根堆(len是arr的长度，index是第一个非叶子节点的下标)
void adjust(int a[], int len, int index)
{
    int left=2*index+1; // index的左子节点
    int right=2*index+2;// index的右子节点
    int maxIdx = index;
    if(left<len&&a[left]>a[maxIdx])
        maxIdx=left;
    if(right<len&&a[right]>a[maxIdx])
        maxIdx = right;
    if(maxIdx!=index)
    {
        swap(a[maxIdx], a[index]);
        adjust(a, len, maxIdx);
    }
}

// 堆排序
void heapSort(int a[], int len)
{
    // 构建大根堆（从最后一个非叶子节点向上）
    for(int i=len/2-1;i>=0;i--)
        adjust(a,len,i);
    // 调整大根堆
    for(int i=len-1;i>=1;i--)
    {
        swap(a[0], a[i]);           // 将当前最大的放置到数组末尾
        adjust(a, i, 0);              // 将未完成排序的部分继续进行堆排序
    }
}

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    heapSort(a,n);
    for(int i=0;i<n;i++)
        cout<<a[i]<<endl;
    return 0;
}

归并排序

https://www.cnblogs.com/chengxiao/p/6194356.html

#include <bits/stdc++.h>

using namespace std;

int a[100005],tmp[100005];

void Merge(int a[],int l,int r)
{
    for(int i=l;i<=r;i++)
        tmp[i]=a[i];
    int mid=(l+r)/2;
    int i=l,j=mid+1;
    for(int pos=l;pos<=r;pos++)
    {
        if (i==mid+1)
        {
            a[pos]=tmp[j];
            j++;
        }
        else if(j==r+1)
        {
            a[pos]=tmp[i];
            i++;
        }
        else if(tmp[i]>tmp[j])
        {
            a[pos]=tmp[j];
            j++;
        }
        else
        {
            a[pos]=tmp[i];
            i++;
        }
    }
}

void merge_sort(int a[],int l,int r)
{
    if (l==r)
        return;
    int mid=(l+r)/2;
    merge_sort(a,l,mid);
    merge_sort(a,mid+1,r);
    Merge(a,l,r);
}

int main()
{
    int n;
    scanf("%d",&n);
    for (int i=0;i<n;i++)
        scanf("%d",&a[i]);
    merge_sort(a,0,n-1);
    for(int i=0;i<n;i++)
        printf("%d%c",a[i],i==n-1?'\n':' ');
    return 0;
}