冒泡排序-快速排序-堆排序-二路归并排序-多路归并排序-希尔排序-插入排序-二分插入排序----C++代码实现，若有需要自取

把常用的几种排序总结了一下，还有几个非计数排序还没弄，有时间再给贴上来。
有的是模板，有的不是，懒得弄，结构都一样。

#include <iostream>
#include <vector>
using namespace std;

template<typename elemType>
void Sort(vector<elemType>& vec,int n)//冒泡
{
	for (int m; 1 < n; n = m)//重置n，从而使内部循环不会遍历到后面已经有序的部分
	{
		for (int i = m = 1; i < n; i++)
		{
			if (vec[i - 1] > vec[i])
			{
				swap(vec[i - 1], vec[i]);
				m = i;//更新待排序区间
			}
		}
	}
}

template<typename elemType>
int quick(vector<elemType>& vec, int low, int height)//快速排序
{
	int temp = vec[low];
	while (low < height)
	{
		while (low < height && vec[height] >= temp) --height;
		vec[low] = vec[height];
		while (low < height && vec[low] < temp) ++low;
		vec[height] = vec[low];
	}
	vec[low] = temp;
	return low;
}

template<typename elemType>
void quickSort(vector<elemType>& vec, int low, int height)//快速排序
{
	if (low < height)
	{
		int mid = quick(vec, low, height);
		quickSort(vec, low, mid - 1);
		quickSort(vec, mid + 1, height);
	}
}

void insertSort(vector<int>& vec, int i, int j)//插入排序
{
	
	unsigned int m,n;
	for (m = 1; m < vec.size(); ++m)
	{
		int temp = vec[m];
		if (temp < vec[m - 1])
		{
			for (n = m - 1; vec[n] > temp; --n)
				vec[n + 1] = vec[n];
			vec[n + 1] = temp;
		}
	}
}

void insertSort_1(vector<int>& vec)//二分插入排序
{
	unsigned int i;
	int j;
	for (i = 1; i < vec.size(); ++i)
	{
		int temp = vec[i];
		int left = 0, right = i - 1;
		while (left <= right)
		{
			int mid = (left + right) >> 1;
			if (vec[mid] > temp) right = mid - 1;
			if (vec[mid] < temp) left = mid + 1;
		}
		for (j = i - 1; j >= right; --j)
			vec[j + 1] = vec[j];
		vec[right + 1] = temp;
	}
}

void shellSort(vector<int>& vec, int n)//希尔排序
{
	unsigned int i, j;
	for (i = n + 1; i < vec.size(); ++i)
	{
		if (vec[i] < vec[i - n])
		{
			int temp = vec[i];
			for (j = i - 1; j > 0 && (temp < vec[j]); j = j - n)
				vec[j + n] = vec[j];
			vec[j + n] = temp;
		}
	}
}
void shellSort_1(vector<int>& vec, int a[], int t)//希尔排序
{
	for (int i = 0; i < t; i++)
		shellSort(vec, a[i]);
}

void selectSort(vector<int>& vec)//简单选择排序
{
	for (size_t i = 0; i < vec.size(); ++i)
	{
		size_t temp = i;
		for (size_t j = i + 1; j < vec.size(); ++j)
		{
			if (vec[j] < vec[i])
				temp = j;//最小值的秩
		}
		swap(vec[i], vec[temp]);
	}
}

void heapify(vector<int>& vec, int index, int len)//堆建立
{
	int left = 2 * index;
	int right = 2 * index + 1;
	int maxindex = index;
	if ((left < len) && (vec[maxindex] < vec[left]))
		maxindex = left;
	if ((right < len) && (vec[maxindex] < vec[right]))
		maxindex = right;
	if (maxindex != index)
	{
		swap(vec[maxindex], vec[index]);
		heapify(vec, maxindex, len);
	}

}
void heapSort(vector<int>& vec, int size)//堆排序
{
	for (int i = size / 2 - 1; i >= 0; --i)
		heapify(vec, i, size);
	for (int i = size - 1; i >= 1; --i)
	{
		swap(vec[0], vec[i]);
		heapify(vec, 0, i);
	}
}

void Merge(int* A, int* L, int leftCount, int* R, int rightCount) //二路归并排序
{
	int i, j, k;


	i = 0; j = 0; k = 0;

	while (i < leftCount && j < rightCount) {
		if (L[i] < R[j]) A[k++] = L[i++];
		else A[k++] = R[j++];
	}
	while (i < leftCount) A[k++] = L[i++];
	while (j < rightCount) A[k++] = R[j++];
}
void MergeSort(int* A, int n) //二路归并排序
{
	int mid, i, * L, * R;
	if (n < 2) return; 

	mid = n / 2;
	L = new int[mid];
	R = new int[n - mid];

	for (i = 0; i < mid; i++) 
		L[i] = A[i]; 
	for (i = mid; i < n; i++) 
		R[i - mid] = A[i]; 

	MergeSort(L, mid); 
	MergeSort(R, n - mid); 
	Merge(A, L, mid, R, n - mid);  
	delete[] R;
	delete[] L;
}
//多路归并排序简单，不再描述

int main()
{
	int b[3] = { 5,3,1 };
	int a[8] = { 1,5,4,3,6,7,8,9 };
	vector<int> vec(a,a+8);
	//Sort(vec, 8);
	//quickSort(vec, 0, 7);
	//insertSort_1(vec);
	//shellSort_1(vec, b, 3);
	//heapSort(vec,8);
	//selectSort(vec);
	MergeSort(a,8);
	for (int i = 0;i < 8;++i)
		cout <<a[i] << endl;
	system("pause");
	return 0;
}

我是_Pico