数据结构与算法——排序
文章目录
- 1.冒泡排序
- 2.选择排序
- 3.插入排序
- 4.快速排序
- 5.堆排序
- 6.归并排序
- 7.希尔排序
1.冒泡排序
将一个数组从小到大排序，一次循环（从头开始遍历，将相邻的两个数值比较，如果前面一个大于后面的数字，交换这两个数字）可以将循环数组中的最大值放在最后面，经过多次冒泡就可以完成排序
| 平均时间复杂度 | O(n2)O(n^2)O(n2) |
| 最坏时间复杂度 | O(n2)O(n^2)O(n2) |
| 最好时间复杂度 | O(n)O(n)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(nlog2n)O(nlog_2 n)O(nlog2n) |
| 最坏时间复杂度 | O(n2)O(n^2)O(n2) |
| 最好时间复杂度 | O(nlog2n)O(nlog_2 n)O(nlog2n) |
| 空间复杂度 | O(nlog2n)O(nlog_2 n)O(nlog2n) |
#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(nlog2n)O(nlog_2 n)O(nlog2n) |
| 最坏时间复杂度 | O(nlog2n)O(nlog_2 n)O(nlog2n) |
| 最好时间复杂度 | O(nlog2n)O(nlog_2 n)O(nlog2n) |
| 空间复杂度 | O(n)O(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;}
参考链接：
[算法]六分钟彻底弄懂希尔排序，简单易懂
白话经典算法系列之三 希尔排序的实现
数据结构与算法——排序相关推荐
- 数据结构与算法 / 排序算法 / 堆排序
一.定义 借助堆结构实现的排序算法被称为堆排序. 二.过程说明 1.建堆 (1)方法1 原地建堆,对于数组来说,从前往后:对于树来说,从下向上. 将数组的第一个元素作为堆顶,第二个元素做向堆中插入数据 ...
- 数据结构与算法 / 排序算法（3）
一.桶排序(Bucket sort) 1.原理 将要排序的数据分到几个有序的桶里,每个桶里的数据再进行排序.桶内的数据排序完毕之后,再把桶里的数据依次取出,组成的序列就是有序的了. 2.原地排序? 属 ...
- python 数据结构与算法——排序
文章目录 排序的分类 排序的复杂度 python 实现 冒泡排序 选择排序 插入排序 希尔排序 归并排序 堆排序 快排 树排序 线性时间排序算法 计数排序 桶排序 桶排序的复杂度分析 基数排序 排序的 ...
- java 数据结构和算法 排序
排序算法 排序算法的介绍 算法的时间复杂度 **度量一个程序(算法)执行时间的两种方法** **时间频度** **时间复杂度** **常见的时间复杂度** 平均时间复杂度和最坏时间复杂度 算法的空间复 ...
- 图综合练习--拓扑排序_03 数据结构与算法 - 排序
1. 冒泡排序 Bubble Sort 基本思想 给定一个数组,这些元素将通过相互之间的比较,按照大小顺序一个个地像气泡一样浮出水面 实现 每一轮,从头部开始,每两个元素比较大小进行交换,直到这一轮中 ...
- 数据结构与算法-排序与查找（java描述）
在软件开发中,有两个常见的任务,一个是某一组中查找某个特定的元素,另一个是将某一组元素按照特定的顺序排序.我们可以使用多种算法来完成这些任务,而这些算法的差异也是值得我们去仔细研究的,接下来我们探究一 ...
- 数据结构与算法 / 排序算法（2）
一.归并排序 1.原理 采用分治思想.将数组分成前后两部分,先将这两部分进行排序,然后再将二者合并即可. 2.原地排序? 不属于原地排序.因为每次合并都需要申请大小为 n 的临时数组用于保存合并之后的 ...
- 数据结构与算法 / 排序算法（1）
零.前言 1.常用的排序算法总结 排序算法种类 时间复杂度 是否基于比较 冒泡.插入.选择 O(n^2) √ 快排.归并 O(nlogn) √ 桶.计数.基数 O(n) × 2.算法的内存消耗 - 原 ...
- js 实现2的n次方计算函数_JS中数据结构与算法---排序算法
排序算法的介绍 排序也称排序算法 (Sort Algorithm),排序是将 一组数据 , 依指定的顺序 进行 排列的过程 . 排序的分类 内部排序 : 指将需要处理的所有数据都加载 到 内部存储器( ...
最新文章
- oracle9i安装不上,终于成功安装oracle9i了(Cent OS 4.0＋oracle9204）
- 问一下，线程池里面到底该设置多少个线程？
- MCSE2003学习之六
- JS获取当前对象大小以及屏幕分辨率等
- 好全的Android面试题
- A+B Problem（洛谷-P1001）
- 笨方法“学习python笔记之print换行
- 20190720学习小结
- 海量数据挖掘MMDS week6: MapReduce算法（进阶）
- linux crontab 每隔一段时间执行一次
- 首次曝光！支付宝支付加密规则梳理，写的太好了！
- 【Spring揭秘】Spring简介
- Mac下实现Word文档批量转换为PDF
- 计算机语言论文标准范文,计算机语言论文大纲范文模板 计算机语言论文提纲怎么写...
- 【Linux operation 07】 - SUSE 12 SP5系统挂载硬盘
- Linux——进程间通信（管道）
- 2010上机二 中国象棋马走日
- python log日志打印两遍_python打印log重复问题
- 2020鸿蒙系统pc版,华为将在2020年发布鸿蒙操作系统2.0版，应用于创新国产PC电脑...
- python，ffprobe获取视频信息