排序算法
快速排序
稳定性：不稳定
平均时间复杂度：NlogN
最差时间复杂度：N^2
最佳时间复杂度：N
思想：分治法
思路：选定一个基准值P，从左到右和从右到左遍历数组，将大于P的移到后面，小于P的移到前面，最后确定P的位置。然后递归P左边的数组和P右边的数组。
优化方法：
- 使用迭代的写法，可以降低函数调用的开销
- 先进行一次有序性检查
- 多线程快排，让每个递归调用单独作为一个线程去跑
- 随机选择基准或者选取中间的数字，在start 和 end中随机选择一个数字交换到start上，或者说选择三个数中位于中间的那个数字，交换到start上。
- 小范围插入排序，数量范围在5~20的时候，使用插入排序，效率会更高些
// 递归版本
#include<iostream>
using namespace std;
void mysort(int array[], int start, int end){
if (start >= end) return;
int left = start+1; //选取第一个数作为基准
int right = end;
int pos = array[start];
while(left < right){
while(left < right && array[left] < pos) left++;
while(left < right && array[right] > pos) right--;
/*
这个结构可能会更清晰些
if (array[left] < pos) left++;
else if (array[right] > pos) right++;
else swap(array[left], array[right]);
*/
//left < right的情况可以无脑交换
//left == right的情况，也可以交换
//left > right的情况不存在
//所以可以直接无脑交换
//由于可能存在重复的数字，所以交换后需要将一个指针的位置移动一下
std::swap(array[left++], array[right]);
}
// 关于left 和 right的情况有三种
// 1. left 第一次直接走到right，那么left之前的所有数字全都小于等于P
// 2. right 走到left,那么当前的数字一定是大于P的，此时应该将P换到right所在的位置的下一个
// 3. left 走到right,那么当前数字是上一轮交换过的，一定是大于P的，也应该将P换到right所在的下一个位置上
// 讨论完毕，我们只需要判断right上的数字是否大于start即可，大就换下面那个，小，就直接换。
if (array[right] > array[start]){
right--;
}
std::swap(array[right], array[start]);
mysort(array, start, right-1);
mysort(array, right+1, end);
return;
int main(){
int array[10] = { 2,34,5,41,45,6,3,9,23,1 };
mysort(array, 0, 9);
for (auto i : array) {
cout << i << " ";
}
}
// 迭代版本
// 用队列的方法来写，每次往队列内部放入两个数，start 和 end。每次取出来排序。
struct node {
int left;
int right;
};
void mysort1(int array[], int size) {
int start = 0;
int end = size - 1;
int left = 0;
int right = end;
queue<node> q;
node n;
n.left = left;
n.right = right;
q.push(n);
while (!q.empty()) {
node temp = q.front();
q.pop();
if (temp.left >= temp.right) continue;
left = temp.left + 1;
right = temp.right;
int pos = array[temp.left];
while (left < right) {
while (left < right && array[left] < pos) left++;
while (left < right && array[right] > pos) right--;
std::swap(array[left], array[right]);
}
if (array[right] > array[temp.left]) {
right--;
}
std::swap(array[right], array[temp.left]);
node new_n;
new_n.left = temp.left;
new_n.right = right - 1;
q.push(new_n);
new_n.left = right + 1;
new_n.right = temp.right;
q.push(new_n);
}
}
// 三数取中法
void swap_mid(int array[], int start, int end){
int mid = (end + start) >> 1;
if (array[start] < array[mid]) swap(array[start], array[mid]);
if (array[end] < array[end]) swap(array[end], array[end]);
if (array[end] < array[start]) swap(array[start], array[end]);
}
冒泡排序
稳定性：稳定
平均时间复杂度：N^2
思路：像冒泡泡一样，从头开始，如果当前数字大于后面的数字，就交换当前的数字，由于每一轮能且只能确定一个数字的最终位置，所以需要遍历n次，每次遍历前n-i个数，i为第几轮。
#include<iostream>
using namespace std;
template<typename T>
void bubble(T array[], int size){
for (int i = 0; i < size; i++){
for (int j = 0; j < size-1-i; j++){
if (array[j] > array[j+1]) swap(array[j], array[j+1]);
}
}
}
int main(){
int array[100];
for (int i = 0; i < 100; i++){
array[i] = rand()%100;
}
bubble<int>(array, 100);
for (auto i : array){
cout << i << " ";
}
}
选择排序
稳定性:不稳定
平均时间复杂度：N^2
思路：每次选择i - size-1中最小的数字，将其交换到第i个位置上
#include<iostream>
using namespace std;
template<typename T>
void select(T array[], int size) {
for (int i = 0; i < size; i++) {
int min_index = i;
for (int j = i; j < size; j++) {
if (array[j] < array[min_index]) {
min_index = j;
}
}
swap(array[i], array[min_index]);
}
}
int main() {
int array[100];
for (int i = 0; i < 100; i++) {
array[i] = rand() % 100;
}
select(array, 100);
for (auto i : array) {
cout << i << " ";
}
}
插入排序
稳定性：稳定
平均时间复杂度：N^2
思路：将数组的前端看作是一个有序的数组，每次从第i个数字开始，在前端从后往前遍历，如果当前数j小于前端当前数i，两者交换位置。
#include<iostream>
using namespace std;
template<typename T>
void insert_sort(T array[], int size){
for (int i = 1; i < size; i++){
for (int j = i; j >0; j--){
if (array[j] < array[j-1]){
swap(array[j], array[j-1]);
}else{
break;
}
}
}
}
希尔排序
稳定性：不稳定
平均时间复杂度：NlogN
最差时间复杂度：N^2
思路：分组的插入排序，因为插入排序在数组相对有序的情况下，效率会更高，所以可以先将数组分成几个组，组内插入排序，而后逐渐加大小组的大小，减少小组的数量，直至只剩一个大组。
#include<iostream>
using namespace std;
template<typename T>
void shell_sort(T array[], int size) {
for (int gap = size >> 1; gap > 0; gap >>= 1) {
for (int i = gap; i < size; i++) {
T temp = array[i];
int j = 0;
for (j = i - gap; j >= 0 && array[j] > temp; j -= gap) {
array[j + gap] = array[j];
}
array[j + gap] = temp;
}
}
}
归并排序
稳定性：稳定
平均时间复杂度：NlogN
思路：将当前数组分成左右两边的数组，递归下去直到得到长度为2的数组，开始让左右两个数组进行插入排序，插入到新的数组中。
#include<iostream>
#include<vector>
using namespace std;
void gui_sort(int array[], int start, int end) {
if (start >= end) return;
int mid = (start + end) >> 1;
gui_sort(array, start, mid);
gui_sort(array, mid + 1, end);
int temp[100];
int i = start, j = mid+1, k = 0;
while (i <= mid && j <= end) {
if (array[i] < array[j]) {
temp[k++] = array[i++];
}
else {
temp[k++] = array[j++];
}
}
while (i <= mid) {
temp[k++] = array[i++];
}
while (j <= end) {
temp[k++] = array[j++];
}
for (int index = 0; index < k; index++) {
array[index + start] = temp[index];
}
}
堆排序
平均时间复杂度：NlogN
稳定性：不稳定
思路：用数组模拟一个堆，每次从最末尾的非叶子节点开始（n-1）/2, n为节点数量减1。直到第0个节点，与其两个儿子，i2+1, i2+2中较大的一个进行交换。需要注意的是，每次交换之后，需要对以该节点为根节点的子树往下递归继续判断是否需要交换，因为如果是已经交换过的，则当前节点的子节点作为父节点的时候，未必就比其子节点要大了。
排序输出的话，每次输出数组的头，然后将头和尾交换，num–，然后重新排序
void heap_swap(int array[], int father, int num){
if (father*+1 > num) return;
int son = father*2+1;
while(son <= num){
if (son+1 <= num && array[son+1] > array[son]) son++;
if (array[son] > array[father]){
swap(array[son], array[father]);
father = son;
son = father*2+1;
}else{
break;
}
}
}
void heap_sort(int array[], int num){
for (int i = (num-1)/2; i >= 0; i--){
int son = i*2+1;
if (son+1 <= num && array[son+1] > array[son]) son++;
if (array[son] > array[i]) {
swap(array[son], array[i]);
heap_sort(array, son, num);
}
}
}
int main() {
int array[10];
int num = 10;
for (int i = 0; i < num; i++) {
array[i] = rand() % 100;
}
for (auto i : array) cout << i << " ";
cout << endl;
heap_sort(array, 9);
for (auto i : array) cout << i << " ";
cout << endl;
while (num) {
cout << array[0] << " ";
swap(array[0], array[num - 1]);
num--;
heap_sort(array, num - 1);
}
}
基数排序
838
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
