常见排序算法
以下代码均以升序为例
选择排序
时间复杂度:O(n^2)
(额外)空间复杂度:O(1)
稳定性：非稳定
核心思想：每次遍历查找最值并进行位置交换。如第一轮查找下标1-N-1中比0小的数与0进行交换
代码如下
public static void selectSort(int[] arr){
//时间复杂度O(n^2),空间复杂度O(1)
for(int i=0;i<arr.length;i++){
int minIndex = i;
for(int j=i+1;j<arr.length;j++){
minIndex = arr[j]<arr[minIndex]?j:minIndex;
}
swap(arr,i,minIndex);
}
}
冒泡排序
时间复杂度:O(n^2)
(额外)空间复杂度:O(1)
稳定性：稳定
核心思想：每次遍历过程中比较相邻数组元素大小，将大数排后，如同冒泡，从下往上逐渐变大。
public static void bubbleSort(int[] arr){//不带flag
//时间复杂度O(n^2),空间复杂度O(1)
for(int i=arr.length-1;i>0;i--){
for(int j=0;j<i;j++){
if(arr[j]>arr[j+1]){
swap(arr,j,j+1);
}
}
}
}
插入排序
时间复杂度:O(n^2)
(额外)空间复杂度:O(1)
稳定性：稳定
核心思想：对于第N个元素，相当于将该元素插入前N-1个已经有序数组中。则将其从N-1开始向前比较并交换位置直至找到小于等于的数（这里的等于是稳定性的关键）。
public static void insertSort(int[] arr){
// 时间复杂度与数组有序程度有关，最好O(n),最坏O(n^2),空间复杂度O(1)
// 但是时间复杂度O需要按照最差情况来估计，所以时间复杂度为O(n^2)
for(int i=1;i<arr.length;i++){//0~i-1已经有序
for(int j =i-1;j>=0&&arr[j]>arr[j+1];j--){//循环条件为到达边界或者找到第一个小的
swap(arr,j,j+1);
}
}
}
归并排序
时间复杂度:O(N*logN)
(额外)空间复杂度:O(N)
稳定性：稳定
核心思想：对于已经有序的左半部分(L,M)和右半部分(M+1,R)，借助辅助数组以及双指针进行插入复制（复制较小的，若相等，则复制左半区的数，这是稳定性的关键）
应用：小和(不能保证稳定性)、逆序对
public class MergeSortTest {
public static void merge(int[] arr,int L,int mid,int R){
int[] help = new int[R-L+1];
int k=0,p1=L,p2=mid+1;
while(p1<=mid&&p2<=R){
help[k++] = arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
}
while(p1<=mid){
help[k++] = arr[p1++];
}
while(p2<=R){
help[k++] = arr[p2++];
}
for(int i=0;i<help.length;i++){
arr[L+i] = help[i];
}
}
public static void mergeSort(int[] arr,int L,int R){
if(L==R){
return;
}
int mid = L+((R-L)>>1);
mergeSort(arr,L,mid);
mergeSort(arr,mid+1,R);
merge(arr,L,mid,R);
}
}
快速排序
时间复杂度:O(N*logN)(要求主元为随机选择，当然有特殊的选择策略，保证每次主元的选择让partition具有较好的分隔性质，大概思路为分组+中位数排序，详情参考算法导论)
(额外)空间复杂度:O(logN)（递归栈空间）
稳定性：非稳定
核心思想：select+partition。先选择主元x，将其与最后一个元素进行位置交换，然后利用partition将数组分割为(<x,=x,>x)三个部分，在对<x,>x这两个部分递归执行select+partition操作
public class QuickSortTest {
public static void quickSort(int[] arr,int L,int R){
if(L<R){
swap(arr,L+(int)(Math.random()*(R-L+1)),R);
int[] p = partition(arr,L,R);
quickSort(arr,L,p[0]-1);//p[0]-1为小于区域的右边界索引
quickSort(arr,p[1]+1,R);//p[1]+1为大于区域的左边界索引
}
}
public static void swap(int[] arr,int i,int j){
int tmp = arr[i];
arr[i]=arr[j];
arr[j]=tmp;
}
public static int[] partition(int[] arr,int L,int R){
int less = L-1;//小于区域的右边界
int more = R;//大于区域的左边界
while(L<more){//逐个遍历
if(arr[L]<arr[R]){//如果小于主元，则左半区扩大
swap(arr,++less,L++);
}else if(arr[L]>arr[R]){//如果大于主元，则右半区扩大
swap(arr,--more,L);//注意这里L不变，因为交换过来的数还没有判断过
}else{//等于主元，则继续遍历
L++;
}
}
swap(arr,more,R);//将主元放到中间
return new int[]{less+1,more};
}
}
堆排序（大顶堆）
时间复杂度:O(N*logN)
(额外)空间复杂度:O(1)（递归栈空间）
稳定性：非稳定
核心思想：构建堆+堆化
public class HeapSortTest {
public static void swap(int[] arr,int i,int j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j]=tmp;
}
public static void heapInsert(int[] arr,int index){
/*
* 从index位置往上看，如果大于父节点，就交换
* 堆插入，停止条件是index位置的数不大于父节点或者到达根节点(index=0)
* 时间复杂度O(logN)
*/
while(arr[index]>arr[(index-1)/2]){
swap(arr,index,(index-1)/2);
index =(index-1)/2;
}
}
public static void heapify(int[] arr,int index,int heapSize){
/*
* 从index位置往下heapify，如果小于子节点，就交换
* 堆调整，停止条件是index位置的数不小于子节点或者到达叶子节点(index*2+1>heapSize)
* 时间复杂度O(logN)
*/
int left = index*2+1,right = index*2+2;
while(left<heapSize){
//left<heapSize说明还有子节点
//largest是左右子节点中较大的那个
int largest = right<heapSize&&arr[right]>arr[left]?right:left;
//较大子节点和父节点比较
largest = arr[largest]>arr[index]?largest:index;
if(largest==index){
//如果父节点最大，说明已经是大根堆，停止
break;
}
//交换位置并更新index
swap(arr,largest,index);
index = largest;
left = index*2+1;
right = index*2+2;
}
}
public static void heapSort(int[] arr){
if(arr==null||arr.length<2){
return;
}
//建立大根堆
for(int i=0;i<arr.length;i++) {//O(N)
heapInsert(arr, i); //O(logN)
}
//createHeap(arr); //时间复杂度O(N)
//堆排序
int heapSize = arr.length;
swap(arr,0,--heapSize);
while(heapSize>0){ //O(N)
heapify(arr,0,heapSize); //O(logN)
swap(arr,0,--heapSize);//不断将最大值放到数组末尾同时缩小堆的大小
}
}
public static void createHeap(int[] arr){
//通过自下而上heapify建立大根堆
for(int i=arr.length-1;i>=0;i--){
heapify(arr,i,arr.length);
}//i也可以从(arr.length-2)/2开始
}
}
计数排序
时间复杂度:O(N) N为数据规模
(额外)空间复杂度:O(M)（M为数组最值)
稳定性：非稳定
核心思想：这是一种非比较排序，受限于已知数组中最值以及最值不是特别大，通过数组记录他出现的次数最终排列即可
public static void countSort(int[] arr){
//计数排序
//arr中的元素范围是[0,maxValue]
int maxValue = Integer.MIN_VALUE;
for(int i=0;i<arr.length;i++){
maxValue = Math.max(maxValue,arr[i]);
}
int[] bucket = new int[maxValue+1];
for(int i=0;i<arr.length;i++){
bucket[arr[i]]++;
}
int index = 0;
for(int i=0;i<bucket.length;i++){
while(bucket[i]-->0){
arr[index++] = i;
}
}
}
基数排序（不基于比较）
时间复杂度:O(N)
(额外)空间复杂度:O(N)
稳定性：稳定
核心思想：获取最大值的数位d，进行d次进桶和出桶
public class RadixSortTest {
public static int maxBits(int[] arr){
int max = Integer.MIN_VALUE;
for(int i=0;i<arr.length;i++){
max = Math.max(max,arr[i]);
}
int res = 0;
while(max!=0){
res++;
max/=10;
}
return res;
}
public static int getDigit(int x,int d){
return ((x/((int)Math.pow(10,d-1)))%10);
}
//[L,R]进行排序，最大值的位数为digit
public static void radixSort(int[] arr,int L,int R,int digit){
final int radix = 10;//基数
int i=0,j=0;
//辅助数组
int bucket[] = new int[R-L+1];
for(int d=1;d<=digit;d++){
int count[] = new int[radix];//计数数组,
for(i=L;i<=R;i++){
//统计每个桶中的元素个数
j = getDigit(arr[i],d);
count[j]++;
}
//经过上一步，count[i]表示在d位上等于i的数字个数
for(i=1;i<radix;i++){
//求前缀和，也是计算边界
count[i] = count[i]+count[i-1];
}
//经过上一步，count[i]表示在d位上小于等于i的数字个数，即前缀和数组
//从右往左遍历，保证排序稳定性
for(i=R;i>=L;i--){
j = getDigit(arr[i],d);
bucket[count[j]-1] = arr[i];//注意这里数组索引是count[j]-1
count[j]--;
}
for(i=L,j=0;i<=R;i++,j++){
arr[i] = bucket[j];
}
}
}
}
扫一扫
8737
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
