常用排序方法

       排序根据分类可分为：插入排序，选择排序，交换排序，归并排序。

       其中，插入排序包含直接插入排序和希尔排序；选择排序包含选择排序和堆排序；交换排序包括冒泡排序和快速排序。

1.直接插入排序（时间复杂度：O(N*N)   空间复杂度：O(1)）

       当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与 array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。是一种稳定的排序方法。

void InsertSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		int tmp = a[i];
		int end = i - 1;
		while (end >= 0)//调整子序列
		{
			if (a[end] > tmp)//如果tmp<a[end]则插入并调整子序列
			{
				a[end + 1] = a[end];
				end -= 1;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

2.希尔排序

       先选定一个整数，把待排序文件中所有记录分成gap个组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工 作。当到达gap=1时，所有记录在统一组内排好序。其中gap的确定尤为重要，根据数据的不同取相应的gap，当gap越大，大的数与小的数移动地越快；当gap越小，移动地更慢，但更接近有序；当gap=1为插入排序。是一种不稳定的排序。

void ShellSort(int* a, int n)
{
	int gap = n;
	//for (int j = 0; j < gap; j++)
	while(gap>1)
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < n-gap; i+=gap)
		{
			int end = i;
			int tmp = a[end+gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

3.直接选择排序（时间复杂度：O(N*N) 空间复杂度：O(1) ）

       在数组中arr[i]~arr[n-i]选择最大/小的数据，与数组中第一个/最后一个进行交换，直到数组只剩一个数据。是一种不稳定的排序方法。

void SelectSort(int* a, int n)
{
	int max = 0;
	int maxj = 0;
	for (int i = 0; i < n-1; i++)
	{
		maxj = i;
		for (int j = i+1; j < n; j++)
		{
			if (a[j] < a[maxj])
			{
				maxj = j;
			}
		}
		if (maxj!=i)
		{
			int tmp = a[i];
			a[i] = a[maxj];
			a[maxj] = tmp;
		}
	}
}

4.堆排序（时间复杂度：O(N*logN) 空间复杂度：O(1)）

       堆排序是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是通过堆来进行选择数据。需要注意的是排升序要建大堆（树的任何一个父亲大于等于孩子），排降序建小堆（树的任何一个父亲小于等于孩子）。其中插入数据是先把数据放在末尾，然后头尾交换，然后根据向上或向下调整法进行调整堆。是一种不稳定的排序方法。

向下调整：前提：调整前根节点的左右子树必须为小堆或大堆。

                  调整思路：从根节点开始，选出左右孩子中值较小的孩子；让该孩子与其父亲进行比较，若孩子小于父亲，则孩子与父亲交换位置，并将孩子当成父亲继续向下调整。该大小比较取决于建堆。

向上调整：前提：堆尾插入数据后，仍然是个堆。

                  调整思路：将目标节点与其父亲节点比较；若目标节点的值小于父亲节点的值，则交换位置，并将原目标节点的父亲节点当做新节点就行进行向上调整。该大小比较取决于建堆。

void HeapSort(int* a, int n)
{
	// 建大堆 
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDwon(a, n, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		// 选出次大的
		AdjustDwon(a, end, 0);
		--end;
	}
}
//向下调整
void AdjustDwon(int* a, int n, int root)
{
	while (root < n)
	{
		int leftchild = root * 2 + 1;
		int rightchild = root * 2 + 2;
		if (a[leftchild]<a[rightchild])
		{
			if (a[rightchild] > a[root])
			{
				Swap(&a[rightchild], &a[root]);
			}
		}
		else if (a[leftchild] > a[rightchild])
		{
			if (a[leftchild] > a[root])
			{
				Swap(&a[leftchild], &a[root]);
			}
		}
		else
		{
			if (a[leftchild] > a[root])
			{
				Swap(&a[leftchild], &a[root]);
			}
		}
		root++;
	}
}

5.冒泡排序（时间复杂度：O(N*N) 空间复杂度：O(1)）

       遍历这个数组，如果遍历的过程发现相邻元素中，左边的数据大于右边的数据时，就交换这两个数据的位置。如果是左边的数据小于所等于右边的数据时，满足从小到大的顺序要求，数据位置维持不变。是一种稳定的排序方法。

void swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

// 冒泡排序
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n-1; i++)
	{
		for (int j = i + 1; j < n; j++)
		{
			if (a[i] < a[j])
			{
				swap(&a[i], &a[j]);
			}
		}
	}
}

6.快速排序（时间复杂度：O(n*logN) 空间复杂度：O(logN)）

       任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。是一种不稳定的排序方法。

        其中分为三种方法：hoare法，挖坑法，前后指针法。

                                      hoare法：将key设为最左边的数，左指针找比key大，右指针找比key小，先从右边开始，找到后交换，相遇时交换key。

                                      挖坑法：设最左边的数为坑，右指针走，找比坑小的，然后交换，坑变为右指针的数，左指针走，依次轮回，直到相遇。

                                       前后指针法：将key设为最左边的数，prev指针指向开头，cur指针指向prev指针的后一个位置，cur找到比key小的值，找到后，prev++后交换prev和cur的值。

// 快速排序hoare版本
int  PartSort1(int* a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		while (left<right&&a[right] >= a[keyi])
		{
			right--;
		}
		while (left<right&&a[left] <= a[keyi])
		{
			left++;
		}
		swap(&a[left], &a[right]);
	}
	swap(&a[keyi], &a[left]);
	keyi = left;
	return keyi;
}
// 快速排序挖坑法
int  PartSort2(int* a, int left, int right)
{
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole]=key;
	return hole;
}

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	int prev = left;
	int cur = prev + 1;
	int keyi = left;
	while (cur <= right)
	{
		if (a[cur] < a[keyi]&&++prev!=cur)
		{
			swap(&a[cur], &a[prev]);
			
		}
		++cur;
	}
	swap(&a[prev], &a[keyi]);
	keyi = prev;
	return keyi;
}

void QuickSort1(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int keyi = PartSort1(a, left, right);
	QuickSort1(a, left, keyi - 1);
	QuickSort1(a, keyi + 1, right);
}

void QuickSort2(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int keyi = PartSort2(a, left, right);
	QuickSort2(a, left, keyi - 1);
	QuickSort2(a, keyi + 1, right);
}

void QuickSort3(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int keyi = PartSort3(a, left, right);
	QuickSort3(a, left, keyi - 1);
	QuickSort3(a, keyi + 1, right);
}

7.归并排序（时间复杂度：O(N*logN) 空间复杂度：O(N))

       将待排序序列分成两个子序列，对这两个子序列进行递归排序,将两个排好序的子序列合并成一个有序的序列。是一种稳定的排序方法。

// 归并排序递归实现
void _MergeSort(int* a1, int begin, int end, int* a2)
{
	if (begin == end)
	{
		return;
	}
	int mid = (begin + end) / 2;
	_MergeSort(a1, begin, mid , a2);
	_MergeSort(a1, mid + 1, end, a2);
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a1[begin1] <= a1[begin2])
		{
			a2[i++] = a1[begin1++];
		}
		else
		{
			a2[i++] = a1[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		a2[i++] = a1[begin1++];
	}
	while (begin2 <= end2)
	{
		a2[i++] = a1[begin2++];
	}
	memcpy(a1 + begin, a2 + begin, sizeof(int) * (end - begin + 1));
}
void MergeSort(int* a, int n)
{
	int* tmp = new int[n];
	_MergeSort(a, 0, n - 1, tmp);
	delete[] tmp;
}
// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{
	int* a2 = new int[n];
	int gap = 1;
	while (gap < n)
	{
		int j = 0;
		for (int i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i+gap-1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			if (end1 >= n || begin2 >= n)
			{
				break;
			}
			if (end2 >= n)
			{
				end2 = n - 1;
			}
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] <= a[begin2])
				{
					a2[j++] = a[begin1++];
				}
				else
				{
					a2[j++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				a2[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				a2[j++] = a[begin2++];
			}
			memcpy(a + i, a2 + i, sizeof(int) * (end2 - i + 1));
			
		}
		gap *= 2;
	}
	delete[] a2;
}

8.计数排序

       找出数据中的最大值和最小值，根据其差值设定数组大小；然后遍历数组，根据其与最小值的差值在新数组对应位置的下标的数据++；最后根据新数组修改原数组。

void CountSort(int* a, int n)
{
	int max = a[0];
	int min = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	int* tmp = new int[max - min+1] {0};
	for (int i = 0; i < n; i++)
	{
		tmp[a[i] - min]++;
	}
	int j = 0;
	for (int i = 0; i < max-min+1; i++)
	{
		while (tmp[i]!=0)
		{
			a[j++] = i+min;
			--tmp[i];
		}
	}
	delete[] tmp;
}