数据结构与算法学习笔记(二)——九大排序

1.冒泡排序

        双循环相邻项大小比较进行排序。

        时间复杂度:O(n^2)
        空间复杂度:O(1)
        稳定

2.选择排序

        双循环选择最小项（最大项）进行比较排序。
        时间复杂度:O(n^2)
        空间复杂度:O(1)
        不稳定

3.插入排序

        双循环找到元素当前有序位置进行插入。
        时间复杂度:O(n^2)
        空间复杂度:O(1)
        稳定

4.希尔排序

        分组插入排序

        时间复杂度:O(n^2)->n^1.3
        空间复杂度:O(1)
        不稳定

5.计数排序

        找到排序数组中最大数，开辟以最大数+1为容量的数组，遍历排序数组，排序数组值对应新数组下标进行计数，最后再顺序取出。

        时间复杂度:O(n)
        空间复杂度:O(N)
        不稳定

6.桶排序

        分类计数排序。

        时间复杂度:O(N+C)
        空间复杂度:O(M+C)
        稳定性取决于C

7.堆排序

        采用二叉树的方式，构建最大堆，将根元素（最大值）放在数组末尾。

        时间复杂度:O(nlogn)
        空间复杂度:O(1)
        不稳定

8.归并排序

        采用迭代的方式，进行分类局部排序。

        时间复杂度:O(nlogn)
        空间复杂度:O(m)
        不稳定

9.快速排序

        采用迭代的方式，二分分割数组进行排序。

        时间复杂度:O(nlogn)
        空间复杂度:O(1)
        不稳定

代码

//Mysort.h
#pragma once
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
class Mysort {
public:
	//冒泡排序
	void Bubblesort(vector<int>& vec);
	//选择排序
	void Selectsort(vector<int>& vec);
	//插入排序
	void Insertsort(vector<int>& vec);
	//希尔排序
	void Shellsort(vector<int>& vec);
	void Shellinsert(vector<int>& vec, int start, int gap);
	//计数排序
	void Countsort(vector<int>& vec);
	//桶排序
	void Bucketsort(vector<int>& vec);
	//堆排序
	void Heapsort(vector<int>& vec);
	void HeapMax(vector<int>& vec, int start, int end);
	//归并排序
	void Mergedevide(vector<int>& vec, int left, int right);
	void Mergesort(vector<int>& vec, int left, int mid, int right);
	//快速排序
	void Quicksort(vector<int>& vec, int left, int right);
private:
};

//Mysort.cpp

#include"mysort.h"

//冒泡排序
//时间复杂度:O(n^2)
//空间复杂度:O(1)
//稳定
void Mysort::Bubblesort(vector<int>& vec) {
	for (int i = 0; i < vec.size() - 1; i++) {
		bool flag = true;
		for (int j = 0; j < vec.size() - i - 1; j++) {
			if (vec[j] >= vec[j + 1]) {
				swap(vec[j], vec[j + 1]);
				flag = false;
			}
		}
		if (flag) break;
	}
}

//选择排序
//时间复杂度:O(n^2)
//空间复杂度:O(1)
//不稳定
void Mysort::Selectsort(vector<int>& vec) {
	for (int i = 0; i < vec.size(); i++) {
		int minindex = i;
		for (int j = i; j < vec.size(); j++) {
			if (vec[j] < vec[minindex]) {
				minindex = j;
			}
		}
		swap(vec[i], vec[minindex]);
	}
}

//插入排序
//时间复杂度:O(n^2)
//空间复杂度:O(1)
//稳定
void Mysort::Insertsort(vector<int>& vec) {
	for (int i = 0; i < vec.size()-1; i++) {
		int temp = vec[i + 1];
		for (int j = 0; j <= i; j++) {
			if (vec[i + 1] < vec[j]) {
				for (int k = i + 1; k > j; k--) {
					vec[k] = vec[k - 1];
				}
				vec[j] = temp;
			}
		}
	}
}
//希尔插入
void Mysort::Shellinsert(vector<int>& vec, int start, int gap) {
	for (int i = start; i < vec.size() - gap; i+=gap) {
		int temp = vec[i + gap];
		for (int j = start; j <= i; j+=gap) {
			if (vec[i + gap] < vec[j]) {
				for (int k = i + gap; k > j; k-=gap) {
					vec[k] = vec[k - gap];
				}
				vec[j] = temp;
			}
		}
	}
}
//希尔排序
//时间复杂度:O(n^2)->n^1.3
//空间复杂度:O(1)
//不稳定
void Mysort::Shellsort(vector<int>& vec) {
	for (int gap = vec.size() / 2; gap >= 1; gap /= 2) {
		for (int i = 0; i < gap; i++) {
			Shellinsert(vec, i, gap);
		}
	}
}
//计数排序
//时间复杂度:O(n)
//空间复杂度:O(N)
//不稳定
void Mysort::Countsort(vector<int>& vec) {
	int maxx = *max_element(vec.begin(), vec.end());
	int* countvec = new int[maxx + 1] {0};
	for (auto& i : vec) countvec[i]++;
	vec.clear();
	for (int i = 0; i < maxx+1; i++) {
		while (countvec[i] != 0) {
			countvec[i]--;
			vec.push_back(i);
		}
	}
	delete[] countvec;
}
//桶排序
//时间复杂度:O(N+C)
//空间复杂度:O(M+C)
//稳定性取决于C
void Mysort::Bucketsort(vector<int>& vec) {
	int maxx = *max_element(vec.begin(), vec.end());
	int minx = *min_element(vec.begin(), vec.end());
	int Bucketnum = (maxx - minx + 1) / vec.size() + 1; //M
	vector<vector<int>> Bucketvec(Bucketnum);
	for (auto& i : vec) {
		Bucketvec[(i - minx + 1) / Bucketnum].push_back(i);
	}
	for (auto Bucket:Bucketvec) {
		sort(Bucket.begin(), Bucket.end());   //C
	}
	vec.clear();
	for (auto Bucket:Bucketvec) {
		for (auto j :Bucket) {
			vec.push_back(j);
		}
	}
}
//构建最大堆
void Mysort::HeapMax(vector<int>& vec, int start, int end) {
	int cur = start;
	int left = 2 * cur + 1;
	while (left <= end) {
		if (left < end && vec[left] < vec[left + 1] ) left++;
		if (vec[cur] < vec[left]) swap(vec[cur], vec[left]);
		else break;
		cur = left;
		left = cur * 2 + 1;
	}
}
//堆排序
//时间复杂度:O(nlogn)
//空间复杂度:O(1)
//不稳定
void Mysort::Heapsort(vector<int>& vec) {
	for (int i = vec.size() / 2 - 1; i >= 0; i--) {
		HeapMax(vec, i, vec.size() - 1);
	}
	for (int i = vec.size() - 1; i > 0; i--) {
		swap(vec[0], vec[i]);
		HeapMax(vec, 0, i-1);
	}
}
//归并排序
//时间复杂度:O(nlogn)
//空间复杂度:O(m)
//不稳定
void Mysort::Mergedevide(vector<int>& vec, int left, int right) {
	int mid = (left + right) / 2;
	if (left >= right) return;
	Mergedevide(vec, left, mid);
	Mergedevide(vec, mid+1, right);
	Mergesort(vec, left, mid, right);

}
void Mysort::Mergesort(vector<int>& vec, int left, int mid, int right) {
	int* tmp = new int[right - left+1];
	int i = left, j = mid+1, index = 0;
	while (i <= mid && j <= right) {
		if (vec[i] < vec[j]) tmp[index++] = vec[i++];
		else tmp[index++] = vec[j++];
	}
	while (i <= mid) tmp[index++] = vec[i++];
	while (j <= right) tmp[index++] = vec[j++];
	for (int k = 0; k < index; k++) {
		vec[left + k] = tmp[k];
	}
	delete[] tmp;
}
//快速排序
//时间复杂度:O(nlogn)
//空间复杂度:O(1)
//不稳定
void Mysort::Quicksort(vector<int>& vec, int left, int right) {
	if (left >= right) return;
	int i = left, j = right, temp = vec[i];
	while (i < j) {
		while (i<j && vec[j]>temp) j--;
		if (i < j) vec[i++] = vec[j];
		while (i < j && vec[i] < temp)i++;
		if (i < j)vec[j--] = vec[i];
	}
	vec[i] = temp;
	Quicksort(vec, left, i - 1);
	Quicksort(vec, i+1, right);
}