十大排序

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

vector<vector<int>> test_dat = {
	{ 9, 9, 2, 41, 4, 6, 7, 4, 1, 0 },
	{123, 3213, 412, 4, 456, 6, 113, 87, 85},
	{1, 3, 4, 5, 6, 12, 12, 34, 100},
	{12, 65, 65, 12,95, 78, 13, 52, 53},
	{98, 72, 85, 654, 83, 16, 48, 45, 43, 76, 214}
};

//======================================= 插入类排序 =============================

void insertSort(vector<int> &a) {
	int  n = a.size();

	for (int i = 1; i < n; ++i) {
		int j = 0;
		for (; j < i; ++j) {
			if (a[i] < a[j]) {
				break;
			}
		}
		if (j != i) {
			int k = a[i];
			for (int l = i; l > j; --l) {
				a[l] = a[l - 1];
			}
			a[j] = k;
		}
	}
}

//折半查找
void insertSort2(vector<int> &a) {
	int  n = a.size();

	for (int i = 1; i < n; ++i) {
		int j = 0;
		int begin = 0, end = i - 1, mid = begin + (end - begin) / 2;
		while (end > begin)
		{
			if (end - begin == 1)
				break;

			if (a[i] < a[mid]) {
				end = mid;
			}
			else {
				begin = mid;
			}
			mid = begin + (end - begin) / 2;
		}

		if (a[i] >= a[end]) {
			j = end + 1;
		}
		else if (a[i] < a[begin]) {
			j = begin;
		}
		else if (a[i] < a[end]) {
			j = end;
		}
			
		if (j != i) {
			int k = a[i];
			for (int l = i; l > j; --l) {
				a[l] = a[l - 1];
			}
			a[j] = k;
		}
	}
}

//希尔排序
void shell(vector<int> &a) {
	int gap = a.size() / 2;
	int n = a.size();

	while (gap >= 1) {

		for (int i = gap; i < n; i = i + gap ) {
			int temp = a[i];
			int j = i;
			while (j - gap >= 0 && temp < a[j - gap]) {
				a[j] = a[j - gap];
				j = j - gap;
			}
			a[j] = temp;
		}
		gap = gap / 2;
	}
}
//============================================================================================


//======================================= 交换类排序 ========================================

//冒泡排序
void bubble(vector<int> &a) {
	int flag = 0, n = a.size();
	for (int i = 0; i < n; ++i) {
		for (int j = n - 1; j > i; j--) {
			if (a[j] < a[j - 1]) {
				int temp = a[j];
				a[j] = a[j - 1];
				a[j - 1] = temp;
				flag = 1;
			}
		}
		if (flag == 0) break;
	}
}

//快速排序
void quick_sort(vector<int> &a, int begin, int end) {
	int x = a[begin];
	int i = begin, j = end;
	while (j > i) {

		while (j > i && a[j] >= x) j--;
		if (j > i) {
			int temp = a[i]; a[i++] = a[j]; a[j] = temp;
		}

		while (j > i && a[i] <= x) i++;
		if (j > i) {
			int temp = a[j]; a[j--] = a[i]; a[i] = temp;
		}
	}
	a[i] = x;
	if(i - 1 > begin) quick_sort(a, begin, i - 1);
	if(i + 1 < end) quick_sort(a, i + 1, end);
}

//=================================== 交换类排序 ==============================

void chooseSort(vector<int> &a) {
	int n = a.size();

	for (int i = 0; i < n; ++i) {
		int min = i;
		for (int j = i + 1; j < n; ++j) {
			if (a[j] < a[min]) {
				min = j;
			}
		}
		if (min != i) {
			int temp = a[i]; a[i] = a[min]; a[min] = temp;
		}
	}
}

void heapSort(vector<int> &a) {
	int n = a.size();
	int p = n / 2 - 1, index = n - 1;
	while (p > 0) {
		for (int i = p; i >= 0; --i) {
			if (2 * i + 1 <= index && a[i] < a[2 * i + 1]) {
				int temp = a[2 * i + 1]; a[2 * i + 1] = a[i]; a[i] = temp;
			}

			if (2 * i + 2 <= index && a[i] < a[2 * i + 2]) {
				int temp = a[2 * i + 2]; a[2 * i + 2] = a[i]; a[i] = temp;
			}
		}
		p = index / 2 - 1;
		int temp = a[0]; a[0] = a[index]; a[index--] = temp;
	}
}

//=================================== 基数排序 
void bucketSort(vector<int> &a) {
	vector<int> bucket[10];
	int n = a.size();
	int flag = 0, dev = 1;

	do
	{
		flag = 0;
		//入桶
		for (int i = 0; i < n; i++) {
			if (a[i] >= dev) {
				bucket[ a[i] / dev % 10 ].push_back(a[i]);
				flag = 1;
			}
			else {
				bucket[0].push_back(a[i]);
			}
		}
		//出桶
		int k = 0;
		for (int i = 0; i < 10; ++i) {
			for (int j = 0; j < bucket[i].size(); ++j) {
				a[k++] = bucket[i][j];
			}
			bucket[i].clear();
		}

		dev = dev * 10;
	} while (flag);
}


//归并排序
void mergeSort(vector<int> &nums, int begin, int end) {
	if (end <= begin)
		return;

	int mid = begin + (end - begin) / 2;
	mergeSort(nums,begin, mid);
	mergeSort(nums, mid + 1, end);

	vector<int> temps(end - begin + 1);
	int i = begin, j = mid + 1, p = 0;
	
	while (i <= mid && j <= end){
		temps[p++] = nums[i] < nums[j] ? nums[i++] : nums[j++];
	}

	while(i <= mid) {
		temps[p++] = nums[i++];
	}
	while(j <= end) {
		temps[p++] = nums[j++];
	}
	p = 0;
	for (int i = begin; i <= end; ++i) {
		nums[i] = temps[p++];
	}
}

vector<int> sortArray(vector<int>& nums) {
	mergeSort(nums, 0, nums.size() -1);

	return nums;
}
//============================归并 end =====================

void print_vec(vector<int> &a) {
	for (int i = 0; i < a.size(); ++i) {
		cout << a[i] << " " << ends;
	}
	cout << endl;
}

void test_sort() {
	for (int i = 0; i < test_dat.size(); ++i) {
		//insertSort2(test_dat[i]);
		//shell(test_dat[i]);
		//bubble(test_dat[i]);
		//quick_sort(test_dat[i], 0, test_dat[i].size() - 1);
		//chooseSort(test_dat[i]);
		//heapSort(test_dat[i]);
		bucketSort(test_dat[i]);
		print_vec(test_dat[i]);
	}

	return;
}