【Java知识体系】算法基础：排序，Java代码解读

大家好！我是未来村村长，就是那个“请你跟我这样做，我就跟你这样做！”的村长👨‍🌾！

||To bottom||

​ 【To Up】系列文章重在java入门，但是【To Bottom】系列文章则重在面向基础，面向底层。只有深入底层才能得到技术和框架理解的进阶，才能深化自己的技术能力。该系列主要是“基础更基础，入门更上层”，即更基础的知识，更全面的框架运用。

​ 所谓“心中有丘壑，眉间显山河”，大致就是这个道理。

1、快速排序

​ 一句话描述：快速排序采用的是分治的思想，不断递归【设定一个基准位，将该数组分成两份】，实现数组的排序。

（1）属性定义

public static void sort(int[] arr,int low,int high){   
		//一、属性定义
        int i,j;//1、左右扫描指针
        if(low>high) return;//2、当low与high大小相等时结束递归
        i = low;//3、i从左开始扫描
        j = high;//4、j从右开始扫描
        int temp = arr[low];//5、基准位

• i，j：从右或右开始扫描的指针
• low，high：分别代表数组首尾元素
• temp：基准位，以该位数据为标准切分子数组，一般为low位

（2）排序实现

        //二、排序实现【升序】
        while (i<j){
            //1、i，j分别从两边开始扫描
            while (arr[j]>=temp && j>i) j--;
            while (arr[i]<=temp && j>i) i++;
            //2、j停下来的数小于基准位，i则大于基准位
            //3、将i和j的数字进行交换
            if(j>i){
                int t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
        //4、归位：ij相遇的位置就是基准位的位置
        arr[low] = arr[i];
        arr[i] = temp;

​ ① i，j从左右开始扫描，当j遇到比基准位小的数，停止扫描，j位置的数据是需要放到基准位左边的数据。

​ ② 当i遇到比基准位小的数，停止扫描。这个时候，i和j正好冲突，将i和j的元素互换

​ ③ 继续扫描，重复以上步骤

​ ④ 最后ij相遇，所有while循环不满足条件而停止，此时i和j的位置就是基准位，我们将该位置的数据与基准位置数据互换即可【为什么ij所在位置的元素小于基准位置？因为j先到达该位置，则一定会停下来与i互换，所以i会先到达该位置，等待j的到来】

（3）递归执行

        //三、递归执行
        sort(arr,low,j-1);
        sort(arr,j+1,high);

​ 第一次已经将该数组分成两份了，然后在从基准位左右两边分别进行此排序操作，最终会使每一个子数组实现排序。

（4）算法效率分析

public class QuickSort {
    public static void sort(int[] arr,int low,int high){
        //一、属性定义
        int i,j;//1、左右扫描指针
        if(low>high) return;//2、当low与high大小相等时结束递归
        i = low;//3、i从左开始扫描
        j = high;//4、j从右开始扫描
        int temp = arr[low];//5、基准位

        //二、排序实现【升序】
        while (i<j){
            //1、i，j分别从两边开始扫描
            while (arr[j]>=temp && j>i) j--;
            while (arr[i]<=temp && j>i) i++;
            //2、j停下来的数小于基准位，i则大于基准位
            //3、将i和j的数字进行交换
            if(j>i){
                int t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
        //4、归位：ij相遇的位置就是基准位的位置
        arr[low] = arr[i];
        arr[i] = temp;

        //三、递归执行
        sort(arr,low,j-1);
        sort(arr,j+1,high);
    }
}

时间复杂度：

• 平均情况：O(nlog2n)

• 最好：O(nlog2n)

• 最坏：O(n²)

• 稳定情况：不稳定

空间复杂度：

• O(nlog2n)

2、插入排序

一句话描述：从头开始逐步遍历，默认i前面的数据已经有序，将i的元素插入到前面的有序数组中。

（1）属性定义

public static void sort(int arr[]){
		//一、属性
        int iv;//定义待插入的数
        int ivPreIndex;//定义待插入数的前一个下标

• iv：待插入数据，默认i前面的数据已经有序，iv是待插入的数据
• ivPreIndex：用ivPreIndex作为遍历i前面数据的指针

（2）排序实现

 		//二、排序
        for(int i = 0;i<arr.length;i++){
            iv = arr[i];//1、从头开始，默认i之前的数已经排好序
            ivPreIndex = i-1;//2、取到i前一位下标,从这里开始与待插入数比较
            //3、将iv与i前面的数逐一比较，找到待插入位置
            while (ivPreIndex>=0 && arr[ivPreIndex]>iv){
                //3.1、每找到一次对应位置，该位置的数后移，直到i前数组有序
                arr[ivPreIndex+1] = arr[ivPreIndex];
                //3.2、下标更新
                ivPreIndex--;
            }
            //4、最终ivPreIndex+1的位置就是待插入的位置
            arr[ivPreIndex+1] = iv;
        }

​ ① 从头开始，默认第一个数有序，从第二个数开始插入

​ ② 每次插入i位置的元素，是将i逐步与i前面的元素进行比较

​ ③ 如果遇到比i大的数，该数就向后移动一位，直到遇到比i小的数，或者ivPreIndex指向头元素

​ ④ 最后将空出来的值，赋值待插入元素

（3）算法效率分析

public class InsertionSort {

    public static void sort(int arr[]){
        //一、属性
        int iv;//定义待插入的数
        int ivPreIndex;//定义待插入数的前一个下标

        //二、排序
        for(int i = 0;i<arr.length;i++){
            iv = arr[i];//1、从头开始，默认i之前的数已经排好序
            ivPreIndex = i-1;//2、取到i前一位下标,从这里开始与带插入数比较
            //3、将iv与i前面的数逐一比较，找到待插入位置
            while (ivPreIndex>=0 && arr[ivPreIndex]>iv){
                //3.1、每找到一次对应位置，该位置的数后移，直到i前数组有序
                arr[ivPreIndex+1] = arr[ivPreIndex];
                //3.2、下标更新
                ivPreIndex--;
            }
            //4、最终ivPreIndex+1的位置就是待插入的位置
            arr[ivPreIndex+1] = iv;
        }
    }
}

时间复杂度：

• 平均情况：O(n²）

• 最好：O(n)

• 最坏：O(n²)

• 稳定情况：稳定

空间复杂度：

• O(1)

3、希尔排序

一句话描述：规定一个间距，让间距相同的元素为一个子数组，在组内进行排序操作，不断缩小间距，重复组内排序。

（1）属性定义

public static void sort(int arr[]){
        //一、属性
        int gap;//规定间距以切分子表

• gap：gap就是我们的分组依据，每次比较结束后缩小其值，进行重新分组和排序

（2）排序实现

		//二、排序
        //1、gap初始值为二分之一数组长度，逐步缩小分组间距
        for(gap = arr.length/2;gap>0;gap = gap/2){

            //2、将整个数组切分为若干个子数组【以gap为间距】
            for(int i = gap;i<arr.length;i++){

                //3、遍历各组元素，进行组内排序
                for (int j = i-gap; j>=0 ; j=j-gap) {

                    if(arr[j]>arr[i]){
                        int temp=arr[j];
                        arr[j] = arr[j+gap];
                        arr[j+gap] = temp;
                    }
                }
            }
        }

​ ① gap取数组长度，每次进行分组操作前都缩小为一半【也可以缩小其它倍数】

​ ② 根据gap大小，将间距为gap的元素划分为一个子数组

​ ③ 在子数组内进行插入排序

（3）算法效率分析

public class ShellSort {

    public static void sort(int arr[]){
        //一、属性
        int gap;//规定间距以切分子表

        //二、排序
        //1、gap初始值为二分之一数组长度，逐步缩小分组间距
        for(gap = arr.length/2;gap>0;gap = gap/2){

            //2、将整个数组切分为若干个子数组【以gap为间距】
            for(int i = gap;i<arr.length;i++){

                //3、遍历各组元素，进行组内排序
                for (int j = i-gap; j>=0 ; j=j-gap) {

                    if(arr[j]>arr[j+gap]){
                        int temp=arr[j];
                        arr[j] = arr[j+gap];
                        arr[j+gap] = temp;
                    }
                }
            }
        }
    }
}

时间复杂度：

• 平均情况：O(n^1.3）

• 最好：O(n)

• 最坏：O(n²)

• 稳定情况：不稳定

空间复杂度：

• O(1)

4、归并排序

一句话描述：利用递归的方式，将数组不断从中间分成子数组，然后进行合并，合并的顺序总是左半部分数据大于右半部分数据。

（1）合并算法

private static void merge(int[] arr,int left,int right,int mid,int[] temp){
        //一、属性
        int i = left;//左边有序序列的初始索引
        int j = mid+1;//右边有序序列的初始索引
        int t = 0;//temp数组的当前索引

        //二、合并：将左右两边的数据按规则填充到temp数组
    	//1、扫描数组arr，从开头和中间开始扫描
        while (i<=mid && j<=right){
            //1.1、将ij扫描到的数进行比较，较小值优先放置，直到有一边扫描完毕
            if(arr[i]<=arr[j]){
                temp[t] = arr[i];
                t++;
                i++;
            }else {
                temp[t] = arr[j];
                t++;
                j++;
            }
        }
		//1.2、将剩余的数据依次添加到temp数组中
        while (i<=mid){
            temp[t] = arr[i];
            t++;
            i++;
        }

        while (j<=right){
            temp[t] = arr[j];
            t++;
            j++;
        }
		
    	//1.3、将temp复制到arr中
        t=0;
        int tempLeft = left;
        while (tempLeft<=right){
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
    }

​ ① 每次都从开头和中间开始扫描，对i，j指针路过的元素进行比较，将较小值优先放入temp数组中

​ ② 继续扫描比较，直到temp数组装载了一半

​ ③ 将后续数据放入temp数组中

​ ④ 如此temp数组前一半数据就小于后一半数据

（2）排序算法

    public static void sort(int[] arr, int left, int right, int[] temp){

        if (left<right) {
            int mid = (left + right) / 2;
            //向左递归进行分解
            sort(arr, left, mid, temp);
            //向右递归进行分解
            sort(arr, mid + 1, right, temp);
            //每分解一次便合并一次
            merge(arr, left, right, mid, temp);
        }
   }

​ ① 向左递归分解

​ ② 向右递归分解

​ ③ 逐步合并

（3）算法效率分析

public class MergeSort {

    public static void sort(int[] arr, int left, int right, int[] temp){

        if (left<right) {
            int mid = (left + right) / 2;
            //向左递归进行分解
            sort(arr, left, mid, temp);
            //向右递归进行分解
            sort(arr, mid + 1, right, temp);
            //每分解一次便合并一次
            merge(arr, left, right, mid, temp);
        }
   }


    private static void merge(int[] arr,int left,int right,int mid,int[] temp){
        //一、属性
        int i = left;//左边有序序列的初始索引
        int j = mid+1;//右边有序序列的初始索引
        int t = 0;//temp数组的当前索引

        //将左右两边的数据按规则填充到temp数组
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t] = arr[i];
                t++;
                i++;
            }else {
                temp[t] = arr[j];
                t++;
                j++;
            }
        }

        while (i<=mid){
            temp[t] = arr[i];
            t++;
            i++;
        }

        while (j<=right){
            temp[t] = arr[j];
            t++;
            j++;
        }

        t=0;
        int tempLeft = left;
        while (tempLeft<=right){
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }


    }

}

时间复杂度：

• 平均情况：O(nlog2n）

• 最好：O(nlog2n)

• 最坏：O(nlog2n)

• 稳定情况：稳定

空间复杂度：

• O(n)

5、基数排序

一句话描述：定义一个桶用于装载数据【大小为10*arr.length】，取到数组的最大值的位数，从个位开始，按照各个位上的自然数进行桶的装载，然后依次取出，这样能保证每次取出都是按各个位上的自然数升序排序，取到最高位时，取出即排序完毕。

（1）属性

    public static void sort(int[] arr){
        //一、属性
        //1、桶：用来装载元素
        int[][] bucket = new int[10][arr.length];
        //2、用来记录每个桶(0-9)装了几个数字
        int[] Count = new int[10];
        //3、数组的最大位数
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        int maxLength = (max + "").length();//获得最大值长度/决定循环次数
        //4、取出来的数据
        int digit；

• bucket：二维数组，10个桶用来装载数据，[10]代表每个位上可能出现的自然数，[arr.length]是装载容量
• Count：记录每个自然数桶装了几个数据
• maxLength：计算该数组中最大数的位数
• digit：自然数，代表各个位上的自然数

（2）装桶与取出

  		//二、装桶再取出
        for(int k = 0;k<maxLength;k++){
            
            //1、装载
            for(int i = 0;i<arr.length;i++){
                //1.1、取出各个位上的自然数，用于桶的定位
                digit = (int)(arr[i]/Math.pow(10,k)%10);
                //1.2、定位到桶之后，通过Count[digit]定位放置的位置
                bucket[digit][Count[digit]]= arr[i];
                //1.3、该自然数放置个数增加
                Count[digit]++;
            }
            
            //2、取出
            int index = 0;
            //2.1、遍历Count，确定每个bucket有几个数
            for(int j = 0;j<Count.length;j++){
                if(Count[j]!=0){
                    //2.2、从0开始依次取出
                    for(int l = 0;l<Count[j];l++){
                        arr[index] = bucket[j][l];
                        index++;
                    }
                }
                Count[j] = 0;//每取出一个就将计数桶元素清零，以便下一个高位装载使用
            }
        }

​ ① 从个位数开始装载，每次都要经历装载和取出的过程

​ ② 装载：首先会取出arr数组中每一个数相应位上的自然数值，然后定位到相应的桶中，进行装载

​ ③ 取出：从自然数值较小的数开始取出，这样取出的数一定是在该位上按从小到大开始取出

​ 说明：这样第二次【十位】装载的时候，按十位上的自然数大小排序，当遇到十位相等时，因为我们是按照个位大小顺序进行装载，此时较小位数会先进入桶中，取出时也会先进行取出，这样即时遇到十位相等的情况，也是个位较小的数先取出，后续装载取出也是如此。

（3）算法效率分析

public class RaixSort {

    public static void sort(int[] arr){
        //一、属性
        //1、桶：用来装载元素
        int[][] bucket = new int[10][arr.length];
        //2、用来记录每个桶(0-9)装了几个数字
        int[] bucketElementCount = new int[10];
        //3、数组的最大位数
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        int maxLength = (max + "").length();//获得最大值长度/决定循环次数

        //二、装桶再取出
        for(int k = 0;k<maxLength;k++){
            
            //装载
            for(int i = 0;i<arr.length;i++){
                int digit = (int)(arr[i]/Math.pow(10,k)%10);
                bucket[digit][Count[digit]]= arr[i];
                Count[digit]++;
            }
            
            //取出
            int index = 0;
            for(int j = 0;j<bucketElementCount.length;j++){
                if(bucketElementCount[j]!=0){
                    for(int l = 0;l<bucketElementCount[j];l++){
                        arr[index] = bucket[j][l];
                        index++;
                    }
                }
                bucketElementCount[j] = 0;//将计数桶元素清零
            }
        }
    }
}

时间复杂度：O是数组大小，k是位数数量

• 平均情况：O(n*k）

• 最好：O(n*k)

• 最坏：O(n*k)

• 稳定情况：稳定

空间复杂度：

• O(n+k)

6、堆排序

一句话描述：利用堆的数据结构进行排序。

（1）数据结构：堆

​ 堆是一棵顺序存储的完全二叉树，堆可分为大顶堆和小顶堆。

• 大顶堆：每个节点的关键字都大于其孩子节点的关键字，根节点是堆中最大节点【因为双亲节点总是大于孩子节点，所以从根节点出发，无论走那条路，得到的都是一个递减序列，可证明根节点为堆中最大节点】

• 小顶堆：每个节点的关键字都小于其孩子节点的关键字，根节点是堆中最小节点

  ps：一棵大小为N的完全二叉树，高度为lgN

（2）下沉算法

    private static void sink(int[] arr,int index,int length){
        //index：代表进行下沉操纵的节点
        //左子节点下标
        int leftChild = 2*index + 1;
        //右子节点下标
        int rightChild = 2*index + 2;
        //要调整的节点下标
        int present = index;
		
        //向左边下沉
        if(leftChild<length && arr[leftChild]>arr[present]){
            present = leftChild;
        }
		
        //向右边下沉
        if(rightChild<length && arr[rightChild]>arr[present]){
            present = rightChild;
        }
		
        //如果下标不相等，说明下标已经下沉
        if(present!=index){
            //则交换值达到值的下沉
            int temp = arr[index];
            arr[index] = arr[present];
            arr[present] = temp;
			//继续下沉
            sink(arr,present,length);
        }
    }

​ ① 下沉操作是针对某一个节点，找到其左右子节点，如果其左右子节点有比该节点大的，则进行位置互换。

​ ② 这个时候该节点可能有又拥有了新的左右子节点，继续根据大顶堆的定义，检查其左右子节点是否大于该节点，如果是则继续下沉

（3）堆的建造

   private static void buildHeap(int[] arr,int length){
       //从length/2的位置开始向前遍历，因为length/2后的节点皆为孩子节点
        for (int i = length/2; i>=0; i--) {
            //对length/2之前的双亲节点逐个进行下沉操作
            sink(arr,i,length);
        }
    }

​ ① 对于一个给定数组，我们进行堆的建造，只需要检查每个一双亲节点是否符合：双亲节点大于孩子节点

​ ② 如果不符合就进行下沉操作

（4）排序算法

    public static void sort(int[] arr){
        int length = arr.length;
        //1、先进行堆的建造
        buildHeap(arr,length);
        //2、从末尾开始，将末尾元素与堆顶元素交换
        for (int i = length-1; i >0 ; i--) {
            //2.1、将堆顶元素与末位元素调换
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            //2.2、更新末尾值，隐藏完成交换的末尾元素
            length--;
            //2.3//、将堆顶元素下沉 目的是将最大的元素浮到堆顶来
            sink(arr,0,length);
        }

    }

​ ① 之前我们已经知道堆顶元素是堆中最大，所以我们只需要将堆顶元素与末尾元素进行调换，更新末尾元素下标，重新调整堆，就取出了最大值并且将其置于末尾

​ ② 重复以上步骤，每次都只需要将堆顶元素与更新的末尾下标元素进行调换，然后对对顶元素进行下沉即可实现排序

（5）算法效率分析

public class HeapSort {

    public static void sort(int[] arr){
        int length = arr.length;
        //1、先进行堆的建造
        buildHeap(arr,length);
        //2、从末尾开始，将末尾元素与堆顶元素交换
        for (int i = length-1; i >0 ; i--) {
            //2.1、将堆顶元素与末位元素调换
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            //2.2、更新末尾值，隐藏完成交换的末尾元素
            length--;
            //2.3//、将堆顶元素下沉 目的是将最大的元素浮到堆顶来
            sink(arr,0,length);
        }

    }

    private static void buildHeap(int[] arr,int length){
        //从length/2的位置开始向前遍历，因为length/2后的节点皆为孩子节点
        for (int i = length/2; i>=0; i--) {
            //对length/2之前的双亲节点逐个进行下沉操作
            sink(arr,i,length);
        }
    }

    private static void sink(int[] arr,int index,int length){
        //index：代表进行下沉操纵的节点
        //左子节点下标
        int leftChild = 2*index + 1;
        //右子节点下标
        int rightChild = 2*index + 2;
        //要调整的节点下标
        int present = index;

        //向左边下沉
        if(leftChild<length && arr[leftChild]>arr[present]){
            present = leftChild;
        }

        //向右边下沉
        if(rightChild<length && arr[rightChild]>arr[present]){
            present = rightChild;
        }

        //如果下标不相等，说明下标已经下沉
        if(present!=index){
            //则交换值达到值的下沉
            int temp = arr[index];
            arr[index] = arr[present];
            arr[present] = temp;
            //继续下沉
            sink(arr,present,length);
        }
    }
}

时间复杂度：O是数组大小，k是位数数量

• 平均情况：O(nlog2n）

• 最好：O(nlog2n)

• 最坏：O(nlog2n)

• 稳定情况：不稳定

空间复杂度：

• O(1)

7、冒泡排序

一句话描述：从头开始遍历，从第一位开始，每一位数与后一位元素两两比较，较大者向后移动，每一轮排序产生一个最大值。

（1）代码

​ 代码自己看

public class BubbleSort {
    
    public static void sort(int[] arr){
        //记录比较次数
        int count=0;
        //i=0,第一轮比较
        for (int i = 0; i < arr.length-1; i++) {
            //第一轮，两两比较
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]) {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
                count++;
            }
        }
    }
}

（2）算法效率分析

时间复杂度：

• 平均情况：O(n²）

• 最好：O(n)

• 最坏：O(n²)

• 稳定情况：稳定

空间复杂度：

• O(1)

8、选择排序

一句话描述：每次找到数组中最小值放到第一个位置，然后默认依次找到后续的最小值，从第一位依次向后放置。

（1）代码

​ 代码自己看

public class SelectionSort {
    public static void sort(int arr[])
    {
        for (int i = 0; i < arr.length-1; i++) {
            int index=i;//标记第一个为待比较的数
            for (int j = i+1; j < arr.length; j++) { //然后从后面遍历与第一个数比较
                if (arr[j]<arr[index]) {  //如果小,就交换最小值
                    index=j;//保存最小元素的下标
                }
            }
            //找到最小值后，将最小的值放到第一的位置，进行下一遍循环
            int temp=arr[index];
            arr[index]=arr[i];
            arr[i]=temp;
        }
    }
}

（2）算法效率分析

时间复杂度：

• 平均情况：O(n²）

• 最好：O(n)

• 最坏：O(n²)

• 稳定情况：不稳定

空间复杂度：

• O(1)

——————————————————

作者：未来村村长

图片来源：简书-小吉头、以及百度图片【侵删】

参考：努力努力再努力²：https://blog.csdn.net/weixin_44531966/article/details/116464294

个人网站：www.76pl.com

👨‍🌾点个关注，在未来村不会迷路👩‍🌾

——————————————————