八大排序的实现——学习笔记

八大排序代码实现

前言

个人学习记录，都是经典的算法，网上也有很多介绍，就没有写每个排序算法的实现逻辑了，尽量写的简洁明了，欢迎指正。

辅助算法

数据交换

void swap(int &x1, int &x2) {
	int temp = x1;
	x1 = x2;
	x2 = temp;
}

快速排序

用的多路快排，有兴趣可以自行了解。

void FastSort(vector<int> &nums, int start, int end) {
	if (start + 1 < end) {
		int key = nums[start];
		int i = start + 1;
		int j = start;
		int k = end;

		while (i < k) {
			if (nums[i] < key) {
				swap(nums[i++], nums[j++]);
			}
			else if (nums[i] > key) {
				swap(nums[i], nums[--k]);
			}
			else {
				++i;
			}
		}

		FastSort(nums, start, j);
		FastSort(nums, k, end);
	}
}

归并排序

void Merge(vector<int> &nums, int start, int mid, int end) {
	int i = start;
	int j = start;
	int k = mid;

	vector<int> temp(nums);

	while (j < mid&&k < end) {
		if (nums[j] < nums[k]) {
			temp[i++] = nums[j++];
		}
		else {
			temp[i++] = nums[k++];
		}
	}

	while (j < mid)
		temp[i++] = nums[j++];
	while (k < end)
		temp[i++] = nums[k++];

	nums = temp;
}

void MergeSort(vector<int> &nums,int start,int end) {
	if (start + 1 < end) {
		int mid = (start + end) / 2;
		MergeSort(nums, start, mid);
		MergeSort(nums, mid, end);
		Merge(nums, start, mid, end);
	}
}

冒泡排序

void BubbleSort(vector<int> &nums) {
	for (int i = 1; i < (int)nums.size(); ++i) {
		for (int j = 0; j < (int)nums.size() - i; ++j) {
			if (nums[j] > nums[j + 1]) {
				swap(nums[j], nums[j + 1]);
			}
		}
	}
}

插入排序

void InsertSort(vector<int> &nums) {
	for (int i = 0; i < (int)nums.size(); ++i) {
		for (int j = i; j > 0 && nums[j] < nums[j - 1]; --j) {
			swap(nums[j - 1], nums[j]);
		}
	}
}

希尔排序

void ShellSort(vector<int> &nums) {
	int index = nums.size() / 2;

	while (index > 0) {
		for (int i = 0; i < index; ++i) {
			for (int j = i; j < (int)nums.size(); j += index) {
				for (int k = j; k - index >= 0 && nums[k] < nums[k - index]; k -= index) {
					swap(nums[k], nums[k - index]);
				}
			}
		}
		index /= 2;
	}
}

选择排序

void SelectionSort(vector<int> &nums) {
	for (int i = 0; i < (int)nums.size(); ++i) {
		int min = i;
		for (int j = i + 1; j < nums.size(); ++j) {
			if (nums[min] > nums[j]) {
				min = j;
			}
		}

		swap(nums[i], nums[min]);
	}
}

基数排序

void RadixSort(vector<int> &nums) {
	int gap = 1;
	vector<vector<int>> tun(1, nums);

	do {
		vector<vector<int>> temp(10);
		for (int i = 0; i < tun.size(); ++i) {
			for (int j = 0; j < tun[i].size(); ++j) {
				int index = (tun[i][j] / gap) % 10;
				temp[index].push_back(tun[i][j]);
			}
		}

		tun = temp;
		gap *= 10;
	} while (tun[0].size() < nums.size());

	nums = tun[0];
}

堆排序

void MaxHeap(vector<int> &nums, int start,int end) {
	int i = start * 2 + 1;
	if (i < end) {
		if (i + 1 < end && nums[i] < nums[i + 1]) {
			++i;
		}

		if (nums[start] < nums[i]) {
			swap(nums[start], nums[i]);
			MaxHeap(nums, i, end);
		}
	}
}

void HeapSort(vector<int> &nums) {
	for (int i = nums.size() / 2 - 1; i >= 0; --i) {
		MaxHeap(nums, i, nums.size());
	}

	for (int i = 1; i < nums.size(); ++i) {
		swap(nums[0], nums[nums.size() - i]);
		MaxHeap(nums, 0, nums.size() - i);
	}
}