排序学习

分治：把一个任务，分成形式和原任务相同，但规模更小的几个部分任务，分别完成。

归并排序

数组排序任务可如下完成：

1. 把前一半排序
2. 把后一半排序
3. 把两个归并到一个新的有序数组，然后再拷贝回原数组

#include<iostream>

using namespace std;

void Merge(int a[], int s, int m, int e, int tmp[]) {
	int pb = 0;
	int p1 = s, p2 = m + 1;
	while (p1 <= m && p2 <= e) {
		if (a[p1] < a[p2]) {
			tmp[pb++] = a[p1++];
		}
		else {
			tmp[pb++] = a[p2++];
		}
	}
	while (p1 <= m)
		tmp[pb++] = a[p1++];
	while (p2 <= e)
		tmp[pb++] = a[p2++];
	for (int i = 0; i < e - s + 1; i++) {
		a[s + i] = tmp[i];
	}
}

void MergeSort(int a[], int s, int e, int tmp[]) {
	if (s < e) {
		int m = s + (e - s) / 2;
		MergeSort(a, s, m, tmp);
		MergeSort(a, m + 1, e, tmp);
		Merge(a, s, m, e, tmp);
	}
}

int a[10] = { 13,27,19,2,8,12,2,30,89 };
int b[10];

int main()
{
	int size = sizeof(a) / sizeof(int);
	MergeSort(a, 0, size - 1, b);
	for (int i = 0; i < size; i++) {
		cout << a[i] << " ";
	}
	cout << endl;
	return 0;
}

归并排序的时间复杂度

快速排序

数组排序任务可以如下完成：

1. 设k=a[0]，将k挪到适当位置，使得比k小的元素都在k左边，比k大的元素都在k右边，和k相等的，不关心，在k左右出现均可（O(n)时间完成）
2. 把k左边的部分快速排序
3. 把k右边的部分快速排序

#include<iostream>
using namespace std;

void swap(int &a, int &b)
{
	int tmp=a;
	a=b;
	b=tmp;
}

void QuickSort(int a[], int s, int e)
{
	if(s>=e)
		return;
	int k=a[s];
	int i=s,j=e;
	while(i!=j){
		while(j>i&&a[j]>=k)
			j--;
		swap(a[i], a[j]);
		while(j>i&&a[i]<=k)
			i++;
		swap(a[i], a[j]);
	}	// 处理完后 a[i]=k
	QuickSort(a,s,i-1);
	QuickSort(a,i+1,e);
}

int a[] = {93,27,30,2,8,12,2,8,30,89};
int main()
{
	int size = sizeof(a)/sizeof(int);
	QuickSort(a,0,size-1);
	for(int i=0;i<size;i++)
		cout<<a[i]<<",";
	cout<<endl;
	return 0;
}

选择排序

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

int* selectionSort(int* A, int n) {
        // write code here
        int min=0;
        int j;
        for(int i=0;i<n;i++)
        {
            min=i;
            for(j=i+1;j<n;j++)
            {
                if(A[j]<A[min])
                {
                    min=j;
                }
            }
            if(min!=i)
            {
                int temp=A[min];
                A[min]=A[i];
                A[i]=temp;
            }
        }
        return A;
    }

无论如何，T=O(N²)

堆排序

堆排序是对选择排序的一种改进

在堆排序中，元素下标从0开始。则对于下标为i的元素，其左、右孩子的下标分别为：2i+1，2i+2。’

堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

堆排序的基本思想：将排序序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的节点，将其与末尾元素交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

建立大根堆：从最后一个非叶子结点开始，从左至右，从下至上进行调整。
对于这个非叶子节点 i，它的子节点分别是i2+1、i2+2，将它的两个子节点中较大的与之交换。

for (int i = len / 2 - 1; i >= 0; i--) {
	max_heapify(arr, i, len - 1);
}

void max_heapify(int arr[], int start, int end)
{
	//建立父节点指标和子节点指标
	int parent = start;
	int child = parent * 2 + 1;
	while(child<=end)	//若子节点指标在范围内才做比较
	{
		if(child+1<=end&&arr[child]<arr[child+1])	//先比较两个子节点大小，选择最大的
			child++;
		if(arr[parent] > arr[child])	//如果父节点大于子节点代表调整完毕，直接跳出函数
			return;
		else{	//否则交换父子内容再继续子节点和孙节点比较
			swap(arr[parent], arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
	}
}

堆排序：

void swap(int* a, int* b) {
    int temp = *b;
    *b = *a;
    *a = temp;
}

void max_heapify(int arr[], int start, int end)
{
	//建立父节点指标和子节点指标
	int parent = start;
	int child = parent * 2 + 1;
	while(child<=end)	//若子节点指标在范围内才做比较
	{
		if(child+1<=end&&arr[child]<arr[child+1])	//先比较两个子节点大小，选择最大的
			child++;
		if(arr[parent] > arr[child])	//如果父节点大于子节点代表调整完毕，直接跳出函数
			return;
		else{	//否则交换父子内容再继续子节点和孙节点比较
			swap(arr[parent], arr[child]);
			parent = child;
			child = parent * 2 + 1;
		}
	}
}

void heap_sort(int arr[], int len) 
{
	for(int i=len/2-1;i>=0;i--){
		max_heapify(arr, i, len-1);
	}
	for(int i=len-1;i>0;i--){
		swap(arr[0], arr[i]);
		max_heapify(arr, 0, i-1);
	}
}

核心思想是将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序。
桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了。

如果要排序的数据有 n 个，我们把它们均匀地划分到 m 个桶内，每个桶里就有 k=n/m 个元素。每个桶内部使用快速排序，时间复杂度为 O(k * logk)。m 个桶排序的时间复杂度就是 O(m * k * logk)，因为 k=n/m，所以整个桶排序的时间复杂度就是 O(n*log(n/m))。当桶的个数 m 接近数据个数 n 时，log(n/m) 就是一个非常小的常量，这个时候桶排序的时间复杂度接近 O(n)。

桶排序对要排序数据的要求是非常苛刻的：首先，要排序的数据需要很容易就能划分成 m
个桶，并且，桶与桶之间有着天然的大小顺序。这样每个桶内的数据都排序完之后，桶与桶之间的数据不需要再进行排序。
其次，数据在各个桶之间的分布是比较均匀的。如果数据经过桶的划分之后，有些桶里的数据非常多，有些非常少，很不平均，那桶内数据排序的时间复杂度就不是常量级了。在极端情况下，如果数据都被划分到一个桶里，那就退化为O(nlogn) 的排序算法了。

插入排序

直接插入排序：每次从无序表中取出最后一个元素，把它插入到有序表的合适位置，使有序表仍然有序。

希尔排序

希尔排序是插入排序的一种算法，希尔排序是非稳定排序算法。

void ShellSort(int A[], int x)
{
	int Si, D, P, i;
	int tmp;
	int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};

}