算法分类
- 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序。
- 线性时间比较类排序:不通过比较来决定元素间的相对次序,可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间比较类排序。
算法时间复杂度分析
相关概念:
- 稳定:如果a原本在b前面,而a=b,经过排序后,a仍然在b前面。
- 不稳定:如果a原本在b前面,而a=b,经过排序后,a可能b后面。
冒泡排序:
算法描述:
- 比较相邻的元素,如果第一个比第二个大,交换这两个元素;
- 对每一对相邻的元素做同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素是最大的数;
- 针对所有的元素重复以上的步骤,除了最后一个元素;
- 重复1-3的步骤,直到排序完成。
相关代码:
void BubbleSort(vector<int>&nums) {
if (nums.empty()) {
return;
}
int temp;
int len = nums.size();
for (int j = 0; j < len - 1; j++){
for (int k = 0; k < len - 1 - j; k++){
if (nums[k] > nums[k + 1]){
temp = nums[k];
nums[k] = nums[k + 1];
nums[k + 1] = temp;
}
}
}
}
选择排序
选择排序是一种简单直观的排序算法。它的工作原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
算法描述:
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。
- 初始状态:无序区为R[1…n],有序区为空;
- 第i趟排序(i=1,2,3…n-1)开始时,当前有序区和无序区分别为R[1…i-1]和R(i…n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区;
- n-1趟结束,数组有序化了。
相关代码:
void SelectSort(vector<int>&nums) {
if (nums.empty()) {
return;
}
int mix, temp;
int len = nums.size();
for (int i = 0; i < len - 1; i++){ //每次循环数组,找出最小的元素,放在前面,前面的即为排序好的
mix = i; //假设最小元素的下标
for (int j = i + 1; j < len; j++) //将上面假设的最小元素与数组比较,交换出最小的元素的下标
if (nums[j] < nums[mix])
mix = j;
//若数组中真的有比假设的元素还小,就交换
if (i != mix){
temp = nums[i];
nums[i] = nums[mix];
nums[mix] = temp;
}
}
}
选择排序是表现最稳定的排序算法之一,因为无论什么数据进去都是O(n^2)的时间复杂度,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲,选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
插入排序
插入排序的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
算法描述:
- 从第一个元素开始,该元素可以认为已经是排好序的;
- 取出下一个元素,在已经排序的数组序列中从后向前扫描;
- 如果该元素(已排序)大于新元素,将该元素移到下一位置;
- 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
- 将新元素插入到改位置;
- 重复步骤2-5,直到数组遍历完。
相关代码:
void InsertionSort(vector<int>&nums) {
if (nums.empty()) {
return;
}
int len = nums.size();
int preIndex, cur;
for (int i = 1; i < len; i++) {
preIndex = i - 1;
cur = nums[i];
while (preIndex >= 0 && nums[preIndex] > cur) {
nums[preIndex + 1] = nums[preIndex];
preIndex--;
}
nums[preIndex + 1] = cur;
}
}
希尔排序
希尔排序是简单插入排序的改进版。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
算法描述:
- 选择一个增量序列t1,t2,…,tk,其中序列的最小值为1;
- 按照增量序列的个数k,对序列进行k趟排序;
- 每趟排序,根据对应的增量t,将待排序的序列分割成若干长度为m的子序列,分别对各子序列进行直接插入排序,仅增量为1的时候,整个序列作为一个整体来处理。
相关代码:
void ShellSort(vector<int>&nums) {
if (nums.empty()) {
return;
}
int len = nums.size();
int temp;
//这里设置刚开始的增量为数组长度的一半
//gap可调节
for (int gap = len / 2; gap > 0; gap = gap / 2) {
for (int i = gap; i < len; i++) {
temp = nums[i];
int j;//直接插入排序
for (j = i - gap; j > 0 && nums[j] > temp; j -= gap) {
nums[j + gap] = nums[j];
}
nums[j + gap] = temp;
}
}
}
希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列,也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法(第4版)》的合著者Robert Sedgewick提出的。
归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。
算法描述:
- 把长度为n的输入序列分为两个长度为n/2的子序列;
- 对这两个序列分别采用归并排序;
- 将两个排序好的子序列合并成一个最终的排序序列。
相关代码:
void MergeSort(vector<int>&nums, int left, int right) {//采用自上而下的递归
if (nums.empty()|| left >= right) {
return;
}
int len = nums.size();
int mid = (right - left) / 2 + left;
MergeSort(nums, left, mid);
MergeSort(nums, mid + 1, right);
Merge(nums, left, mid, right);
}
void Merge(vector<int>&nums, int left, int mid, int right) {
vector<int> temp(right - left + 1);//开辟一个新的数组,将原数组映射进去
for (int m = left; m <= right; m++){
temp[m - left] = nums[m];
}
int i = left, j = mid + 1;//i和j分别指向两个子数组开头部分
for (int k = left; k <= right; k++){
if (i > mid){
nums[k] = temp[j - left];
j++;
}
else if (j > right){
nums[k] = temp[i - left];
i++;
}
else if (temp[i - left] < temp[j - left]){
nums[k] = temp[i - left];
i++;
}
else{
nums[k] = temp[j - left];
j++;
}
}
}
快速排序
快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。
算法描述:
- 从数组中挑出一个元素,称为基准元素;
- 重新排序数组,所有元素比基准值小的摆放在基准元素前面,所有元素比基准值大的摆放在基准元素后面。
- 递归地将小于基准元素的子数组和大于基准元素的子数组排序。
相关代码:
void QuickSort(vector<int>&nums, int left, int right){
if (left < right){
int pos = Partition(nums, left, right);
QuickSort(nums, left, pos - 1);
QuickSort(nums, pos + 1, right);
}
}
int Partition(vector<int>&a, int left, int right){
int temp = a[left];
while (right > left){
while (left < right&&a[right] >= temp){
right--;
}
a[left] = a[right];
while (left < right&&a[left] <= temp){
left++;
}
a[right] = a[left];
}
a[right] = temp;
return left;
}
堆排序
堆排序是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。
算法思想:
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆,此堆为初始的无序区;
- 将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n];
- 由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn);
- 不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成。
注意点:
- 如果数组下标从1开始存储,编号为i的节点的主要关系为:
双亲:i/2,取下整。左孩子:2i,右孩子:2i+1。 - 如果数组下标从0开始存储,编号为i的节点的主要关系为:
双亲:(i-1)/2,取下整。左孩子:2i+1,右孩子:2i+2。
相关代码:
void HeapSort(vector<int>&nums, int n){
int i;
//首先将无序数列转换为大顶堆
for (i = n / 2; i > 0; i--) //注意由于是完全二叉树,所以我们从一半向前构造,传入父节点
AdjustHeap(nums, i, n);
//上面大顶堆已经构造完成,我们现在需要排序,每次将最大的元素放入最后
//然后将剩余元素重新构造大顶堆,将最大元素放在剩余最后
for (i = n; i > 1; i--){
Swap(nums, 1, i);
AdjustHeap(nums, 1, i - 1);
}
}
void Swap(vector<int>&nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
//大顶堆的构造,传入的i是父节点
void AdjustHeap(vector<int> &nums, int p, int n){
int i, temp;
temp = nums[p];
for (i = 2 * p; i <= n; i *= 2) { //逐渐去找左右孩子结点
//找到两个孩子结点中最大的
if (i < n&&nums[i] < nums[i + 1])
i++;
//父节点和孩子最大的进行判断,调整,变为最大堆
if (temp >= nums[i])
break;
//将父节点数据变为最大的,将原来的数据还是放在temp中,
nums[p] = nums[i]; //若是孩子结点的数据更大,我们会将数据上移,为他插入的点提供位置
p = i;
}
//当我们在for循环中找到了p子树中,满足条件的点,我们就加入数据到该点p,注意:p点原来数据已经被上移动了
//若没有找到,就是相当于对其值不变
//插入
nums[p] = temp;
}
以上算法都是非线性时间比较类排序算法,下篇再来总结线性时间比较类排序算法。