八大排序自写C++代码集合

#include<iostream>
#include<stack>

using namespace std;

//main/
int main()
{
	int A[] = { 5, 7, 2, 3, 1, 8, 4, 9, 6, 0 };
	int length = sizeof(A) / sizeof(A[0]);
	//InsertSort(A,length};
	//ShellSort(A, length);
	//SelectSort(A, length);
	//HeapSort(A, length);
	//BubbleSort(A, length);
	//QuickSort1(A, 0, length - 1);
	//MergeSort(A, length);
	RadixSort(A, length);
	for (auto v : A){
		cout << v << ends;
	}
}


//1、InsertSort插入排序///
template<typename T>
void InsertSort(T* array, int len)
{
	for (int i = 1; i <= len - 1; i++){
		T temp = array[i];
		int j = i - 1;
		while (j >= 0 && array[j] > temp){
			array[j + 1] = array[j];
			j--;
		}
		array[j + 1] = temp;

	}
}

//2、ShellSort希尔排序///
template<typename T>
void ShellSort(T* array, int length)//误写为引用
{
	for (int gap = length >> 1; gap > 0; gap >>= 1){
		for (int i = gap; i < length; i++){
			T temp = array[i];
			int j = i;
			while (temp <array[j - gap] && j >= gap){//是否加等号要看清，考虑清楚
				array[j] = array[j - gap];
				j -= gap;
			}
			array[j] = temp;
		}
	}
}

//3、SeleceSort直接排序//
//template<typename T>
//void SelectSort(T* array, int length){
//	for (int i = 0; i < length - 1; i++){//最后一位不用比较，所以没有等号
//		T temp = array[i];
//		int index = i;
//		for (int j = i + 1; j < length ; j++){ //智障，<length,或者<=length-1
//			if (array[j]<temp){
//				index = j;
//				temp = array[j];
//			}
//		}
//		swap(array[i], array[index]);
//	}
//}

//改进如下
template<typename T>
void SelectSort(T* array, int length){
	for (int i = 0; i < length - 1; i++){//最后一位不用比较，所以没有等号
		int index = i;
		for (int j = i + 1; j < length; j++){ //智障，<length,或者<=length-1
			if (array[j]<array[index]){
				index = j;              //只记最小的小标
			}
		}
		swap(array[i], array[index]);
	}
}

//4、StackSort最大堆排序///
template<typename T>
void MaxHeap(T*array, int dad,int length)
{
	int sonl = 2 * dad + 1;
	int sonr = 2 * dad + 2;
	int temp = sonl;
	if (array[sonl] < array[sonr] && sonr < length){
		temp = sonr;
	}
	if (temp>length - 1||array[dad]>array[temp]){
		return;
	}
	else{
		swap(array[dad], array[temp]);
		MaxHeap(array, temp, length);
	}
}

template<typename T>
void HeapSort(T*array, int length)
{
	for (int i = length / 2 - 1; i >= 0; i--){
		MaxHeap(array, i, length);   //构建堆时从最后一个节点开始
	}
	for (int j = length-1; j > 0; j--){
		swap(array[0], array[j]);
		MaxHeap(array, 0,j);     //排好序的堆从0下标开始
	}
}

//5、冒泡排序BubbleSort
//template<typename T>
//void BubbleSort(T*array, int length)//智障，你写成选择排序了
//{
//	for (int i = length-1; i >0; i--){
//		int index=i;
//		for (int j = 0; j < i; j++){
//			if (array[j] > array[index]){
//				index = j;
//			}
//		}
//		swap(array[index], array[i]);
//	}
//}

template<typename T>
void BubbleSort(T*array, int length)
{
	for (int i = 0; i <length; i++){
		for (int j = 0; j < length-1-i; j++){
			if (array[j] > array[j+1]){
				swap(array[j], array[j + 1]);
			}
		}
	}
}

//6、QuickSort快速排序///
template<typename T>
void QuickSort(T*array, int left,int right)
{
	if (right <= left){
		return;
	}
	int pivot = left + rand() % (right - left + 1);
    //int pivot = (left+right)/2;
	swap(array[pivot], array[right]);
	int index = left;
	for (int i = left; i < right; i++){
		if (array[i] < array[right]){
			if (i != index){
				swap(array[i], array[index]);
			}
			index++;  //写在括号外面，不能误写在里面
		}
	}
	swap(array[index], array[right]);
	QuickSort(array, left,index - 1);
	QuickSort(array,index+1, right);//index如果不加1会陷入循环无法跳出
}

template<typename T>
void QuickSort1(T*array, int left, int right)
{
	if (right <= left){
		return;
	}
	T povit = array[left];
	int j = right;
	int i = left + 1; 
	while (i < j){
		while (array[i] < povit){
			i++;
		}
		while (array[j] >= povit){
			j--;
		}
		if (i < j){
			swap(array[i], array[j]);
		}
	}
	if (array[i] < povit){
		swap(array[i], array[left]);
	}
	else{
		i--;
		swap(array[i], array[left]);
	}
	QuickSort1(array, left, i - 1);
	QuickSort(array, i + 1, right);
}

//7、MergeSort归并排序///
template<typename T>
void MergeSort(T*array, int length)
{
	T*reg = (T*)malloc(sizeof(T)*length);
	MergeSortRecursive(array, reg, 0, length - 1);
}

template<typename T>
void MergeSortRecursive(T*array, T*reg, int left, int right)
{
	if (left >= right){
		return;
	}
	int mid = left + ((right - left) >> 1);
	MergeSortRecursive(array, reg, left, mid);
	MergeSortRecursive(array, reg, mid + 1, right);
	Merge(array, reg, left, mid, right);
}

template<typename T>
void Merge(T*array, T*reg, int left, int mid, int right)
{
	int leftTop = left, leftEnd = mid;
	int rightTop = mid + 1,rightEnd = right;
	int k = left;

	while (leftTop <= leftEnd&&rightTop <= rightEnd)
		//下面这句实在是太妙了，两个有序队列的排序，赞
		reg[k++] = array[leftTop] < array[rightTop] ? array[leftTop++] : array[rightTop++];
	while (leftTop <= leftEnd)
		reg[k++] = array[leftTop++];
	while (rightTop <= rightEnd)
		reg[k++] = array[rightTop++];
	for (int i = left; i <= right; i++)
		array[i] = reg[i];
}

//8、RadixSort基数排序/
template<typename T>
void RadixSort(T*array, int length)
{
	int max = GetMax(array, length);

	for (int e = 1; max / e > 0; e *= 10)
		RadixSortsub(array, length, e);
}

template<typename T>
int GetMax(T*array, int length)
{
	int temp = array[0];
	for (int i = 0; i < length; i++){
		if (array[i]>temp)
			temp = array[i];
	}
	return temp;
}

template<typename T>
void RadixSortsub(T*array, int length, int e)
{
	T*output = (T*)malloc(sizeof(T)*length);
	int bucket[10] = { 0 };
	for (int i = 0; i < length; i++){
		bucket[(array[i]/e)%10]++;
	}
	for (int i = 1; i < 10; i++){
		bucket[i] += bucket[i - 1];
	}
	for (int i = length-1; i >=0; i--){//因为要保持原来的次序不变，所以是倒着
		output[--bucket[(array[i] / e)%10]] = array[i];//非常巧妙的设计
	}
	for (int i = 0; i < length; i++){
		array[i] = bucket[i];
	}
}