Eight achieve the sort of - study notes

Eight sort code implementation

Foreword

Personal learning record, is the classic algorithm, there are many online introduction, there is no writing implement logic for each sorting algorithm, and try to write clear and concise, please correct me.

Aided algorithm

Data Exchange

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

Quick Sort

With multiple fast row you are interested can inform themselves about.

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);
	}
}

Merge sort

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);
	}
}

Bubble Sort

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]);
			}
		}
	}
}

Insertion Sort

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]);
		}
	}
}

Shell sort

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;
	}
}

Selection Sort

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]);
	}
}

Radix Sort

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];
}

Heapsort

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);
	}
}