leetcode排序

排序算法分为内部排序与外部排序，前者是数据量少，后者是数据量大。

主要的十种排序算法：
按照算法时间复杂度来
$O(n^2)$:冒泡排序，选择排序，插入排序
$O(n\ast log$_2$n)$:希尔排序，归并排序，快速排序，堆排序
$O(n)$:计数排序，桶排序，基数排序

class solution {
public:
	vector<int> bubblesorted(vector<int>&nums) {
		for (int i = 0;i < nums.size();i++) {
			for (int j = 0 ;j < nums.size() - i - 1;j++) {//先加再比较
				if (nums[j] > nums[j+1]) {
					int tmp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = tmp;
				}
			}
		}
		return nums;
	}
};

vector<int> selectsorted(vector<int>&nums) {
		for (int i = 0;i < nums.size()-1;i++) {
			int min_i = i;
			for (int j = i + 1;j < nums.size();j++) {//先加再比较
				if (nums[j] < nums[i]) {
					min_i = j;
				}
			}
			if (min_i != i)
			{
				int tmp = nums[i];
				nums[i] = nums[min_i];
				nums[min_i] = tmp;
			}
		}
		return nums;
	}

vector<int> insertsorted(vector<int>&nums) {
		for (int i = 1;i < nums.size() ;i++) {
			int value = nums[i];
			int position = i;
			while (position > 0&& value < nums[position-1]) {
				nums[position] = nums[position - 1];
				position--;
			}
			nums[position] = value;
		}
		return nums;
	}

vector<int> shellsorted(vector<int>&nums) {
		int length = nums.size();
		for (int gap = length / 2;gap > 0;gap /= 2) 
			for (int i = gap;i < length;i++)
				for (int j = i-gap;j>=0;j -=gap)//当gap为1时，i与j嵌套类比于插入排序
					if (nums[j] > nums[j+ gap]) {
						int tmp = nums[j + gap];
						nums[j + gap] = nums[j];
						nums[j] = tmp;
					}
		return nums;
	}

vector<int> mergesorted(vector<int>&nums) {
		if (nums.empty()) return {};
		int length = nums.size();
		vector<int>tmp(length);
		sort(nums, 0, length - 1,tmp);
		
		return nums;
	}
private: //使得以下方法只能在当前类内进行使用
	void sort(vector<int>&nums,int begin,int end, vector<int>&tmp) {
		//int length = nums.size();
		if (begin < end) {//这个能够使得在递归正常进行
			int mid = (begin + end) / 2;
			sort(nums, begin, mid, tmp);
			sort(nums, mid + 1, end, tmp);
			merge(nums, begin, mid, end, tmp);
		}	
		//return nums;
	}
	void merge(vector<int>&nums, int begin,int mid, int end, vector<int>&tmp) {
		//int length = nums.size();
		int i = begin;//the subscript of left array
		int j = mid + 1;//the subscript of right array
		int position = 0;
		while (i <= mid &&j <= end)
		{
			if (nums[i] > nums[j])
				tmp[position++] = nums[j++];//tmp[position],position+1
			else
				tmp[position++] = nums[i++];
		}
		while (i <= mid)
			tmp[position++] = nums[i++];
		while (j <= end)
			tmp[position++] = nums[j++];
		position = 0;
		while (begin <= end)
			nums[begin++] = tmp[position++];

	}

	void quick(vector<int>&nums, int begin, int end) {
		if (begin >= end) return;
		int tmp = nums[begin];
		int left = begin + 1;
		int right = end;
		while (left < right)
		{
			while (nums[left] <= tmp && left < right) left++;
			while (nums[right] >= tmp && left < right) right--;
			if(right > left){
				int t = nums[left];
				nums[left] = nums[right];
				nums[right] = t;
			}
		}
		if (nums[begin] <= nums[left])			
			left--;//这一步不能忽视，可能存在这个数大于基准的情况，所以需要将left前一个数据与基准相交换位置，因为这个数据肯定小于基准
		nums[begin] = nums[left];
		nums[left] = tmp;
		quick(nums, begin, left - 1);
		quick(nums, left + 1, end);
	}