Ocho lograr el tipo de - notas de estudio

Ocho especie implementación del código

prefacio

registro personal de aprendizaje, es el algoritmo clásico, hay muchos introducción en línea, no hay ningún instrumento de escritura lógica para cada algoritmo de ordenación, y tratar de escribir claro y conciso, por favor, corríjanme.

Asistido por el algoritmo

Intercambio de datos

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

Ordenación rápida

Con la fila rápida múltiple está interesado puede informarse sobre.

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

Combinar especie

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

Ordenar burbuja

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

Ordenar la inserción

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

la ordenación Shell

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

selección Ordenar

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