数据结构与算法——排序

1.冒泡排序

将一个数组从小到大排序，一次循环（从头开始遍历，将相邻的两个数值比较，如果前面一个大于后面的数字，交换这两个数字）可以将循环数组中的最大值放在最后面，经过多次冒泡就可以完成排序

平均时间复杂度	$O(n^2)$
最坏时间复杂度	$O(n^2)$
最好时间复杂度	$O(n)$
空间复杂度	O(1)

#include<iostream>
#include<vector>

using namespace std;

//1.冒泡算法
void bubblesort(vector<int>& array,int N) {
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < N - 1 - i; j++) {
			if (array[j] > array[j + 1]) {
				swap(array[j], array[j + 1]);
			}
		}
	}
}

2.选择排序

一次循环，找出最大值，与最后一个值做交换，执行多次循环

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

//2.选择排序
void selectsort(vector<int>& array, int N) {
	for (int i = 0; i < N; i++) {
		int max = array[0];
		int location = 0;
		for (int j = 0; j < N - i; j++) {
			if (array[j] > max) {
				max = array[j];
				location = j;
			}
		}
		swap(array[location], array[N - 1 - i]);
	}
}
int main() {
	vector<int> array = { 2,1,5,6,0,1,2,8,10,3,8 };
	selectsort(array, array.size());
	for (int i = 0; i < array.size(); i++) {
		cout << array[i] << " ";
	}
	cout << endl;
}

3.插入排序

假设数组i位置前面的（0~i-1）个元素，是有序数组（从小到大），在前面的有序数组中插入第i个元素，从后向前，依次和第i个元素比较，大的向后，直到插入合适位置，循环N-1次就可以完成排序。

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

//3.插入排序
void insertsort(vector<int>& array,int N) {
	for (int i = 1; i < N; i++) {
		int n = i;
		while (n>0&&array[n] < array[n-1]) {
			swap(array[n], array[n - 1]);
			n--;
		}
	}
}
int main() {
	vector<int> array = { 2,1,5,6,0,1,2,8,10,3,8 };
	insertsort(array, array.size());
	for (int i = 0; i < array.size(); i++) {
		cout << array[i] << " ";
	}
	cout << endl;
}

参考链接：插入排序

4.快速排序

选定数组中一个数pivot作为中心轴
将大于pivot的数放在pivot的右边，将小于pivot的数放在pivot的左边
分别对左右子序列重复第一步第二步的操作

平均时间复杂度	$O(nlo{g}_{2}n)$
最坏时间复杂度	$O(n^2)$
最好时间复杂度	$O(nlo{g}_{2}n)$
空间复杂度	$O(nlo{g}_{2}n)$

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


void quicksort(vector<int>& array, int left,int right) {
	if (left >= right) {
		return;
	}
	int l = left;
	int r = right;
	while (l < r) {
		while (array[left] <= array[r] && l < r) {
			r--;
		}
		while (array[left] >= array[l] && l < r) {
			l++;
		}
		swap(array[l], array[r]);
	}
	swap(array[left], array[l]);
	quicksort(array, left, l - 1);
	quicksort(array, l + 1, right);
}
int main() {
	vector<int> array = { 2,1,5,6,0,1,2,8,10,3,8 };
	quicksort(array, 0, array.size() - 1);
	for (int i = 0; i < array.size(); i++) {
		cout << array[i] << " ";
	}
	cout << endl;
}

参考链接：快速排序

5.堆排序

构造一个大顶堆/小顶堆，取堆顶数字，也就是最大值/最小值
再将剩下的数字构建一个大顶堆/小顶堆，，取堆顶数字
重复以上的操作，直到取完堆中的数字，得到一个从大到小/从小到大的有序数组

#include<iostream>
#include<iostream>
#include<vector>

using namespace std;

//5.堆排序
void HeapSort(vector<int>& result, int count, int location) {
    if (location<0 || location>count) {
        return;
    }

    int left_location = 2 * location + 1;
    int right_locaton = 2 * location + 2;
    int max = result[location];

    if (left_location < count && max < result[left_location]) {
        max = result[left_location];
    }
    if (right_locaton < count && max < result[right_locaton]) {
        max = result[right_locaton];
    }

    if (max != result[location]) {
        if (left_location < count && max == result[left_location]) {
            result[left_location] = result[location];
            HeapSort(result, left_location, count);
        }
        else if (right_locaton < count && max == result[right_locaton]) {
            result[right_locaton] = result[location];
            HeapSort(result, right_locaton, count);
        }
        result[location] = max;
    }
}
vector<int> heap_sort(int array[], int N) {
    vector<int> result;
    for (int i = 0; i < N; i++) {
        result.push_back(array[i]);
    }
    for (int count = N; count > 0; count--) {
        for (int location = count / 2; location >= 0; location--) {
            HeapSort(result, count, location);
        }
        int value = result[0];
        result[0] = result[count - 1];
        result[count - 1] = value;
    }
    return result;
}
int main()
{
    int array[] = { 2,6,1,5,0,8,4,3 };
    int N = sizeof(array)/4;
    vector<int> sorted;
    
    //sorted= bubble_sort(array, N);
    //sorted = select_sort(array, N);
    //sorted = insertion_sort(array, N);
    //sorted = quick_sort(array, N);
    sorted = heap_sort(array, N);
    for (int i = 0; i < sorted.size(); i++) {
        cout << sorted[i] << " ";
    }
    cout << endl;
    return 0;

}

参考链接：
堆排序算法
排序算法
图解排序算法(三)之堆排序

6.归并排序

将数组中的数分为若干组，开始各组数字都是单个元素
两两排序归并，保证归并后的数组是有序的
重复上面两步，直到合成一个组

平均时间复杂度	$O(nlo{g}_{2}n)$
最坏时间复杂度	$O(nlo{g}_{2}n)$
最好时间复杂度	$O(nlo{g}_{2}n)$
空间复杂度	$O(n)$

#include<iostream>
#include<vector>

using namespace std;

//6.归并排序
void mergesort(vector<int>& array, int left, int right) {
	if (left >= right) {
		return;
	}
	int mid = (left + right) / 2;
	mergesort(array, left, mid);
	mergesort(array, mid + 1, right);

	int l = left;
	int r = mid + 1;
	vector<int> tmp;
	while (l <= mid && r <= right) {
		if (array[l] > array[r]) {
			tmp.push_back(array[r]);
			r++;
		}
		else {
			tmp.push_back(array[l]);
			l++;
		}
	}
	while (l <= mid) {
		tmp.push_back(array[l]);
		l++;
	}
	while (r <= right) {
		tmp.push_back(array[r]);
		r++;
	}
	for (int i = 0; i <= right - left; i++) {
		array[i + left] = tmp[i];
	}
}

int main() {
	vector<int> array = { 2,1,5,6,0,1,2,8,10,3,8 };
	//quicksort(array, 0, array.size() - 1);
	//bubblesort(array, array.size());
	mergesort(array, 0, array.size() - 1);
	for (int i = 0; i < array.size(); i++) {
		cout << array[i] << " ";
	}
	cout << endl;
}

参考链接：

归并排序算法讲解
十分钟学会写归并排序

7.希尔排序

该方法的基本思想是：
先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，
然后依次缩减增量再进行排序，
待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

#include<iostream>
#include<iostream>
#include<vector>

using namespace std;

//7.希尔排序
void shell_swap(int a, int b, vector<int>& result) {
    int temp = result[a];
    result[a] = result[b];
    result[b] = temp;
}
vector<int> shell_sort(int array[], int N) {
    vector<int> result;

    for (int i = 0; i < N; i++) {
        result.push_back(array[i]);
    }
    for (int gap = N / 2; gap > 0; gap--) {
        for (int i = gap; i < N; i++) {
            for (int j = i - gap; j >= 0 && result[j] > result[j + gap]; j -= gap) {
                shell_swap(j, j + gap, result);
            }
        }
    }
    return result;
}

int main()
{
    int array[] = { 2,6,1,5,0,8,4,3,10 };
    int N = sizeof(array)/4;
    vector<int> sorted;
    
    //sorted= bubble_sort(array, N);
    //sorted = select_sort(array, N);
    //sorted = insertion_sort(array, N);
    //sorted = quick_sort(array, N);
    //sorted = heap_sort(array, N);
    //sorted = merge_sort(array, N);
    sorted = shell_sort(array, N);
    for (int i = 0; i < sorted.size(); i++) {
        cout << sorted[i] << " ";
    }
    cout << endl;
    return 0;

}

参考链接：

[算法]六分钟彻底弄懂希尔排序，简单易懂
白话经典算法系列之三 希尔排序的实现