排序算法

1.冒泡排序法
如图所示：相邻两位相互比较。
时间复杂度：
最好情况，本身是有序的，O(n)。
最坏情况，本身是逆序的，O(n^2)。
平均情况：O(n^2)

void bubble(vector<int> &data)
{
    if (data.size() == 0)
        return;
    int len = data.size();
    for (int i = 1; i < len; i++)
    {
        for (int j = 0; j<len-i; j++)
        {
            //if (data[j] < data[j+1]) //从大到小排序
            if (data[j] >data[j+1])//从小到大排序
            {
                swap(data[j], data[j+1]);
            }
        }
    }
}
//由于2 1 3 4 5 6，当第一次排序后，1 2 3 4 5 6已经不需要再次排序，所以进行优化。
void bubble_1(vector<int> &data)
{
    if (data.size() == 0)
        return;
    int len = data.size();
    bool flag=true;
    for (int i = 1; i < len && flag ; i++)
    {
        flag=false;
        for (int j = 0; j<len-i; j++)
        {
            //if (data[j] < data[j+1]) //从大到小排序
            if (data[j] >data[j+1])//从小到大排序
            {
                swap(data[j], data[j+1]);
                flag=true;
            }
        }
    }
}

int main()
{
    vector<int> data = { 1,2,6,5,3,4,7 ,0};
    bubble(data);
    for (auto i : data)
        cout << i << " ";
    system("pause");
    return 0;
}

2.选择排序法
通过n-i-1次关键字间的比较，选出关键字最小的记录，并和第i（0<=i<=n-1）个记录交换。
时间复杂度：
最好情况=最坏情况=平均情况：O(n^2)
性能略优于冒泡排序法，主要体现在交换数据次数少。

void select(vector<int> &data)
{
    if (data.size() == 0)
        return;
    int len = data.size();
    for (int i = 0; i < len-1; i++)
    {
        int min = i;
        for (int j = i+1; j<len; j++)
        {
            if (data[min] > data[j])
            {
                min = j;
            }
        }
        if(i!=min)
            swap(data[i],data[min]);
    }
}

3.直接插入排序法
从第一个元素开始，该元素可以认为已被排序；取出下一个元素，在已经排序的元素序列中从后向前扫描；如果该元素（已排序）大于新元素，将该元素移到下一个位置；重复，直到找到已排序的元素小于或者等于新元素的位置；将新元素插入到该位置后，重复。
时间复杂度：
最好情况，本身是有序的，O(n)。
最坏情况，本身是逆序的，O(n^2)。
平均情况：O(n^2)
略优于冒泡排序法和选择排序法。

void insert(vector<int> &data)
{
    if (data.size() == 0)
        return;
    int len = data.size();
    for (int i = 1; i < len; i++)//n-1次，从1开始
    {
        int temp = data[i];
        int j = i - 1;
        for (; j>=0 && temp<data[j]; j--)//向右移动，直到不符合条件，或者到了0位置
        {
            data[j + 1] = data[j];
        }
        data[j + 1] = temp;
    }
}

4.希尔排序法
也称为递减增量排序算法，是对直接插入排序法的改进。
改进:1.插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；2.但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位。
希尔排序的一般步骤为：
1.先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中，在各组内进行直接插人排序。
2.取第二个增量d2>d1重复上述的分组和排序，直至所取的增量dt=1(dt< dt-l< …< d2< d1)，即所有记录放在同一组中进行直接插入排序为止。
步长的选择是希尔排序的重要部分。只要最终步长为1任何步长串行都可以工作。算法最开始以一定的步长进行排序。然后会继续以一定步长进行排序，最终算法以步长为1进行排序。当步长为1时，算法变为插入排序，这就保证了数据一定会被排序。
时间复杂度为：希尔排序时间复杂度平均为O(NlogN)，增量序列的最后一个增量必须等于1.

void shell(vector<int> &data)
{
    if (data.size() == 0)
        return;
    int len = data.size();
    for (int gap = 3; gap > 0; gap--)
    {
        for (int i = 0; i < gap; i++)
        {
            for (int j = i + gap; j < len; j = j + gap)
            {
                if (data[j] <data[j - gap])
                {
                    int temp =data[j];
                    int k = j - gap;
                    while (k >= 0 && data[k]>temp)
                    {
                        data[k + gap] = data[k];
                        k = k - gap;
                    }
                    data[k + gap] = temp;
                }
            }
        }
    }
}

5.堆排序法
引用于：https://blog.youkuaiyun.com/lzuacm/article/details/52853194
堆排序是基于完全二叉树的排序方法，其中心思想是首先构造最大堆（或最小堆），即父节点总是大于其子节点，然后将堆化的数组a[0]与a[i]交换，即将最大数置于i位置，再将0—i的继续堆化，重新选出最大的数于a[0]，完成第一个排序。
堆排序的基本思想是利用heap这种数据结构(可看成一个完全二叉树)，使在排序中比较的次数明显减少。
时间复杂度：
最好情况=最坏情况=平均情况：O(n*log(n))。
堆排序的关键在于建堆和调整堆，下面简单介绍一下建堆的过程：
第1趟将索引0至n-1处的全部数据建大顶(或小顶)堆，就可以选出这组数据的最大值(或最小值)。将该堆的根节点与这组数据的最后一个节点交换，就使的这组数据中最大(最小)值排在了最后。
第2趟将索引0至n-2处的全部数据建大顶(或小顶)堆，就可以选出这组数据的最大值(或最小值)。将该堆的根节点与这组数据的倒数第二个节点交换，就使的这组数据中最大(最小)值排在了倒数第2位。
…
第k趟将索引0至n-k处的全部数据建大顶(或小顶)堆，就可以选出这组数据的最大值(或最小值)。将该堆的根节点与这组数据的倒数第k个节点交换，就使的这组数据中最大(最小)值排在了倒数第k位。
其实整个堆排序过程中, 我们只需重复做两件事：
建堆(初始化+调整堆, 时间复杂度为O(n));
拿堆的根节点和最后一个节点交换(siftdown, 时间复杂度为O(n*log n) ).
因而堆排序整体的时间复杂度为O(n*log n).
下面通过一组数据说明堆排序的方法：
9, 79, 46, 30, 58, 49
1: 先将待排序的数视作完全二叉树(按层次遍历顺序进行编号, 从0开始)，如下图:

2：完全二叉树的最后一个非叶子节点，也就是最后一个节点的父节点。最后一个节点的索引为数组长度len-1，那么最后一个非叶子节点的索引应该是为(len-1)/2.也就是从索引为2的节点开始，如果其子节点的值大于其本身的值。则把他和较大子节点进行交换，即将索引2处节点和索引5处元素交换。交换后的结果如图：

3：向前处理前一个节点，也就是处理索引为1的节点，此时79>30,79>58,因此无需交换。
4：向前处理前一个节点，也就是处理索引为0的节点，此时9 < 79,9 < 49, 因此需交换。应该拿索引为0的节点与索引为1的节点交换，因为79>49. 如图:

5：如果某个节点和它的某个子节点交换后，该子节点又有子节点，系统还需要再次对该子节点进行判断。如上图因为1处，3处，4处中，1处的值大于3,4出的值，所以还需交换。

将每次堆排序得到的最大元素与当前规模的数组最后一个元素交换。

void adjust(vector<int> &data, int len, int index)
{
    //int len = data.size();
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    int maxindex = index;
    if (left<len && data[left]>data[maxindex])
        maxindex = left;
    if (right<len && data[right]>data[maxindex])
        maxindex = right;
    if (maxindex != index)
    {
        swap(data[maxindex], data[index]);
        adjust(data, len,maxindex);
    }
}

void heap_sort(vector<int> &data)
{
    if (data.size() == 0)
        return;
    int len = data.size();
    for (int i = len / 2 - 1; i >= 0; i--)
    {
        adjust(data,len, i);
    }
    for (int i = len - 1; i >= 1; i--)
    {
        swap(data[0], data[i]);
        adjust(data,i, 0);
    }

}

6.归并排序法
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用，归并排序将两个已经有序的序列合并成一个有序的序列。
时间复杂度：最坏情况=最好情况=平均情况=O(nlogn)
思路：假设我们有一个没有排好序的序列，那么我们首先使用分割的方法将这个序列分割成一个个已经排好序的子序列（当一个序列只有一个元素时，该序列自然是有序的）。然后再利用归并的方法将一个个有序的子序列合并成排好序的序列。

void merge(vector<int> &data, int l1, int r1, int l2, int r2)
{
    int i = l1, j = l2;
    int n = (r1 - l1 + 1) + (r2 - l2 + 1);
    vector<int>temp(n);
    int k = 0;
    while (i <= r1 && j <= r2)
    {
        if (data[i] < data[j])
            temp[k++] = data[i++];
        else
            temp[k++] = data[j++];
    }
    while (i <= r1)
        temp[k++] = data[i++];
    while (j <= r2)
        temp[k++] = data[j++];
    for (int i = 0; i < n; i++)
        data[l1 + i] = temp[i];
}

void mergesort(vector<int> &data,int start,int end)
{
    if (start < end)
    {
        int mid = (start + end) >> 1;
        mergesort(data, start, mid);
        mergesort(data, mid + 1, end);
        merge(data, start, mid, mid + 1, end);
    }
}

7.快速排序法
快速排序法的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，可以达到整个序列的有序目的。
时间复杂度：
最好情况，parttion每次划分的很均匀，O(nlogn)。
最坏情况，本身是正序或逆序的，O(n^2)。
平均情况：O(nlogn)

步骤：

vector<int> data={50,10,90,30,70,40,80,60,20};
1:p0                      p1
  50,10,90,30,70,40,80,60,20
关键字key=data[p0]
data[p1]<=key  则：swap(data[p1],data[p0]);
2:p0                      p1
  20,10,90,30,70,40,80,60,50
data[p0]<=key  则：++p0;
3:   p0                   p1
  20,10,90,30,70,40,80,60,50
data[p0]<=key  则：++p0;
4:      p0                p1
  20,10,90,30,70,40,80,60,50
data[p0]>=key  则：swap(data[p1],data[p0]);
5:      p0                p1
  20,10,50,30,70,40,80,60,90
data[p1]>=key  则：--p1;
6:      p0       p1     
  20,10,50,30,70,40,80,60,90
data[p1]<=key  则：swap(data[p1],data[p0]);
7:      p0       p1     
  20,10,40,30,70,50,80,60,90
data[p0]<=key  则：++p0;
7:            p0 p1     
  20,10,40,30,70,50,80,60,90
data[p0]>=key  则：swap(data[p1],data[p0]);
8:            p0 p1     
  20,10,40,30,50,70,80,60,90
data[p1]>=key  则：--p1;
p1==p0；
小于key   key  大于key
迭代左右，得到全排。

int  partition(vector<int> &data, int low, int high)
{
    int pivotkey = data[low];
    while (low < high)
    {
        while (low < high && data[high] >= pivotkey)
            high--;
        swap(data[low], data[high]);
        while (low < high && data[low] <= pivotkey)
            low++;
        swap(data[low], data[high]);
    }
    return low;

}

void fastsort(vector<int> &data,int start,int end)
{
    int pivot;
    if (start < end)
    {
        pivot = partition(data, start, end);
        fastsort(data, start, pivot - 1);
        fastsort(data, pivot + 1, end);
    }
}

总结：

由于快速排序法关键字的比较和交换是跳跃进行的，因此是不稳定的。
由于堆排序记录的比较和交换是跳跃式进行的，不是稳定的。
由于希尔排序记录是跳跃式进行的，不是稳定的。