看了总结图,我这里就总结一下 直接插入排序,冒泡排序,快速排序,堆排序和归并排序,使用C++实现

重新画了总结图

直接插入排序

整个序列分为有序区和无序区,取第一个元素作为初始有序区,然后第二个开始,依次插入到有序区的合适位置,直到排好序

刚开始在我那本《数据结构》看到大概这样的实现

void InsertSort(int arr[], int len) {
int i, j;
int temp;
for (i = 1; i < len; i++) {
temp = arr[i];
for (j = i - 1; j >= 0 && arr[j] > temp;j--)
arr[j + 1] = arr[j];
arr[j + 1] = temp;
}
}

有点难理解,后来又在网上看到这样的实现,这种方式比较好理解

void InsertSort(int arr[],int n){
for (int i =1;i <= n;++i){
for(int j = i;j > 0;--j){
if(arr[j] < arr[j -1]){
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
}

原理都是一样的,第一个for循环对从第二个开始的所有的数字遍历,嵌套的for循环是每次遍历数字时都取无序区的一个元素与有序区的元素比较,如果比有序区的要小则交换,直到合适的位置。

如果使用vector的话会方便一点,因为vector可以使用size()直接获得容器内的元素个数

void InsertSort2(vector<int> &num){
for(int i = 1;i < num.size();++i){
for(int j = i;j > 0;--j){
if(num[j] < num[j - 1]){
int temp = num[j];
num[j] = num[j-1];
num[j-1] = temp;
}
}
}
}

插入排序的时间复杂度最好的情况是已经是正序的序列,只需比较(n-1)次,时间复杂度为O(n),最坏的情况是倒序的序列,要比较n(n-1)/2次,时间复杂度为O(n^2 ) ,平均的话要比较时间复杂度为O(n^2 )

插入排序是一种稳定的排序方法,排序元素比较少的时候很好,大量元素便会效率低下

这个图很形象,取自维基百科

冒泡排序

比较相邻的元素,如果反序则交换,过程也是分为有序区和无序区,初始时有序区为空,所有元素都在无序区,经过第一趟后就能找出最大的元素,然后重复便可

void BubbleSort(int arr[], int n)
{
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

冒泡排序感觉非常好理解,第一个for循环是遍历所有元素,第二个for循环是每次遍历元素时都对无序区的相邻两个元素进行一次比较,若反序则交换

时间复杂度最坏的情况是反序序列,要比较n(n-1)/2次,时间复杂度为O(n^2 ),最好的情况是正序,只进行(n-1)次比较,不需要移动,时间复杂度为O(n),而平均的时间复杂度为O(n^2 )

但是还有更好的方法,如果第一次比较完没有交换即说明已经有序,不应该进行下一次遍历
还有已经遍历出部分有序的序列后,那部分也不用进行遍历,即发生交换的地方之后的地方不用遍历

void BubbleSort(int arr[], int len){
int i,temp;
//记录位置,当前所在位置和最后发生交换的地方
int current,last = len - 1;
while(last > 0) {
for(i = current = 0;i < last;++i){
if(arr[i] > arr[i+1]){
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
//记录当前的位置,如果没有发生交换current值即for循环初始化的0
current = i;
}
}
//若current = 0即已经没有可以交换的元素了,即已经有序了
last = current;
}
}

图取自维基

冒泡排序也是一种稳定的排序算法,也是元素较少时效率比较高

快速排序

快速排序首先选一个轴值(pivot,也有叫基准的),将待排序记录划分成独立的两部分,左侧的元素均小于轴值,右侧的元素均大于或等于轴值,然后对这两部分再重复,直到整个序列有序

过程是和二叉搜索树相似,就是一个递归的过程

排序函数

QuickSort(int arr[], int first, int end){
if (first < end) {
int pivot = OnceSort(arr,first,end);
//已经有轴值了,再对轴值左右进行递归
QuickSort(arr,first,pivot-1);
QuickSort(arr,pivot+1,end);
 }
}

接下来就是一次排序的函数

int OnceSort(int arr[], int first, int end){
int i = first,j = end;
//当i<j即移动的点还没到中间时循环
while(i < j){
//右边区开始,保证i<j并且arr[i]小于或者等于arr[j]的时候就向左遍历
while(i < j && arr[i] <= arr[j]) --j;
//这时候已经跳出循环,说明j>i 或者 arr[i]大于arr[j]了,如果i<j那就是arr[i]大于arr[j],那就交换
if(i < j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//对另一边执行同样的操作
while(i < j && arr[i] <= arr[j]) ++i;
if(i < j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
//返回已经移动的一边当做下次排序的轴值
return i;
}

过程解释都写在注释里面了,挺好理解的
这是我在书上看到的实现,用的是递归的方法
我在维基上还看到用迭代的方法,这里就不说了,有兴趣的可以去看看

这个图不是一般的棒!!来自维基

快速排序时间复杂度的最好情况和平均情况一样为O(nlog2 n),最坏情况下为O(n^2 ),这个看起来比前面两种排序都要好,但是这是不稳定的算法,并且空间复杂度高一点( O(nlog2 n)
而且快速排序适用于元素多的情况

堆排序

堆的结构类似于完全二叉树,每个结点的值都小于或者等于其左右孩子结点的值,或者每个节点的值都大于或等于其左右孩子的值

堆排序过程将待排序的序列构造成一个堆,选出堆中最大的移走,再把剩余的元素调整成堆,找出最大的再移走,重复直至有序

来看一下实现

//堆排序
void HeapSort(int arr[],int len){
int i;
//初始化堆,从最后一个父节点开始
for(i = len/2 - 1; i >= 0; --i){
Heapify(arr,i,len);
}
//从堆中的取出最大的元素再调整堆
for(i = len - 1;i > 0;--i){
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
//调整成堆
Heapify(arr,0,i);
}
}

再看 调整成堆的函数

void Heapify(int arr[], int first, int end){
int father = first;
int son = father * 2 + 1;
while(son < end){
if(son + 1 < end && arr[son] < arr[son+1]) ++son;
//如果父节点大于子节点则表示调整完毕
if(arr[father] > arr[son]) break;
else {
//不然就交换父节点和子节点的元素
int temp = arr[father];
arr[father] = arr[son];
arr[son] = temp;
//父和子节点变成下一个要比较的位置
father = son;
son = 2 * father + 1;
}
}
}

堆排序的时间复杂度最好到最坏都是O(nlogn),较多元素的时候效率比较高

图来自维基

归并排序

归并排序的基本思想是将若干个序列进行两两归并,直至所有待排序记录都在一个有序序列为止

这个图很有概括性,来自维基

我们也可以用递归的思想,每次合并就是一次递归
首先,将一整个序列分成两个序列,两个会分成4个,这样分下去分到最小单位,然后开始合并

void Merge(int arr[], int reg[], int start, int end) {
if (start >= end)return;
int len = end - start, mid = (len >> 1) + start; //分成两部分
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
//然后合并
Merge(arr, reg, start1, end1);
Merge(arr, reg, start2, end2); int k = start;
//两个序列一一比较,哪的序列的元素小就放进reg序列里面,然后位置+1再与另一个序列原来位置的元素比较
//如此反复,可以把两个有序的序列合并成一个有序的序列
while (start1 <= end1 && start2 <= end2)
reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++]; //然后这里是分情况,如果arr2序列的已经全部都放进reg序列了然后跳出了循环
//那就表示arr序列还有更大的元素(一个或多个)没有放进reg序列,所以这一步就是接着放
while (start1 <= end1)
reg[k++] = arr[start1++]; //这一步和上面一样
while (start2 <= end2)
reg[k++] = arr[start2++];
//把已经有序的reg序列放回arr序列中
for (k = start; k <= end; k++)
arr[k] = reg[k];
} void MergeSort(int arr[], const int len) {
//创建一个同样长度的序列,用于临时存放
int reg[len];
Merge(arr, reg, 0, len - 1);
}

过程解释都写在了注释里

归并排序的时间复杂度都是O(nlogn),并且适用于元素较多的时候排序

参考资料

1 《数据结构(C++版)》
2 维基百科

常见排序算法C++总结的更多相关文章

  1. 常见排序算法(附java代码)

    常见排序算法与java实现 一.选择排序(SelectSort) 基本原理:对于给定的一组记录,经过第一轮比较后得到最小的记录,然后将该记录与第一个记录的位置进行交换:接着对不包括第一个记录以外的其他 ...

  2. JS常见排序算法

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  3. JavaScript版几种常见排序算法

    今天发现一篇文章讲“JavaScript版几种常见排序算法”,看着不错,推荐一下原文:http://www.w3cfuns.com/blog-5456021-5404137.html 算法描述: * ...

  4. 常见排序算法(JS版)

    常见排序算法(JS版)包括: 内置排序,冒泡排序,选择排序,插入排序,希尔排序,快速排序(递归 & 堆栈),归并排序,堆排序,以及分析每种排序算法的执行时间. index.html <! ...

  5. 常见排序算法-Python实现

    常见排序算法-Python实现 python 排序 算法 1.二分法     python    32行 right = length-  :  ]   ):  test_list = [,,,,,, ...

  6. python常见排序算法解析

    python——常见排序算法解析   算法是程序员的灵魂. 下面的博文是我整理的感觉还不错的算法实现 原理的理解是最重要的,我会常回来看看,并坚持每天刷leetcode 本篇主要实现九(八)大排序算法 ...

  7. python——常见排序算法解析

    算法是程序员的灵魂. 下面的博文是我整理的感觉还不错的算法实现 原理的理解是最重要的,我会常回来看看,并坚持每天刷leetcode 本篇主要实现九(八)大排序算法,分别是冒泡排序,插入排序,选择排序, ...

  8. 常见排序算法总结 -- java实现

    常见排序算法总结 -- java实现 排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序. 线性时间 ...

  9. 常见排序算法题(java版)

    常见排序算法题(java版) //插入排序:   package org.rut.util.algorithm.support;   import org.rut.util.algorithm.Sor ...

  10. [算法] 常见排序算法总结(C语言版)

    常见排序算法总结 本文对比较常用且比较高效的排序算法进行了总结和解析,并贴出了比较精简的实现代码,包括选择排序.插入排序.归并排序.希尔排序.快速排序等.算法性能比较如下图所示: 1 冒泡排序 基本原 ...

随机推荐

  1. Javascript 基础编程练习一

    Javascript 基础互动编程,这篇练习结合了function 函数名(), onclick 时间, prompt输入窗口, window.open和confirm窗口, 任务 1.新窗口打开时弹 ...

  2. poj 1469(二分图 最大匹配)

    这道题让我认识到了c++cin,cout确实会使其超时,还是我用的c printf吧 #include<cstdio> #include<iostream> #include& ...

  3. LDAP验证用户名和密码

    测试环境:VS2008, NET Framework 3.5 公司打算改用LDAP来存储用户名和密码,现在用C#测试下如何能拿到LDAP中的用户名,并检测用户密码是否正确.即输入用户名和密码,可以检验 ...

  4. sqlserver字符串拆分(split)方法汇总

    --方法0:动态SQL法declare @s varchar(100),@sql varchar(1000)set @s='1,2,3,4,5,6,7,8,9,10'set @sql='select ...

  5. 5G关键技术研究方向

    对于还没体验4G移动通信魅力的国内的移动通信用户而言,5G也许还是镜中花,雾中月:但对于科研界而言,5G研究已经启程,三星电子5月份宣布,率先开发出了首个基于5G核心技术的移动传输网络,实现每秒1Gb ...

  6. springmvc的ModelAndView的简单使用

    参考:http://blog.csdn.net/zzjjiandan/article/details/34089313 先上图: MAVTest.java package com.wyl; impor ...

  7. python 常用模块及方法

    ******************** PY核心模块方法 ******************** os模块: os.remove()         删除文件 os.unlink()        ...

  8. 为SQL Server 增加链接到SQL Server 的链接服务器

    整体的分析一下好有一个思路.我们的目的是完成一个到远程服务器的链接. 第一:我们要知道这台服务器在哪(也就是要知道它的IP地址,如果是在同一个网络中知道它的计算机名也是可以的.因为一台服务器上可以安装 ...

  9. 在 Windows Azure 网站中配置动态 IP 地址限制

    我们最近对 Windows Azure 网站进行了升级,并启用了IIS8的动态 IP 限制模块.现在,开发人员可以为其网站启用并配置动态 IP 限制功能(或简称 DIPR). 可以通过以下链接查看此 ...

  10. java常用日期函数总结

    请记得要引入java.util.Date和java.text.SimpleDateFormat两个包 1.计算某一月份的最大天数 Calendar time=Calendar.getInstance( ...