八大算法总结
【摘要】
文章目录
算法稳定性插入排序直接插入排序折半插入排序希尔排序
交换排序冒泡排序快速排序
选择类排序简单选择排序堆排序
归并排序基数排序外部排序
算法
稳定性
...
算法
稳定性
选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，
冒泡排序、插入排序、归并排序、基数排序是稳定的排序算法
插入排序
有一个已经 有序 的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法，插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为 O(n^2)。是稳定的排序方法。
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤 3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤 2 ~ 5，直至最后一个元素。
import java.util.Arrays;
public class InsertSort {
private static void insertSort(int[] arr) {
int j; // 已排序列表下标
int t; // 待排序元素
for (int i = 1; i < arr.length; i++) {
if (arr[i] < arr[i - 1]) {
t = arr[i]; // 赋值给待排序元素
for (j = i - 1; j >= 0 && arr[j] > t; j--) {
arr[j + 1] = arr[j]; // 从后往前遍历已排序列表，逐个和待排序元素比较，如果已排序元素较大，则将它后移
}
arr[j + 1] = t; // 将待排序元素插入到正确的位置
}
}
}
public static void main(String[] args) {
int[] ints = {5, 3, 4, 1, 2};
insertSort(ints);
System.out.println(Arrays.toString(ints));
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
直接插入排序
void InsertSort(ElemType A[],int n){
int i,j;
for(i=2;i<=n;i++)
if(A[i]<A[i-1]){
A[0]=A[i]; //复制为哨兵，A[0]不存放元素
for(j=i-1;A[0]<A[j];--j)
A[j+1]=A[j]; //所有比待插入元素值大的都往后移一位，腾出空位
A[j+1]=A[0]; //复制到插入位置
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
折半插入排序
void InsertSort(ElemType A[],int n){
int i,j,low,high,mid;
for(i=2;i<=n;i++){ //i记录的是待插入的元素下标，也就是说i-1之前的元素都是有序的
A[0]=A[i]; //保存待插入的值
low=1;high=i-1;
while(low<=high){ //折半查找
mid=(low+high)/2;
if(A[mid].key>A[0].key) high=mid-1;
else low=mid+1;
}
//找到了待插入的位置 接下来从后往前依次后移元素腾出位置
for(j=i-1;j>=high+1;--j)A[j+1]=A[j];
A[high+1]=A[0]; //因为此时high指向的是待插入位置的前一位
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
希尔排序
void ShellSort (ElemType A[],int n){
int i,j;
for(dk=n/2;dk>=1;dk=dk/2) //初始增量为总长度的一半，之后依次除2且向下取整，
//且最后一次要为1
for(i=dk+1;i<=n;++i)
if(A[i].key<A[i-dk].key){ //A[i].key是待插入的关键字，i-dk之前的都是有序的，如 //果待插入的比有序序列最后一个小， 则需要进行排序(进入if语句块)，如果大则不需要(跳出if语句块)
A[0]=A[i]; //待插入关键字暂存在A[0]
for(j=i-dk;j>0&&A[0].key<A[j].key; j-=dk)
//待插入关键字之前以dk为增量的关键字只要比待插入关键字大的都往后移动dk位
A[j+dk]=A[j];
A[j+dk]=A[0]; //找到了待插入的位置，就将待插入关键字插入这个位置
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
交换排序
冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列， 依次比较两个相邻的元素 ，如果他们的顺序（如从大到小、首字母从 A 到 Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。 这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
import java.util.Arrays;
public class BubbleSort {
public static void sort(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
//如果当前元素比后一位元素大 交换位置
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] ints = {5, 3, 4, 1, 2};
sort(ints);
System.out.println(Arrays.toString(ints));
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
快速排序
快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），简称快排，也是一种排序算法。最早由东尼·霍尔提出。在平均状况下，排序 n 个项目要 O(nlogn) 次比较。在最坏状况下则需要 O(n^2) 次比较，但这种状况并不常见。事实上，快速排序 O(nlogn) 通常明显比其他算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地达成。
- 从数列中挑出一个元素，称为“基准”（pivot），
- 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分割结束之后，该基准就处于数列的中间位置。这个称为分割（partition）操作。
- 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。
- 递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
int Partition(ElemType A[],int low,int high){ //low是当前待排序的序列起始下标，high是末尾下标
ElemType pivot=A[low]; //第一个元素作为枢轴
while(low<high){
while(low<high&&A[high]>=pivot) --high;//先从末尾往前找到第一个比枢轴小的元素
A[low]=A[high]; //用high的元素替换low的元素
while(low<high&&A[low]<=pivot) ++low; //再从开头往后找到第一个比枢轴大的元素
A[high]=A[low]; //用low的元素替换high的元素
}
A[low]=pivot; //枢轴元素存放到最终位置
return low; //返回存放枢轴的最终位置
}
void QuickSort(ElemType A[],int low,int high){
if(low<high){ //low和high值要合法
int pivotpos=Partition(A,low,high);
QuickSort(A,low,pivotpos-1); //分治递归左半部分
QuickSort(A,pivotpos+1,high); //分治递归右半部分
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
import java.util.Arrays;
public class QuickSort {
public static void sort(int[] arr, int head, int tail) {
if (head >= tail || arr == null || arr.length <= 1) {
return;
}
//设置数组的起始位置 i 结束位置j 基准 pivot 为数组的中间
int i = head, j = tail, pivot = arr[(head + tail) / 2];
while (i <= j) {
//当数组小于基准 循环结束后 相当于i所处的位置的值为大于基准的元素
while (arr[i] < pivot) {
++i;
}
//当数组大于基准 循环结束后 相当于j所处的位置的值为小于于基准的元素
while (arr[j] > pivot) {
--j;
}
//如果i<j 那么则将交互i j对应位置的值
if (i < j) {
int t = arr[i];
arr[i] = arr[j];
arr[j] = t;
//将指针继续移动
++i;
--j;
} else if (i == j) {
//如果i=j 那么说明本次排序已经结束 将i++ 如果这里不使用i++ 那么后面的sort(arr,i,tail)将改为arr(arr,i+1,tail)
++i;
}
}
//继续将数组分割
sort(arr, head, j);
sort(arr, i, tail);
}
public static void main(String[] args) {
int[] ints = {5, 3, 4, 1, 2};
sort(ints, 0, ints.length - 1);
System.out.println(Arrays.toString(ints));
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
选择类排序
简单选择排序
void SelectSort(ElemType A[],int n){
for(i=0;i<n-1;i++){ //依次从后面序列中选择当前最小的元素作为第i个元素 最后一个元素不需要排序
min=i; //min存的是当前最小元素所在下标，初值设为第i个
for(j=i+1;j<n;j++) //从第i个元素往后找，一直要找到最后一个元素
if(A[j]<A[min]) min=j; //如果这个值更小，则更新min值为这个更小的元素所在下标
if(min!=i) { //如果第i个元素不是剩下元素最小的，则和最小的进行交换
ElemType temp=A[i];
A[i]=A[min];
A[min]=temp;
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
堆排序
void BuildMaxHeap(ElemType A[],int len){
for(int i=len/2;i>0;i--) AdjustDown(A,i,len); //由数组下标高处往低处 从第一个可能需要调整的非叶结点
// 开始检查，直到根结点(注意根结点下标不是0，是从1开始存储)
}
void AdjustDown(ElemType A[],int k,int len){ //A是存储堆的数组,k是需要检查的结点下标,len是堆中结点个数
A[0]=A[k]; //A[0]暂存这个需要检查的结点值
for(i=2*k;i<=len;i*=2){ //从这个结点的左孩子开始往下比较，
// 如果发生交换，对交换过的结点继续和它的孩子比较
if(i<len&&A[i]<A[i+1])i++; //如果右孩子大一些，就只要考虑和右孩子比较
if(A[0]>=A[i]) break; //如果这个结点的值不小于它的较大孩子结点值 则不需要交换
else{
A[k]=A[i]; //如果这个结点的值小于它的较大孩子
//结点值则将较大的孩子结点值赋值给该结点
k=i; //i赋值给k也就是从i开始继续往下检查 直到所有结点检查结束
}
}
A[k]=A[0]; //检查到最后k的值就是最后一轮交换过的结点位置下标 将该结点换过去
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
归并排序
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法，该算法是采用分治法（
Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
-
申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
-
设定两个指针，最初位置分别为两个已经排序序列的起始位置
-
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
-
重复步骤 3 直到某一指针到达序列尾
-
将另一序列剩下的所有元素直接复制到合并序列尾
import java.util.Arrays;
public class MergeSort {
public static void mergeSort(int[] arrays, int left, int right) {
// 如果数组还可以拆分
if (left < right) {
//数组的中间位置
int middle = (left + right) / 2;
//拆分左边数组
mergeSort(arrays, left, middle);
//拆分右边数组
mergeSort(arrays, middle + 1, right);
//合并
merge(arrays, left, middle, right);
}
}
/**
* 合并数组
*/
public static void merge(int[] arr, int left, int middle, int right) {
//申请合并空间 大小为两个已经排序序列之和
int[] temp = new int[right - left + 1];
//i 和 j为两个已经排好序的数组的起始位置
int i = left;
int j = middle + 1;
int k = 0;
//排序
while (i <= middle && j <= right) {
//将比较小的数组放入合并空间
if (arr[i] < arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
//将左边剩余元素写入合并空间
while (i <= middle) {
temp[k++] = arr[i++];
}
//将右边剩余的元素写入合并空间
while (j <= right) {
temp[k++] = arr[j++];
}
//将排序后的数组写回原来的数组
for (int l = 0; l < temp.length; l++) {
arr[l + left] = temp[l];
}
}
public static void main(String[] args) {
int[] ints = {5, 3, 4, 1, 2};
mergeSort(ints,0,ints.length-1);
System.out.println(Arrays.toString(ints));
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
基数排序
ElemType *B=(ElemType *)malloc((n+1)*sizeof(ElemType)); //辅助数组B(动态分配内存)
void Merge(ElemType A[],int low,int mid,int high){
//表A的两段A[low…mid]和A[mid+1…high]各自有序，将它们合并成一个有序表
for(int k=low;k<=high;k++)B[k]=A[k]; //将A中所有元素复制到B中
for(int i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){ k是归并之后数组的下标计数器
if(B[i]<=B[j]) //比较B的左右两段中的元素
A[k]=B[i++]; //将较小值复制到A中
else
A[k]=B[j++];
}
while(i<=mid) A[k++]=B[i++]; //若第一个表未检测完，直接将剩下的部分复制过来
while(j<=high) A[k++]=B[j++]; //若第二个表未检测完，直接将剩下的部分复制过来
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
外部排序
文章来源: hiszm.blog.csdn.net，作者：孙中明，版权归原作者所有，如需转载，请联系作者。
原文链接：hiszm.blog.csdn.net/article/details/116054171
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）