八大排序算法

1.排序的概念
2.算法分析
3.具体排序讲解
- 3.1插入排序
- - 直接插入排序
  - 希尔排序
- 3.2选择排序
- - 简单选择排序
  - 堆排序
- 3.3交换排序
- - 冒泡排序
  - 快速排序

1.排序的概念

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。

排序分为内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。

2.算法分析

插入排序

直接插入排序

将第一个和第二个元素排好序，然后将第3个元素插入到已经排好序的元素中，依次类推（插入排序最好的情况就是数组已经有序了）

希尔排序

因为插入排序每次只能操作一个元素，效率低。元素个数N，取奇数k=N/2，将下标差值为k的数分为一组（一组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为一组，构成有序序列，直到k=1，然后再进行直接插入排序。

选择排序

简单选择排序

选出最小的数和第一个数交换，再在剩余的数中又选择最小的和第二个数交换，依次类推

堆排序

以升序排序为例，利用小根堆的性质（堆顶元素最小）不断输出最小元素，直到堆中没有元素
1.构建小根堆
2.输出堆顶元素
3.将堆低元素放一个到堆顶，再重新构造成小根堆，再输出堆顶元素，以此类推

交换排序

冒泡排序

头尾进行冒泡，每次把最大的沉底，最小的浮上去，两边往中间靠1

快速排序

选择一个基准元素，比基准元素小的放基准元素的前面，比基准元素大的放基准元素的后面，这种动作叫分区，每次分区都把一个数列分成了两部分，每次分区都使得一个数字有序，然后将基准元素前面部分和后面部分继续分区，一直分区直到分区的区间中只有一个元素的时候，一个元素的序列肯定是有序的嘛，所以最后一个升序的序列就完成啦。

归并排序

将一个无序的数列一直一分为二，直到分到序列中只有一个数的时候，这个序列肯定是有序的，因为只有一个数，然后将两个只含有一个数字的序列合并为含有两个数字的有序序列，这样一直进行下去，最后就变成了一个大的有序数列

计数排序

找到最大的数，开个比最大的数大一点的数组，遍历每个元素，某个元素为k，则a[k]++,最好遍历数组a，a[k]等于多少就输出多少个k。只能处理整型数

稳定排序：冒泡排序，直接插入排序，归并排序，计数排序

稳定排序：待排序的记录序列中可能存在两个或两个以上关键字相等的记录。排序前的序列中Ri领先于Rj（即i<j）.若在排序后的序列中Ri仍然领先于Rj，则称所用的方法是稳定的。比如int数组[1,1,1,6,4]中a[0],a[1],a[2]的值相等，在排序时不改变其序列，则称所用的方法是稳定的。

不稳定排序：简单选择排序，快速排序，希尔排序，堆排序

3.具体排序讲解

3.1插入排序

直接插入排序

直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过因此，从上面的描述中我们可以发现，直接插入排序可以用两个循环完成。

第一层循环：遍历待比较的所有数组元素
第二层循环：将本轮选择的元素(selected)与已经排好序的元素(ordered)相比较。如果：selected > ordered，那么将二者交换。

#include<iostream>
#include<vector>
using namespace std;
void Print(vector<int>& v,int i) {cout <<"第"<< i <<"次排序结果"<< ":";for (int j = 0; j<v.size(); ++j) {cout << v[j] << " ";}cout << endl;
}
void InsertSort(vector<int>& v) {for (int i = 1; i < v.size(); ++i) {// //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入if (v[i] < v[i - 1]) {int end = i - 1;int tmp = v[i];while(end>=0) {if (tmp < v[end]) {v[end + 1] = v[end];end--;}elsebreak;}v[end + 1] = tmp;}Print(v, i);}
}int main() {vector<int> v;v.push_back(10);v.push_back(7);v.push_back(9);v.push_back(8);v.push_back(4);v.push_back(2);InsertSort(v);return 0;
}

希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

算法步骤：
1.选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2.按增量序列个数k，对序列进行k趟排序；
3.每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

#include<iostream>
#include<vector>
using namespace std;
void Print(vector<int>& v, int i) {cout << "第" << i << "次排序结果" << ":";for (int j = 0; j < v.size(); ++j) {cout << v[j] << " ";}cout << endl;
}
void ShellSort(vector<int>& v) {int size = v.size();int gap = size;while (gap > 1) {gap = gap / 3 + 1;for (int i = 0; i < size - gap; ++i) {int end = i;int tmp = v[end + gap];while (end >= 0 && tmp < v[end]) {v[end+gap] = v[end];end -= gap;}v[end + gap] = tmp;cout << "gap为" << gap << "时";Print(v,i);}cout << endl;}
}
int main() {vector<int> v;v.push_back(10);v.push_back(7);v.push_back(9);v.push_back(8);v.push_back(4);v.push_back(2);ShellSort(v);return 0;
}

3.2选择排序

简单选择排序

简单选择排序的实现思想：比较+交换
在一个无序数组中选择出每一轮中最值元素，然后把这一轮中最前面的元素和min交换，最后面的元素和max交换；然后缩小范围(begin++,end–),重复上面步骤，最终得到有序序列（升序）。

#include<iostream>
#include<vector>
using namespace std;
void Print(vector<int>& v,int i) {cout <<"第"<< i <<"次排序结果"<< ":";for (int j = 0; j<v.size(); ++j) {cout << v[j] << " ";}cout << endl;
}
void Selectsort(vector<int>& v) {size_t size = v.size();int begin = 0;int end = size - 1;int j = 0;while (begin < end) {int min = begin,max = begin;//选择每一轮的最值元素for (int i = begin; i <=end; ++i) {if (v[min]>v[i])min = i;if (v[max]<v[i])max = i;}//最前面的元素和min交换，最后面的元素和max交换swap(v[min], v[begin]);如果首元素是最大的，则需要先把min 和 max的位置一换，再交换，否则经过两次交换，又回到原来的位置if (max==begin) {max = min;}swap(v[max], v[end]);++j;++begin;--end;Print(v, j);}
}
int main() {vector<int> v;v.push_back(10);v.push_back(7);v.push_back(9);v.push_back(8);v.push_back(4);v.push_back(2);Selectsort(v);return 0;
}

堆排序

堆的概念
堆：本质是一种数组对象。特别重要的一点性质：任意的叶子节点小于（或大于）它所有的父节点。对此，又分为大顶堆和小顶堆：

大顶堆要求节点的元素都要大于其孩子。
小顶堆要求节点元素都小于其左右孩子。

两者对左右孩子的大小关系不做任何要求。利用堆排序，就是基于大顶堆或者小顶堆的一种排序方法。下面，我们通过大顶堆来实现。

基本思想：堆排序可以按照以下步骤来完成：

首先将序列构建称为大顶堆；（这样满足了大顶堆那条性质：位于根节点的元素一定是当前序列的最大值）
取出当前大顶堆的根节点，将其与序列末尾元素进行交换；（此时：序列末尾的元素为已排序的最大值；由于交换了元素，当前位于根节点的堆并不一定满足大顶堆的性质）
对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质；
重复2.3步骤，直至堆中只有1个元素为止

#include<iostream>
#include<vector>
using namespace std;void Adjustdown(int* a, int root, int n) {int child = root * 2 + 1;//左孩子while (child < n) {if ((child + 1 )< n && a[child + 1] > a[child])child++;if (a[child] > a[root]) {swap(a[child], a[root]);root = child;child = root * 2 + 1;}elsebreak;}
}int* Heapsort(int* a, int n) {//构建堆 从最后一个非叶子节点开始for (int i = (n - 1) / 2; i >= 0; i--) {Adjustdown(a, i, n);for (int i = 0; i < n; ++i) {cout << a[i] << " ";}cout << endl;}int end = n - 1;while (end > 0) {swap(a[0], a[end]);Adjustdown(a, 0, end); // end其实就是不算后面的一个元素，原因是最后一个节点已经是最大的for (int i = 0; i < n; ++i) {cout << a[i] << " ";}cout << endl;end--;}return a;
}int main() {int a[] = { 2,5,1,7,9,8,3,6 };int n = (sizeof(a)) / sizeof(int);Heapsort(a, n);for (int i = 0; i < n; ++i) {cout << a[i] << " " ;}return 0;}

3.3交换排序

冒泡排序

冒泡遍历所有的数据，每次对相邻元素进行两两比较，如果顺序和预先规定的顺序不一致，则进行位置交换；这样一次遍历会将最大或最小的数据上浮到顶端，之后再重复同样的操作，直到所有的数据有序。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

#include<iostream>
#include<vector>
using namespace std;void Bubblesort(int* a, size_t n) {for (int i = 0; i < n-1; ++i) {for (int j = 0; j < n-1-i; ++j) {if (a[j] > a[j + 1]) {int temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;}}}
}int main() {int a[] = { 2,5,1,7,9,8,3,6 };int n = (sizeof(a)) / sizeof(int);Bubblesort(a, n);for (int i = 0; i < n; ++i) {cout << a[i] << " " ;}return 0;}

优化：设置一个变量判断exchange判断序列是否为升序序列，如为升序则直接输出。

#include<iostream>
#include<vector>
using namespace std;void Bubblesort(int* a, size_t n) {for (int i = 0; i < n - 1; ++i) {int exchange = 0;//设置一个变量判断是否为升序序列 优化冒泡排序for (int j = 0; j < n-1-i; ++j) {if (a[j] > a[j + 1]) {int temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;exchange = 1;//exchang改变说明 其不是一个标准的升序序列}}if (exchange == 0)//exchange没变 说明其是一个标准的升序序列 跳出循环 break;for (int i = 0; i < n; ++i) {cout << a[i] << " ";}cout << endl;}
}int main() {int a[] = { 2,5,1,7,9,8,3,6 };int n = (sizeof(a)) / sizeof(int);Bubblesort(a, n);return 0;}

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

将区间按照基准值划分为左右两半部分的常见方式有：

左右指针法
挖坑法
前后指针法

左右指针法

1．将数组的最后一个数right作为基准数key。
2．分区过程:从数组的首元素begin开始向后找比key大的数（begin找大）；end开始向前找比key小的数（end找小）；找到后然后两者交换（swap）,直到begin >= end终止遍历。最后将begin和最后一个数交换（这个时候end不是最后一个位置），即 key作为中间数（左区间都是比key小的数，右区间都是比key大的数）
3．再对左右区间重复第二步，直到各区间只有一个数。

//左右指针法
int Partsort1(int* a, int left, int right) {int begin = left;int end = right;int key = right;while (begin < end) {while (begin < end && a[begin] <= a[key])begin++;while (begin < end && a[end] >= a[key])end--;swap(a[begin], a[end]);}swap(a[begin], a[right]);return begin;//返回中间位置
}

挖坑法

定义两个指针left指向起始位置，right指向最后一个元素的位置,然后指定一个基数key（right）,作为坑。
left寻找比基数（key）大的数字，找到后将left的数据赋给right，left成为一个坑，然后right寻找比基数（key）小的数字，找到将right的数据赋给left，right成为一个新坑，循环这个过程，直到begin指针与end指针相遇，然后将key返回给那个坑（最终：key的左边都是比key小的数，key的右边都是比key大的数），然后进行递归操作。

//挖坑法
int Partsort2(int* a, int left, int right) {int key = a[right];//初始坑while (left < right) {while (left < right && a[left] <= key)left++;a[right] = a[left];//left作为新坑while (left < right && a[right] >= key)right--;a[left] = a[right];//right作为新坑}a[left] = key;将key赋值给left和right的相遇点，保持key的左边都是比key小的数，key的右边都是比key大的数return left;//最终返回中间位置
}

前后指针法

定义两个指针，一前一后，cur（前）指向起始位置，prev（后）指向cur的前一个位置；选择数组最后一个元素作为key（right）
实现过程：cur找比key小的数，prev在cur没有找到的情况下，一直不动（即保证prev一直指向比key大的数）；直到cur找到比key小的数（+ +prev && prev != cur时）然后++cur,prev仍然不动。
直到cur走到right前一个位置，终止循环。最后++prev，交换prev和right的值。返回中间位置prev。最后再继续递归。

//前后指针法
int Partsort3(int* a, int left, int right) {int cur = left;int prev = left - 1;int key = a[right];while (cur < right) {if (a[cur] < key && ++prev!=cur) {swap(a[cur], a[prev]);}++cur;}swap(a[++prev], a[right]);//++prev左边比key小 右边比key大return prev;返回中间位置
}

递归实现：

#include<iostream>
#include<vector>
using namespace std;//左右指针法
int Partsort1(int* a, int left, int right) {int begin = left;int end = right;int key = right;while (begin < end) {while (begin < end && a[begin] <= a[key])begin++;while (begin < end && a[end] >= a[key])end--;swap(a[begin], a[end]);}swap(a[begin], a[right]);return begin;//返回中间位置
}//挖坑法
int Partsort2(int* a, int left, int right) {int key = a[right];//初始坑while (left < right) {while (left < right && a[left] <= key)left++;a[right] = a[left];//left作为新坑while (left < right && a[right] >= key)right--;a[left] = a[right];//right作为新坑}a[left] = key;将key赋值给left和right的相遇点，保持key的左边都是比key小的数，key的右边都是比key大的数return left;//最终返回中间位置
}//前后指针法
int Partsort3(int* a, int left, int right) {int cur = left;int prev = left - 1;int key = a[right];while (cur < right) {if (a[cur] < key && ++prev!=cur) {swap(a[cur], a[prev]);}++cur;}swap(a[++prev], a[right]);//++prev左边比key小 右边比key大return prev;//返回中间位置
}//递归
void Quicksort(int* a, int left, int right) {if (left >= right)return;int mid = Partsort1(a, left, right);Quicksort(a, left, mid - 1);Quicksort(a, mid + 1, right);
}int main() {int a[] = { 2,5,1,7,9,8,3,6 };int n = (sizeof(a)) / sizeof(int);Quicksort(a, 0, n - 1);for (int i = 0; i < n; ++i) {cout << a[i] << " " ;}return 0;
}

排序算法(插入、选择、交换、归并)相关推荐

【自考】排序算法-插入、交换、选择、归并排序
碎碎念: 记得当初第一年的时候.接触算法.有那么两个视频.跳舞的.讲的是冒泡排序跟选择排序.当时看了好多遍最终懂了.这次多了一些算法.学起来也还好吧.咱是有基础的人.找到了曾经的视频.有的就发了.没找 ...
Java面试宝典系列之基础面试题-常见的几种排序算法-插入、选择、冒泡、快排、堆排等
常见的几种排序算法-插入.选择.冒泡.快排.堆排: https://blog.csdn.net/zhangerqing/article/details/8831542
C语言排序算法之简单交换法排序，直接选择排序，冒泡排序
C语言排序算法之简单交换法排序,直接选择排序,冒泡排序,最近考试要用到,网上也有很多例子,我觉得还是自己写的看得懂一些. 简单交换法排序 1 /*简单交换法排序 2 根据序列中两个记录键值的比较结果来 ...
排序---初级排序算法（选择排序、插入排序和希尔排序）
写在前面的话: 一枚自学Java和算法的工科妹子. 算法学习书目:算法(第四版) Robert Sedgewick 算法视频教程:Coursera Algorithms Part1&2 本文 ...
堆排序算法c语言筛选法,【排序】排序算法之选择排序
排序算法之选择排序罗朝辉(http://www.cppblog.com/kesalin) 转载请注明出处排序是数据处理中经常使用的一种重要运算,在计算机及其应用系统中,花费在排序上的时间在系统运行 ...
函数模板案例_利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序排序规则从大到小，排序算法为选择排序分别利用char数组和int数组进行测试
案例描述: 利用函数模板封装一个排序的函数,可以对不同数据类型数组进行排序排序规则从大到小,排序算法为选择排序分别利用char数组和int数组进行测试 #include <iostream& ...
排序算法 | 直接选择排序，算法的图解、实现、复杂度和稳定性分析
排序算法 | 直接选择排序,算法的图解.实现.复杂度和稳定性分析目录 1.直接选择排序的原理 2.图解直接选择排序 3.算法代码实现 4.算法复杂度分析.稳定性分析直接选择排序 1.直接选择排序的 ...
【排序算法】选择排序(Selection sort)
选择排序(Selection sort)是一种简单直观的排序算法. 选择排序介绍它的基本思想是: 首先在未排序的数列中找到最小(or最大)元素,然后将其存放到数列的起始位置:接着,再从剩余未排序的元 ...
排序算法(3)选择排序
排序算法(3)选择排序原理:思想:两个变种(1)单侧选择:在一个无序数组中选择出每一轮中最大值(或最小值)元素,放到最前面或最后面(升序)(2)双向选择:在一个无序数组中选择出每一轮中最值元素,然后 ...
Java经典排序算法：选择排序，动图演示排序过程
Java经典排序算法:选择排序,动图演示排序过程示意动图: public class Main {public static void main(String[] args) {new Main() ...

排序算法(插入、选择、交换、归并)