一些排序算法

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

//快速排序，最好和平均情况：nlog(n),最坏情况：n^2
void quicksort(vector<int>& arr, int l, int r){
	if (l >= r) return;
	int i = l, j = r;
	while (i < j) {
		while (i < j && arr[j] >= arr[l]) --j;
		while (i < j && arr[i] <= arr[l]) ++i;
		swap(arr[i], arr[j]);
	}
	swap(arr[i], arr[l]);
	quicksort(arr, l, i - 1);
	quicksort(arr, i + 1, r);
}

void quick_sort(vector<int>& arr, int l, int r) {
	if (l >= r) return;
	int i = l, j = r;
	while (i < j) {
		while (i < j && arr[j] >= arr[l]) j--;
		while (i < j && arr[i] > arr[l]) i++;
		swap(arr[i], arr[j]);
	}
	swap(arr[i], arr[l]);
	quick_sort(arr, l, i - 1);
	quick_sort(arr, i + 1, r);
}

void test02() {
	vector<vector<int>> res = { { 2, 5, 7, 4 } ,{0,2,3,6} ,{0,0,0,2,0,5}, {0,0,2,3,2,1,1,2,0,4}, {0}, {3, 6, 8, 10, 1, 2, 1}, {5, 4, 3, 2, 1}, {1, 7, 3, 9, 2, 8, 6, 4, 5}, {9, 8, 7, 6, 5, 4, 3, 2, 1} };
	for (auto& arr : res) {
		quick_sort(arr, 0, arr.size() - 1);
		for (auto num : arr) {
			cout << num << " ";
		}
		cout << endl;
	}
}


//冒泡排序，无论什么情况都是n^2
vector<int> bubblesort(vector<int> arr)
{
	int lenth = arr.size();
	for (int i = 0; i < lenth; i++)
	{
		for (int j = 0; j < lenth - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(arr[j], arr[j + 1]);
			}
		}
	}
	return arr;
}

vector<int> bubblesort1(vector<int> arr) {
	for (int i = 0; i < arr.size(); ++i) {
		for (int j = 0; j < arr.size() - i - 1; ++j) {
			if (arr[j] > arr[j + 1]) swap(arr[j], arr[j + 1]);
		}
	}
	return arr;
}

//插入排序，不太熟练
vector<int> insertionsort(vector<int> arr){
	for (int i = 1; i < arr.size(); i++){
		int key = arr[i], j = i - 1;
		while (j >= 0 && key < arr[j]){
			arr[j + 1] = arr[j];
			j--;
		}
		arr[j + 1] = key;
	}
	return arr;
}

vector<int> insertionsort1(vector<int> arr) {
	for (int i = 1; i < arr.size(); ++i) {
		int key = arr[i], j = i - 1;
		while (j >= 0 && arr[j] > key) {
			arr[j + 1] = arr[j];
			j--;
		}
		j++;
		arr[j] = key;
	}
	return arr;
}

//选择排序，不太熟练
vector<int> SelectionSort(vector<int> arr) {
	for (int i = 0; i < arr.size(); ++i) {
		int min_index = i;
		for (int j = i; j < arr.size(); ++j) {
			if (arr[j] < arr[min_index]) min_index = j;
		}
		swap(arr[min_index], arr[i]);
	}
	return arr;
}

vector<int> SelectionSort1(vector<int> arr) {
	for (int i = 0; i < arr.size(); ++i) {
		int min_index = i;
		for (int j = i + 1; j < arr.size(); ++j) {
			if (arr[j] < arr[min_index]) min_index = j;
		}
		swap(arr[min_index], arr[i]);
	}
	return arr;
}

//归并排序，不太熟练
void merge_sort_(int l, int r, vector<int>& arr, vector<int>& tmp) {
	if (l >= r) return;
	int m = l + (r - l) / 2;
	int i = l, j = m + 1;
	merge_sort_(l, m, arr, tmp);
	merge_sort_(m + 1, r, arr, tmp);
	for (int k = l; k <= r; ++k) tmp[k] = arr[k];
	for (int k = l; k <= r; ++k) {
		if (i == m + 1) arr[k] = tmp[j++];
		else if (j == r + 1 || tmp[i] < tmp[j]) arr[k] = tmp[i++];
		else arr[k] = tmp[j++];
	}
}

vector<int> merge_sort(vector<int> arr) {
	vector<int> tmp(arr.size());
	merge_sort_(0, arr.size() - 1, arr, tmp);
	return arr;
}

void merge_sort_1(int l, int r, vector<int>& arr, vector<int>& tmp) {
	if (l >= r) return;
	int m = l + (r - l) / 2;
	int i = l, j = m + 1;
	merge_sort_1(l, m, arr, tmp);
	merge_sort_1(m + 1, r, arr, tmp);
	for (int k = l; k <= r; ++k) tmp[k] = arr[k];
	for (int k = l; k <= r; ++k) {
		if (i == m + 1) arr[k] = tmp[j++];
		else if (j == r + 1 || tmp[i] <= tmp[j]) arr[k] = tmp[i++];
		else arr[k] = tmp[j++];
	}
}

vector<int> merge_sort1(vector<int>& arr) {
	vector<int> tmp(arr.size());
	merge_sort_1(0, arr.size() - 1, arr, tmp);
	return arr;
}

//堆排序，不太熟练
void Heapify(vector<int>& arr, int n, int i){
	int left = i * 2 + 1, right = i * 2 + 2;
	int maxIndex = i;
	if (left < n && arr[left] > arr[maxIndex]) maxIndex = left;
	if (right < n && arr[right] > arr[maxIndex]) maxIndex = right;
	if (maxIndex != i) {
		swap(arr[i], arr[maxIndex]);
		Heapify(arr, n, maxIndex);
	}
}

vector<int> HeapSort(vector<int> arr){
	for (int i = arr.size() - 1; i >= 0; i--) {
		Heapify(arr, arr.size(), i);
	}
	for (int i = arr.size() - 1; i >= 0; i--) {
		swap(arr[i], arr[0]);
		Heapify(arr, i, 0);
	}
	return arr;
}

void Heapify1(vector<int>& arr, int n, int i) {
	int left = 2 * i + 1, right = 2 * i + 2;
	int max_index = i;
	if (left < n && arr[left] > arr[max_index]) max_index = left;
	if (right < n && arr[right] > arr[max_index]) max_index = right;
	if (max_index != i) {
		swap(arr[i], arr[max_index]);
		Heapify1(arr, n, max_index);
	}
}

vector<int> HeapSort1(vector<int>& arr) {
	int n = arr.size() - 1;
	for (int i = n; i >= 0; --i) Heapify1(arr, n + 1, i);
	for (int i = n; i >= 0; --i) {
		swap(arr[i], arr[0]);
		Heapify1(arr, i, 0);
	}
	return arr;
}



//全排序算法：
void qun() {
	vector<int> nums = { 1, 2, 3, 4 };
	do {
		cout << "-----------";
		for (int num : nums)
			cout << num << " ";
		cout << endl;
	} while (next_permutation(nums.begin(), nums.end()));
	cout << endl;
	return;
}

//测试案例
void testsort(vector<int> arr)
{
	arr = HeapSort1(arr);
	std::cout << "Sorted array: ";
	for (int i = 0; i < arr.size(); i++)
		std::cout << arr[i] << " ";
	std::cout << std::endl;
}



int main() 
{

	vector<vector<int>> arrs = { { 2, 5, 7, 4 } ,{0,2,3,6} ,{0,0,0,2,0,5}, {0,0,2,3,2,1,1,2,0,4}, {0}, {3, 6, 8, 10, 1, 2, 1}, {5, 4, 3, 2, 1}, {1, 7, 3, 9, 2, 8, 6, 4, 5}, {9, 8, 7, 6, 5, 4, 3, 2, 1} };
	for (auto &arr : arrs) testsort(arr);
	//test02();

	return 0;
}