各种排序

/***********************
*输入：待排数组vector<int>
*输出：排好的序列
***********************/
#include <iostream>
#include <vector>
using namespace std;
/******简单排序********
*时间复杂度：
	平均：O(n^2)
	最坏：O(n^2)
	最好：O(n^2)
*空间复杂度：O(1)
*稳定性：稳定排序
*********************/
void SimpleSort(vector<int> &v, int length)
{
	for (int i = 0; i < length; i++)
	{
		for (int j = i + 1; j < length; j++)
		{
			if (v[j] < v[i])
			{
				int temp = v[i];
				v[i] = v[j];
				v[j] = temp;
			}
		}
	}
}
/******冒泡排序********
*时间复杂度：
	平均：O(n^2)
	最坏：O(n^2)
	最好：O(n)
*空间复杂度：O(1)
*稳定性：稳定排序
*********************/
void BubbleSort(vector<int> &v, int length)
{
	bool mark = true;
	for (int i = 1; i < length && mark; i++)
	{
		mark = false;//若无数据交换，结束循环
		for (int j = length - 1; j >= i; j--)
		{
			if (v[j] < v[j - 1])
			{
				int temp = v[j - 1];
				v[j - 1] = v[j];
				v[j] = temp;
				mark = true;
			}
		}
	}
}
/******快速排序********
*时间复杂度：
平均：O(nlogn)
最坏：O(n^2)
最好：O(nlogn)
*空间复杂度：O(logn)~O(n)
*稳定性：不稳定排序
*********************/
int Partition(vector<int> &v, int low, int high)
{
	int pivot = v[low]
	while (low < high)
	{
		while (low < high&&v[high] >= pivot)
			high--;
		v[low] = v[high];
		while (low < high&&v[low] <= pivot)
			low++;
		v[high] = v[low];
	}
	v[low] = pivot;
	return low;
}
void QSort(vector<int> &v, int low, int high)
{
	if (low < high)
	{
		int pivot = Partition(v, low, high);
		QSort(v, low, pivot - 1);
		QSort(v, pivot + 1, high);
	}
}
void QuickSort(vector<int> &v, int length)
{
	QSort(v, 0, length - 1);
}
/******插入排序********
*时间复杂度：
	平均：O(n^2)
	最坏：O(n^2)
	最好：O(n)
*空间复杂度：O(1)
*稳定性：稳定排序
*********************/
void InsertSort(vector<int> &v, int length)
{
	for (int i = 1; i < length; i++)
	{
		if (v[i] < v[i - 1])
		{
			int guard = v[i];
			int j = i - 1;
			while (j >= 0 && v[j] > guard)//j>=0要先判断
			{
				v[j + 1] = v[j];
				j--;
			}
			v[j + 1] = guard;
		}
	}
}
/******希尔排序********
*时间复杂度：
	平均：O(nlogn)~O(n^2)
	最坏：O(n^2)
	最好：O(n^1.3)
*空间复杂度：O(1)
*稳定性：不稳定排序
*********************/
void ShellSort(vector<int> &v, int length)
{
	int increment = length;
	do
	{
		increment = increment / 3 + 1;
		for (int i = increment; i < length; i++)
		{
			if (v[i] < v[i - increment])
			{
				int guard = v[i];
				int j = i - increment;
				for (; j >= 0 && guard < v[j]; j -= increment)
					v[j + increment] = v[j];
				v[j + increment] = guard;
			}
		}
	} while (increment > 1);
}
/******选择排序********
*时间复杂度：
平均：O(n^2)
最坏：O(n^2)
最好：O(n^2)
*空间复杂度：O(1)
*稳定性：不稳定排序
*********************/
void SelectSort(vector<int> &v, int length)
{
	for (int i = 0; i < length - 1; i++)
	{
		int min = i;//找到最小的放在i处
		for (int j = i + 1; j < length; j++)
		{
			if (v[min]>v[j])
				min = j;
		}
		if (i != min)
		{
			int temp = v[i];
			v[i] = v[min];
			v[min] = temp;
		}
	}
}
/******堆排序排序********
*时间复杂度：
	平均：O(nlogn)
	最坏：O(nlogn)
	最好：O(nlogn)
*空间复杂度：O(1)
*稳定性：不稳定排序
*********************/
void HeapAdjust(vector<int> &v, int s, int m)
{
	//v[s...m]除v[s]外满足大顶堆定义
	int temp = v[s];
	for (int j = 2*s+1; j <= m; j = 2*j+1)
	{
		if (j < m && v[j] < v[j+1])
			++j;//选择大的那个孩子（左孩子2*s，右孩子2*s+1)
		if (temp >= v[j])
			break;
		v[s] = v[j];
		s = j;
	}
	v[s] = temp;
}
void HeapSort(vector<int> &v, int length)
{
	//构建最大堆
	for (int i = length / 2 - 1; i >= 0; i--)//i都是有孩子的节点
		HeapAdjust(v, i, length-1);
	//把最大值v[0]放在末尾，重新构建v[0...i-1]
	for (int i = length - 1; i>0; i--)
	{
		int temp = v[i];
		v[i] = v[0];
		v[0] = temp;
		HeapAdjust(v, 0, i - 1);
	}
}
/******归并排序********
*时间复杂度：
	平均：O(nlogn)
	最坏：O(nlogn)
	最好：O(nlogn)
*空间复杂度：O(n)
*稳定性：不稳定排序
*********************/
//将va[i...j]和va[j+1...k]合并到va[i...k]
void Merge(vector<int> &va, int i, int j, int k)
{
	vector<int> temp;
	int ia = i, ib = j + 1;
	while ((ia <= j) && (ib <= k))
	{
		if (va[ia] < va[ib])
		{
			temp.push_back(va[ia]);
			ia++;
		}
		else
		{
			temp.push_back(va[ib]);
			ib++;
		}
	}
	for (int m = ia; m <= j; m++)
		temp.push_back(va[m]);
	for (int m = ib; m <= k; m++)
		temp.push_back(va[m]);
	for (int m = i; m <= k; m++)
		va[m] = temp[m - i];
}
void MergeSort(vector<int> &va, int length)
{
	int k = 1;
	while (k < length)
	{
		int n = length / (2 * k);//需要至少划分多少区间
		bool mark = false;//是否有残留区间
		if (length % (2 * k) == 0)
			mark = true;
		for (int i = 0; i < n; i++)//对每个区间进行合并
		{
			int d = i * 2 * k;
			Merge(va, d, d + k - 1, d + 2 * k - 1);
		}
		if (!mark)//处理残留区间
		{
			int diff = length - 2 * k*n;
			if (diff > k)//是否大于半个区间
			{
				int d = n * 2 * k;
				Merge(va, d, d + k - 1, length - 1);
			}
		}
		k *= 2;
	}

}
/***********主函数***********************/
void Check(vector<int> &a)
{
	for (unsigned i = 0; i < a.size(); i++)
		cout << a[i] << " ";
	cout << endl;
}
int main()
{
	int init[] = { 1, 3, 6, 8, 0, 3, 6, 5, 8, 1, 0, 2 };
	vector<int> vForSort(init, init + 12);
	cout << "待排序数组：" << endl;
	Check(vForSort);
	//SimpleSort(vForSort, vForSort.size());
	//BubbleSort(vForSort, vForSort.size());
	QuickSort(vForSort, vForSort.size());
	//InsertSort(vForSort, vForSort.size());
	//ShellSort(vForSort, vForSort.size());
	//SelectSort(vForSort, vForSort.size());
	//HeapSort(vForSort, vForSort.size());
	//MergeSort(vForSort, vForSort.size());
	cout << "排序后数组：" << endl;
	Check(vForSort);
	return 0;
}