码迷,mamicode.com
首页 > 编程语言 > 详细

常见排序算法及其C++实现

时间:2020-03-11 12:40:11      阅读:71      评论:0      收藏:0      [点我收藏+]

标签:play   复杂   改变   数据交换   状态   排序算法   not   堆排序   参与   

对常见排序算法进行总结,下图可做参考:

技术图片

在介绍排序算法之前先明确几个概念:

1、时间复杂度:从序列的初始状态到最终排序好的结果状态所花费的时间度量,主要取决于变换、移位等操作语句的执行次数。

2、空间复杂度:从序列的初始状态到最终状态所花费的空间开销,即排序过程中所需要开辟的新的内存空间。

3、稳定性:排序算法是否会改变大小相等元素的相对次序,比如在原序列中r[i]=r[j]、且r[i]在r[j]之前,而排序后r[i]仍在r[j]之前,则该排序算法是稳定的。

4、内部\外部排序:内部排序是指不需要开辟新的数组空间,在原先序列的内存中即可完成排序;而外部排序需要借助新的内存空间。

下面依次介绍,并贴上自己的C++实现代码(以从小到大排列为例):

一、冒泡排序

原理:从前往后访问要排序的序列,每次比较相邻两个元素,若相对位置不符合排序要求,则将它们互换。

需要两层循环实现,外层循环表示排序的趟数,n个数据需要n-1趟,外层每次循环结束都会有一个最大的元素“下沉”到序列尾,而小元素则随着比较慢慢“上浮”,这也是冒泡排序名称的来由。

内层循环表示每趟需要排序的元素,m趟排完后就会有m个元素已经有序,不参与m+1趟排序。

时间复杂度:平均为O(n2)、最好情况为O(n) 、最坏情况为O(n2)

空间复杂度:不需要开辟大量新的内存,仅需一个地址用于交换数据,为O(1)

实现代码:

 1 //交换元素
 2 void Swap(int &a, int &b)
 3 {
 4     int useValue = 0;
 5     useValue = a;
 6     a = b;
 7     b = useValue;
 8 }
 9 //冒泡排序
10 void BubbleSort(vector<int> &arr)
11 {
12     for (int i = 0; i < arr.size() - 1; i++)
13     {
14         for (int j = 0; j < arr.size() -1 - i; j++)
15         {
16             if (arr[j] > arr[j + 1]) Swap(arr[j + 1], arr[j]);
17         }
18     }
19 }
20 int main()
21 {
22     vector<int> arr = {5, 5, 6, 12, 1, 12, 23, 19, 20, 24, 19, 19, 19, 19, 15, 15, 3, -2};
23     BubbleSort(arr);   //冒泡排序
24     for (auto ele : arr) cout << ele << " ";
25     cout << endl;
26     return 0;
27 }

二、选择排序

原理:遍历序列找到当前序列中最小元素的位置并记录,将其与序列最前面元素交换,得到一部分有序序列,下次遍历仅遍历后面无序的序列,直到所有元素均有序。这种排序方法避免了冒泡排序中数据交换次数过多的问题。

也需要两层循环实现,每趟排序使最小的元素上浮到本次排序的最前面,下一趟排序时,已经有序的元素不再参与。

时间复杂度:因为不管是否序列已有序,都要比较并记录位置,故平均情况、最好情况、最坏情况均为O(n2)

时间复杂度:O(1)

实现代码:

 1 //交换元素
 2 void Swap(int &a, int &b)
 3 {
 4     int useValue = 0;
 5     useValue = a;
 6     a = b;
 7     b = useValue;
 8 }
 9 //选择排序
10 void SelectSort(vector<int> &arr)
11 {
12     for (int i = 0; i < arr.size(); i++)
13     {
14         int location = i;
15         for (int j = i + 1; j < arr.size(); j++)
16         {
17             if (arr[j] < arr[location]) location = j;
18         }
19         Swap(arr[i], arr[location]);
20     }
21 }
22 int main()
23 {
24     vector<int> arr = {5, 5, 6, 12, 1, 12, 23, 19, 20, 24, 19, 19, 19, 19, 15, 15, 3, -2};
25     SelectSort(arr);      //选择排序
26     for (auto ele : arr) cout << ele << " ";
27     cout << endl;
28     return 0;
29 }

三、插入排序

 原理:构建有序序列,对于未排序的无序部分,遍历有序部分并找合适的地方插入,直到所有元素均已有序。

需要两层循环,外层循环表示比较的趟数,排完m趟就会有m个元素已经有序,并放置于序列前面部分,下一趟会遍历这m个元素,并将m+1个元素插入到它们中合适的位置;内层循环表示这一趟已经有序元素的个数。

插入排序可以借助外部内存实现,那样更好理解一点,但是也可以直接内部排序。

时间复杂度:平均为O(n2)、最好情况为O(n) 、最坏情况为O(n2)

空间复杂度:O(1)

实现代码:

 1 //插入排序
 2 void InsertSort(vector<int> &arr)
 3 {
 4     for (int i = 0; i < arr.size(); i++)
 5     {
 6         int j, tmp = arr[i];
 7         for (j = i; j > 0; j--)
 8         {
 9             if (arr[j - 1] <= tmp) break;
10             else arr[j] = arr[j - 1];
11         }
12         arr[j] = tmp;
13     }
14 }
15 int main()
16 {
17     vector<int> arr = {5, 5, 6, 12, 1, 12, 23, 19, 20, 24, 19, 19, 19, 19, 15, 15, 3, -2};
18     InsertSort(arr);    //插入排序
19     for (auto ele : arr) cout << ele << " ";
20     cout << endl;
21     return 0;
22 }

四、希尔排序

原理:加强版的插入排序,先将整个待排序的序列分割成为若干子序列,分别进行直接插入排序,待整个序列中的记录"基本有序"时,再对全体记录进行依次直接插入排序。避免了插入排序每次只能将数据移动一位的缺陷。

需要设定一个希尔序列增量t,如果序列长度为n,可以设置t的初始值为n/2,但t是递减的,需要设定递减规则但最终t必须要递减到1,可以设置规则为t=t/2。对每一个t值,都会有若干组数据在进行插入排序,当t=1时,整个序列已经基本有序,再排一趟就可以完成整体排序。

举个例子:对12,3,16,8,9,14,1,36,9,11这十个数排序

当t=n/2=5时,对12,14;3,1;16,36;8,9;9,11这五组序列插入排序(增量为5),得到12,1,16,8,9,14,3,36,9,11;

当t=t/2=2时,对12,16,9,3,9和1,8,14,36,11这两组序列插入排序(增量为2),得到3,1,9,8,9,11,12,14,16,36;

当t=t/2=1时,直接对上一步得到的序列插入排序(增量为1),得到1,3,8,9,9,11,12,14,16,36。

时间复杂度:希尔排序的时间复杂度计算很复杂,平均可认为是O(nlogn)即可,最好情况为O(n) 、最坏情况为O(n2)。最上面的表格中可能有错误。

空间复杂度:O(1)

实现代码:

 1 //希尔排序
 2 void ShellSort(vector<int> &arr)
 3 {
 4     int shellValue = arr.size() / 2;  //定义希尔值
 5     while (shellValue >= 1)
 6     {
 7         for (int i = shellValue; i < arr.size(); i++)
 8         {
 9             int j, tmp = arr[i];
10             for (j = i; j / shellValue > 0; j = j - shellValue)
11             {
12                 if (tmp >= arr[j - shellValue]) break;
13                 else arr[j] = arr[j - shellValue];
14             }
15             arr[j] = tmp;
16         }
17         shellValue = shellValue / 2;
18     }
19 }
20 int main()
21 {
22     vector<int> arr = {5, 5, 6, 12, 1, 12, 23, 19, 20, 24, 19, 19, 19, 19, 15, 15, 3, -2};
23     ShellSort(arr);       //希尔排序
24     for (auto ele : arr) cout << ele << " ";
25     cout << endl;
26     return 0;
27 }

五、归并排序

原理:采用分治法的原理,建立在归并操作的基础上。一般是自上而下的递归,将初始序列分为两半,两半再分为四份,四份分为八份.......直到每一份仅含一个元素,然后两个相邻的元素比较,按大小排序得到一组,一组再与相邻的组归并得到更大的组,更大的组再与其他组归并,直到所有元素均已有序。

举个例子表示归并的方式:归并2,8,14,20,21和1,9,15两组序列,需要先开辟新的内存空间,然后按大小顺序将元素放入,先放1,再放2,8,接着是14..........直到得到1,2,8,9,14,15,20,21完成归并操作。

归并排序需要开辟新的内存,所以是一种外部排序。

时间复杂度:递归过程可看作利用了二叉树结构,共需要nlogn次完成分割,每次比较N次,故平均情况、最好情况、最坏情况均为O(nlogn)

空间复杂度:O(n)

实现代码:

 1 //归并排序
 2 vector<int> MergeSort(vector<int> &arr)
 3 {
 4     if (arr.size() < 2) return arr;
 5     else
 6     {
 7         int middle = arr.size() / 2;
 8         return Merge(MergeSort(vector<int>(arr.begin(), arr.begin() + middle)), MergeSort(vector<int>(arr.begin() + middle, arr.end())));
 9     }
10 }
11 //归并排序中具体归并过程
12 vector<int> Merge(vector<int> left, vector<int> right)
13 {
14     vector<int> result;
15     vector<int>::iterator leftVec = left.begin(), rightVec = right.begin();
16     while (leftVec != left.end() && rightVec != right.end())
17     {
18         result.push_back((*leftVec <= *rightVec) ? (*leftVec++) : (*rightVec++));
19     }
20     while (leftVec != left.end()) result.push_back(*leftVec++);
21     while (rightVec != right.end()) result.push_back(*rightVec++);
22     return result;
23 }
24 int main()
25 {
26     vector<int> arr = {5, 5, 6, 12, 1, 12, 23, 19, 20, 24, 19, 19, 19, 19, 15, 15, 3, -2};
27     vector<int> result = MergeSort(arr);      //归并排序
28     for (auto ele : result) cout << ele << " ";
29     cout << endl;
30     return 0;
31 }

六、快速排序

原理:在元素中挑出一个“基准”元素,拿其他元素与之比较,将基准放在中间,比基准小的都放在左边,大的都放在右边,然后递归对基准左、右边序列再进行这样的排序,直到所有元素有序。

快速排序也是“分治法”的一种实现,它是平均情况下最快、效率最高的排序算法,虽然最坏状况下需要 Ο(n2) 次比较,但这种状况并不常见。快排通常明显比其他 Ο(nlogn) 算法更快,因为它的内部循环可以在大部分的架构上很有效率地被实现出来,而且O(nlogn) 记号中隐含的常数因子很小,比复杂度稳定等于 O(nlogn) 的归并排序要小很多。

时间复杂度:平均为O(nlogn)、最好情况为O(nlogn) 、最坏情况为O(n2)

空间复杂度:需要记录递归过程,故空间复杂度为递归深度O(logn)

实现代码:(通常情况下由多个函数辅助实现,但也可以由一个函数单个实现)

 1 //交换元素
 2 void Swap(int &a, int &b)
 3 {
 4     int useValue = 0;
 5     useValue = a;
 6     a = b;
 7     b = useValue;
 8 }
 9 //快速排序
10 void QuickSort(vector<int> &arr, int left, int right)
11 {
12     if (right - left >= 0)
13     {
14         int midValue = arr[left - 1];
15         int midLocation = left - 1;
16         int rightLocation = right;
17 
18         while (left != right)
19         {
20             while (arr[left] <= midValue && left < right) left++;
21             while (arr[right] >= midValue && left != right) right--;
22             Swap(arr[left], arr[right]);
23         }
24         if (arr[left] >= midValue) left--; right--;
25         if (arr[left] < midValue) Swap(arr[midLocation], arr[left]);
26         QuickSort(arr, midLocation + 1, left - 1);
27         QuickSort(arr, left + 2, rightLocation);
28     }
29 }
30 int main()
31 {
32     vector<int> arr = {5, 5, 6, 12, 1, 12, 23, 19, 20, 24, 19, 19, 19, 19, 15, 15, 3, -2};
33     QuickSort(arr, 1, arr.size() - 1);  //快速排序
34     for (auto ele : arr) cout << ele << " ";
35     cout << endl;
36     return 0;
37 }

七、堆排序

 原理:要想介绍堆排序的原理,就需要先介绍什么是堆及堆的常见操作。

在数据结构中有一种树结构称为完全二叉树:若设二叉树的深度为n,则除第n层外其他各层的节点数都达到最大个数,且第n层上的所有节点都集中在最左侧。

堆就是完全二叉树,且一般情况下堆分为最大堆和最小堆,最大堆中每个父节点元素都大于或等于两个子节点,最小堆则相反。所以最大堆中根节点就是整个序列中的最大值,最小堆中是最小值。

比如下图就是一个最小堆:

技术图片

堆可以用数组结构来存储,按从上到下、从左到右的顺序,对应于数组的下标编号。节点i的左子节点为2i+1,右子节点为2i+2,父节点为(i-1)/2。

对于堆,常见的操作有上浮、下沉、插入、弹出、取顶和堆排序,本文仅介绍堆排序,想了解堆其他操作的可以看这篇:https://www.cnblogs.com/schips/p/10660163.html

堆排序的思路其实很简单,如果想从小到大排序,则构建最大堆,首先对全部n个元素构建最大堆,此时根节点为最大值,将根节点取出与最后一个节点交换,然后最后的节点不再参与运算,对剩下的n-1个元素构建堆,依次操作,直到所有元素有序。

堆排序中关键点在于构建堆的过程,可以理解为从最后一个父节点开始,依次往上对每个节点进行下沉。

时间复杂度:平均情况、最好情况、最坏情况均为O(nlogn)

空间复杂度:O(1)

实现代码:(构建堆过程中下沉操作可以用while循环实现,这里我使用了递归方式)

 1 //交换元素
 2 void Swap(int &a, int &b)
 3 {
 4     int useValue = 0;
 5     useValue = a;
 6     a = b;
 7     b = useValue;
 8 }
 9 //堆排序
10 void HeapSort(vector<int> &arr)
11 {
12     int sizeBegin = arr.size();
13     for (int i = 0; i < sizeBegin; i++)
14     {
15         BuildHeap(arr, sizeBegin - i);  //构建最大堆
16         Swap(arr[0], arr[sizeBegin - 1 - i]);
17     }
18 }
19 //构建最大堆
20 //参数为序列的引用和序列长度
21 void BuildHeap(vector<int> &arr, int size)
22 {
23     if (size > 1)  //仅当序列中有至少两个元素时才构建堆
24     {
25         for (int i = size / 2 - 1; i >= 0; i--) AdjustHeap(arr, size, i);
26     }
27 }
28 //调整堆
29 //参数为序列的引用、序列长度和要调整节点的位置
30 void AdjustHeap(vector<int> &arr, int size, int location)
31 {
32     int leftChild = location * 2 + 1;  //左子节点
33     int rightChild = location * 2 + 2;   //右子节点
34     if (rightChild < size)   //表示该节点既有左子节点,也有右子节点
35     {
36         int maxChild = arr[leftChild] > arr[rightChild] ? arr[leftChild] : arr[rightChild];
37         if (arr[location] < maxChild)
38         {
39             if (maxChild == arr[leftChild])
40             {
41                 Swap(arr[location], arr[leftChild]);
42                 AdjustHeap(arr, size, leftChild);
43             }
44             else
45             {
46                 Swap(arr[location], arr[rightChild]);
47                 AdjustHeap(arr, size, rightChild);
48             }
49         }
50     }
51     else if (leftChild < size)   //只有左子节点
52     {
53         if (arr[location] < arr[leftChild]) Swap(arr[location], arr[leftChild]);
54     }
55 }
56 int main()
57 {
58     vector<int> arr = {5, 5, 6, 12, 1, 12, 23, 19, 20, 24, 19, 19, 19, 19, 15, 15, 3, -2};
59     HeapSort(arr);      //堆排序
60     for (auto ele : arr) cout << ele << " ";
61     cout << endl;
62     return 0;
63 }

八、交换排序

原理:类似于选择排序和冒泡排序,由两层循环完成,外部循环表示排序的趟数,每排一趟找出最小值放到最前面,依次进行直到所有元素有序。

以前经常将这种方法与冒泡排序混淆,其实两者还是有区别的,冒泡排序是相邻的两个数比较并交换数据,而交换排序是用最前面的元素与所有元素比较,如果顺序不符合要求就交换。

与选择排序也很类似,而选择排序省略了数据交换的过程,交换排序需要很多数据交换操作。

时间复杂度:平均为O(n2)、最好情况为O(n) 、最坏情况为O(n2)

空间复杂度:O(1)

实现代码:

 1 //交换元素
 2 void Swap(int &a, int &b)
 3 {
 4     int useValue = 0;
 5     useValue = a;
 6     a = b;
 7     b = useValue;
 8 }
 9 //交换排序
10 void ExchangeSort(vector<int> &arr)
11 {
12     for (int i = 0; i < arr.size() - 1; i++)
13     {
14         for (int j = i + 1; j < arr.size(); j++)
15         {
16             if (arr[i] > arr[j]) Swap(arr[i], arr[j]);
17         }
18     }
19 }
20 int main()
21 {
22     vector<int> arr = {5, 5, 6, 12, 1, 12, 23, 19, 20, 24, 19, 19, 19, 19, 15, 15, 3, -2};
23     ExchangeSort(arr);  //交换排序
24     for (auto ele : arr) cout << ele << " ";
25     cout << endl;
26     return 0;
27 }

除了以上几种排序,常见的还有计数排序、桶排序与基数排序,但应用场景可能比较局限,就不做介绍。感兴趣的可以参考这个链接:https://www.runoob.com/w3cnote/ten-sorting-algorithm.html

本文参考的博文除了以上两个外,还有以下链接,表示感谢:

https://blog.csdn.net/m0_37962600/article/details/81475585

https://blog.csdn.net/weixin_43956598

常见排序算法及其C++实现

标签:play   复杂   改变   数据交换   状态   排序算法   not   堆排序   参与   

原文地址:https://www.cnblogs.com/MatthewHome/p/12459662.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!