c++实现常见排序算法

#include<iostream>
using namespace std;
#if 1
void InsertSort(int* array, int size) {
	for (int i = 1;i < size;++i) {
		int key = array[i];
		int end = i - 1;
		while (end >= 0&&key < array[end]) {
			array[end + 1] = array[end];
			end--;
			
		}
		array[end + 1] = key;
	}
}
#endif

#if 0
void ShellSort(int* array, int size) {
	
		int gap = 3;
		while (gap) {
			for (int i = gap;i < size;++i) {
				int key = array[i];
				int end = i - gap;
				while (end >= 0 && key < array[end]) {
					array[end + gap] = array[end];
					end = end - gap;

				}
				array[end + gap] = key;
			}
			gap--;
		}
} 
#endif
#if 0
void SelectSort(int* array, int size) {
	for (int j = 0;j < size - 1;++j) {
		int MaxPos = 0;
		for (int i = 0;i < size - j;++i) {
			if (array[i] > array[MaxPos]) {
				MaxPos = i;
			}
		}
		if (MaxPos != size - 1 - j) {
			swap(array[MaxPos], array[size - 1 - j]);
		}
	}
	
}
#endif
#if 0
void SelectSortOP(int* array, int size) {
	int begin = 0;
	int end = size - 1;
	while (begin < end) {
		int MaxPos = begin;
		int MinPos = begin;
		int index = begin + 1;
		while (index <=end) {
			if (array[index] > array[MaxPos]) {
				MaxPos = index;
			}
			if (array[index] < array[MinPos]) {
				MinPos = index;
			}
			index++;
		}
		if (MinPos == end) {
			MinPos = MaxPos;
		}
		
		if (MaxPos != end) {
			swap(array[MaxPos], array[end]);
		}
		
		if (MinPos != begin) {
			swap(array[MinPos], array[begin]);
		}
		begin++;
		end--;
		
	}
}
#endif
//优化快排 为了避免所取基准值为最小或最大情况 采用三数取中法得基准值
//当区间元素比较少时用插入排序
int GetMidIndex(int* array, int left, int right) {
	int mid = left + ((right - left) >> 1);
	if (array[left] < array[right]) {
		if (array[mid] < array[left]) {
			return left;
		}
		else if (mid > array[right]) {
			return right;
		}
		else {
			return mid;
		}
	}
	else {
		if (array[mid] < array[right]) {
			return right;
		}
		else if (array[mid] > array[left]) {
			return left;

		}
		else {
			return mid;
		}
	}

}
int Partion1(int* array, int left, int right) {
	int begin = left;
	int end = right - 1;
	int key = array[right - 1];
	//begin从前往后找比基准值大的元素
	while(begin<end){
		while (begin < end && array[begin] <= key) 
			begin++;
	//end从后往前找比基准值小的元素
		while (begin < end && array[end] >= key) 
			end--;
		
		
		if (begin != end) {
			swap(array[begin], array[end]);

		}
		
	}
	if (begin != right - 1) {
		swap(array[begin], array[right - 1]);
	}
	
	return begin;
	

}
//挖坑法
int Partion2(int* array, int left, int right) {
	int begin = 0;
	int end = right - 1;
	int key = array[end];
	//begin从前往后找到基准值的值则填坑
	while (begin < end) {
		while (begin < end&&array[begin] <= key) {
			begin++;
		}
		if (begin < end) {
			swap(array[begin], array[end]);
			end--;
		}
		//end从后找到比基准值的值则填上一个坑
		while (begin < end&&array[end] >= key) {
			end--;
		}
		if (begin < end) {
			swap(array[end], array[begin]);
			begin++;
		}
	}
	array[begin] = key;
	return begin;

}
//前后指针
int Partion3(int* array, int left, int right) {
	int cur = left;
	int pre = left - 1;
	int key = array[right - 1];
	int mid = GetMidIndex(array, left, right);
	swap(key, array[mid]);
	while (cur < right) {
		if (array[cur] < key&&cur != ++pre) {
			swap(array[cur], array[pre]);
		}
		cur++;
	}
	++pre;
	swap(array[pre], array[right - 1]);
	return pre;
}


void QuickSort(int* array, int left, int right) {

	/*if (right - left > 1) {
		int div = Partion3(array, left, right);
		QuickSort(array, left, div);
		QuickSort(array, div + 1, right);
	}*/
	if (right - left <16) {
		InsertSort(array, right - left);
		
	}
	else {
		int div = Partion3(array, left, right);
		QuickSort(array, left, div);
		QuickSort(array, div + 1, right);

	}

}
//循环快排
#include<stack>
void QuickSortNor(int* array, int size) {
	int left = 0;
	int right = size;
	stack<int> s;
	s.push(right);
	s.push(left);
	while (!s.empty()) {
		left = s.top();
		s.pop();
		right = s.top();
		s.pop();
		if (right - left > 1) {
			int mid = Partion1(array, left, right);
			s.push(right);
			s.push(mid + 1);
			s.push(mid);
			s.push(left);
		}
	}
}
//归并排序
void MergeData(int* array, int left, int mid, int right, int* temp) {
	int begin1 = left, end1 = mid;
	int begin2 = mid, end2 = right;
	int index = left;
	while (begin1 < end1&&begin2 < end2) {
		if (array[begin1] <= array[begin2]) {
			temp[index++] = array[begin1++];
		}
		else {
			temp[index++] = array[begin2++];
		}
		while (begin1 < end1) {
			temp[index++] = array[begin1++];
		}
		while (begin2 < end2) {
			temp[index++] = array[begin2++];
		}
	}
}
void _MergeSort(int* array, int left, int right, int* temp) {
	if (right - left> 1) {
		int mid = left + ((right - left) >> 1);
		_MergeSort(array, left, mid, temp);
		_MergeSort(array, mid, right, temp);
		MergeData(array, left, mid, right, temp);
		memcmp(array + left, temp + left, (right - left) * sizeof(array[0]));
	}
}
void MergeSort(int* array, int size) {
	int* temp = new int[size];
	_MergeSort(array, 0, size, temp);
	delete[] temp;
}



#if 0


void HeapAdjust(int* array, int size, int parent)
{
	int child = parent * 2 + 1;
	while (child < size)
	{
		// 找左右孩子中较大的孩子
		if (child+1 < size && array[child+1] > array[child])
		{
			child += 1;
		}

		if (array[parent] < array[child])
		{
			swap(array[parent], array[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			return;
	}
}
// 堆排序
void HeapSort(int* array, int size)
{
	// 1. 创建堆---向下调整
	//    升序---->大堆   降序---小堆

	// 找倒数第一个非叶子节点
	int root = ((size - 2) >> 1);
	for (; root >= 0; --root)
		HeapAdjust(array, size, root);

	// 2. 堆删除的思想---向下调整
	int end = size - 1;
	while (end)
	{
		swap(array[0], array[end]);
		HeapAdjust(array, end, 0);
		--end;
	}
}