几种常见的排序方法整理

几种常见的排序方法整理

一、直接插入排序

插入排序是一种简单直观的排序算法。通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在从后向前扫描的过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

算法：
将需要排序的数列看成一个数组，i初始化指向数组1号下标，j初始化指向数组0号下标，和i对应数值进行比较，比较一次往后退一步，如果j对应数值大于i对应数值，数值进行交换，直到i前面的数字都比它小，i往后走。

时间复杂度：（1）最坏情况是O（n^2）
(2) 最好情况是有序情况：O（n）
空间复杂度：O（1）
稳定性：稳定

代码：

public static void insertSort(int[] array){int tmp = 0;int j ;for(int i=1; i<array.length; i++){tmp = array[i];for( j=i-1; j>=0; j--){if(array[j] > tmp){array[j+1] = array[j]; //调换位置}else{// array[j+1] = tmp;   //不用换，放回原位break;}}array[j+1] = tmp;   //不用换，放回原位}
}

二、希尔排序

希尔排序也是插入排序的一种，它是采用分组的思想，对每组进行插入排序。

代码：

public static void shellSort(int[] array){int[] drr = {5,3,1};for(int i = 0; i<drr.length; i++){shell(array,drr[i]);}
}
public static void shell(int[] array,int gap){int tmp = 0;for(int i = gap; i<array.length; i++){tmp = array[i];int j;for(j=i-gap; j>=0; j-=gap){if(array[j]>tmp){array[j+gap] = array[j];}else {break;}}array[j+gap]=tmp;}}

三、选择排序

算法思想：
先从数组第一个数字开始，把这个数字和这个数字之后的所有数字进行比较，如果比这个数字小就交换，然后把数组第二个数字和它之后的所有数字进行比较，比他小就交换，以此类推，直到数组最后一个数字。

代码：

 public static void selectSort(int[] array){for(int i=0; i<array.length; i++){for(int j=i+1; j<array.length; j++){if(array[j]<array[i]){int tmp = array[i];array[i] = array[j];array[j] = tmp;}}}}

时间复杂度：O（n^2）
空间复杂度：O（1）
稳定性：不稳定

四、堆排序

首先将数组建立成一个大根堆，从数组最后一个数字开始，和数组0号下标数字进行交换，然后采用向下调整法。接着将倒数第二个数字和数组0号下标数字进行交换，然后采用向下调整法，以此类推，直到0号下标数字。

代码：

public static void heapSort(int[] array){creatHeap(array);int end = array.length-1;while(end>0){int tmp = array[end];array[end] = array[0];array[0] = tmp;adjustDown(array,0,end);end--;}
}//建立大根堆
public static void creatHeap(int[] array){for(int i = (array.length-1-1)/2; i>=0; i--){adjustDown(array,i,array.length);}
}
//向下调整法
public static void adjustDown(int[] array,int root,int len){int patrnt = root;int child = root*2+1;//最起码有左孩子while(child<len){//有右孩子且左孩子小于右孩子，进行交换if(child+1<len && array[child]<array[child+1]){int tmp = array[child];array[child] = array[child+1];array[child+1] = tmp;}//如果左孩子大于父亲结点，要进行交换if (array[child] > array[patrnt]) {int tmp = array[child];array[child] = array[patrnt];array[patrnt] = tmp;patrnt = child;child = patrnt*2+1;}else{break;}}
}

时间复杂度：O（nlogn）
空间复杂度：O（1）
稳定性：不稳定

五、冒泡排序

冒泡排序是每一趟都从第一个数字开始，将数组每一个数字和它后一个数字进行比较，比它小就交换。如此往复，直到序列有序。

代码：

public static void bubleSort(int[] array){//i表示趟数for(int i=0; i<array.length-1; i++){for(int j=0; j<array.length-1-i; j++){if(array[j]>array[j+1]){int tmp = array[j];array[j] = array[j+1];array[j+1] = tmp;}}}
}

时间复杂度：O（n^2）
空间复杂度：O（1）
稳定性：不稳定

六、快速排序

快速排序，又称划分交换排序。通过一趟排序将要排序的数据分割成两部分，然后再按此方法对两部分数据分别进行快速排序，以此达到整个数据变成有序序列
步骤为：
（1）从数列找出一个元素，称为“基准”。
（2）重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区操作。
（3）把基准元素左边的数值序列用递归的方法进行快速排序，右边序列也如此。直到整个序列有序。

代码：

public static void quickSort(int[] array){quick(array,0,array.length-1);
}
public static void quick(int[] array,int left,int right){if(left>=right){return;}int par = partition(array,left,right);//递归排序左边和右边quick(array,left,par-1);quick(array,par+1,right);}
//找基准
public static int partition(int[] array,int left,int right){int tmp = array[left];while(left<right){while(left<right && array[right]>=tmp){right--;}array[left]=array[right];while(left<right && array[left]<=tmp) {left++;}array[right] = array[left];}array[left] = tmp;return left;
}

时间复杂度：O（nlogn）
最坏情况：1 2 3 4 5 6 7 8 9 / 9 8 7 6 5 4 3 2 1 ：O（n^2）
空间复杂度：O(logn)~O（n）
稳定性：不稳定

七、归并排序

归并排序是采用分治法，思想就是先将数组分解为一个一个的数（将数组从中间一分为二，然后递归分解左边和右边），再合并数组。
合并的基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指向就往后移一位。然后比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

代码：

public static void mergeSort(int[] array){mergeSortIn(array,0,array.length-1);
}
//分解
public static void mergeSortIn(int[] array,int low,int high){if(low>=high){return;}//分解（从数组中间一分为二，直至分解为一个一个的数）int mid = (low+high)>>>1; //右移相当于除2mergeSortIn(array,low,mid);mergeSortIn(array,mid+1,high);//归并（将一个一个的数按序归并）merge(array,low,mid,high);
}//归并
public static void merge(int[] array,int low,int mid,int high){int s1 = low;int s2 = mid+1;int len = high-low+1; //新数组的长度int[] ret = new int[len]; //新建一个数组用来存放归并排序后的数int i = 0; //表示ret数组的下标while (s1<=mid && s2<=high){if(array[s1] <= array[s2]){ret[i++] = array[s1++];}else {ret[i++] = array[s2++];}}while (s1<=mid){ret[i++] = array[s1++];}while (s2<=high){ret[i++] = array[s2++];}for(int j= 0; j<ret.length; j++){array[j+low] = ret[j];}
}

时间复杂度：nlogn
空间复杂度：O(n)
稳定性：稳定

几种常见的排序方法整理相关推荐

java中的排序方法_Java中8种常见的排序方法
本博主要介绍Java中几种常见的排序算法: /* 排序方法的演示 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分 ...
python中的排序方法都有哪些_几种常见的排序方法总结（Python）
几种常见的排序算法总结(Python) 排序算法:是一种能将一串数据依照特定顺序进行排序的一种算法. 稳定性:稳定排序算法会让原本有相等键值的记录维持相对次序.也就是如果一个排序算法是稳定的,当有两个 ...
python五种常见的排序方法是_python中序列的排序，sorted方法、reversed方法的使用...
简介 INTRODUCTION 包括字典排序.列表排序.升序.降序.逆序一.基础概念我们知道python中的内建序列包括字典.列表.元组.字符串等,序列是python中最基本的数据结构. 列表.元 ...
python五种常见的排序方法是_常见的经典的排序方法的实现（Python）
常见的经典算法的实现首先来一张图,这张图总结了常见的几种排序算法的时间复杂度和空间复杂度的对比.现对常见的几种算法进行实现,以备后需.图片来源:专知 1. 快速排序思路先寻找一个基准数,然后接下 ...
排序1：几种基本的排序方法
在数据结构课里,一般会将查找和排序放在一起,大部分人都会感觉查找比排序容易.但是我们研究过算法之后就会发现查找远远难于排序,因为常见的排序方法是相对固定的.而查找除了最基本的二分查找外,还包含非常广的 ...
java util 排序_Java中常见的排序方法
本博主要介绍Java中几种常见的排序算法: /* 排序方法的演示 1)插入排序(直接插入排序.希尔排序) 2)交换排序(冒泡排序.快速排序) 3)选择排序(直接选择排序.堆排序) 4)归并排序 5)分 ...
【机器学习】交叉验证详细解释+10种常见的验证方法具体代码实现+可视化图
[机器学习]交叉验证详细解释+10种常见的验证方法具体代码实现+可视化图一.使用背景由于在训练集上,通过调整参数设置使估计器的性能达到了最佳状态:但在测试集上可能会出现过拟合的情况. 此时,测试集 ...
七种常见的排序算法总结
目录引言 1.什么是排序? 2.排序算法的目的是什么? 3.常见的排序算法有哪些? 一,插入排序 1.基本思想 2.代码实现 3.性能分析 4.测试二,希尔排序(缩小增量排序) 1.基本思想 2. ...
排序方法整理Java - 冒泡排序、选择排序、插入排序、快速排序
/*** 排序方法整理* @author zhyea**/ public class Sort {/*** 冒泡排序,从小到大.* 冒泡排序是比较相邻的两个元素,若顺序错误,则执行交换.循环走访序列直 ...

几种常见的排序方法整理

几种常见的排序方法整理相关推荐

最新文章

热门文章