超两万字详解！通过Java实现交换排序（包括冒泡排序；快速排序的Hoare法、挖坑法、前后指针法及递归、非递归形式）和归并排序的递归、非递归形式

已于 2024-08-02 10:38:52 修改
阅读量609 收藏 18
点赞数 25
文章标签： 算法 数据结构 排序算法 java
于 2024-08-02 10:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79698279/article/details/140859069
版权

目录

（一）交换排序

1.冒泡排序

（1）基本形式

1）核心思想：

2）代码实现（以从小到大排序为例）：

3）代码分析：

（2）优化形式

1）核心思想：

2）代码实现（以从小到大排序为例）：

3）代码分析：

2.快速排序

（1）递归形式：Hoare型

1）核心思想：

2）代码实现（以从小到大排序为例）：

3）代码分析：

（2）递归形式：挖坑法型

1）核心思想：

2）代码实现（以从小到大排序为例）：

3）代码分析：

（3）递归形式：前后指针法型

1）核心思想：

2）代码实现（以从小到大排序为例）：

3）代码分析：

（4）通过三数取中法优化（以递归形式：Hoare型为例）

1）核心思想：

2）代码实现（以从小到大排序为例）：

3）代码分析：

（5）非递归形式（以Hoare型为例）

1）核心思想：

2）代码实现（以从小到大排序为例）：

3.以上两种交换排序示例及各算法耗时参考

1）代码结构

2）程序源码

ExchangeSort类（可以略过，其中代码和上文各算法代码一致，不过都被整合到了ExchangeSort类中）：

Test类：

3）测试结果

（二）归并排序

1.归并排序

（1）递归形式

1）核心思想：

2）代码实现（以从小到大排序为例）：

3）代码分析：

（2）非递归形式 

1）核心思想：

2）代码实现（以从小到大排序为例）：

2.以上算法示例及各算法耗时参考

1）代码结构

2）程序源码

MergeSort类（可以略过，其中代码和上文各算法代码一致，不过都被整合到了ExchangeSort类中）：

Test类：

3）测试结果

（一）交换排序

1.冒泡排序

（1）基本形式

1）核心思想：

冒泡排序，顾名思义，即每次循环通过交换的形式每次将非有序部分的最大值（或者最小值）放置在非有序部分的首端或者末端，就像冒泡一般，重复此过程最终整组元素有序。

2）代码实现（以从小到大排序为例）：
    //实现冒泡排序
    public static void bubbleSort(int[] array){
        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;
                }
                //完成一次循环，此时数组中最大值被“冒泡”至数组末端
            }
        }
    }
3）代码分析：

时间复杂度：严格为O(n^2);

空间复杂度：O(1);

稳定性：稳定。

（2）优化形式

1）核心思想：

同基本形式，但是设定了标志位flg判断单次循环中是否发生交换，若未发生交换则说明整组元素已有序，直接中断即可。

2）代码实现（以从小到大排序为例）：
    //实现冒泡排序的优化形式
    public static void bubbleSort2(int[] array){
        for(int i=0;i<array.length-1;i++){
            //设定标志位判断是否在一次循环中发生了交换
            boolean flg=false;
            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;
                    flg=true;
                }
                //完成一次循环，此时数组中最大值被“冒泡”至数组末端

                //判断标志位是否被置为true，若未被置为true则说明没有发生交换，整个数组有序，直接中断循环即可
                if(!flg){
                    break;
                }
            }
        }
    }
3）代码分析：

时间复杂度：顺序情况（最好情况）下只需遍历一遍数组，时间复杂度降为O(n),最坏情况仍为O(n^2)；

空间复杂度：O(1);

稳定性：稳定。

2.快速排序

（1）递归形式：Hoare型

1）核心思想：

快速排序是指，取待排序元素序列中某个元素作为基准值，依照该基准值将该元素序列分割成两个子序列，并且左子序列中的所有元素均小（大）于基准值，右子序列中所有元素均大（小）于基准值，中间为基准值，然后左右子序列重复该过程，向下递归，最终该组元素有序。

总体体现了分治的思想（即分而治之）。 

Hoare型指Hoare法（发明人为Hoare）实现的分组方法。 

2）代码实现（以从小到大排序为例）：
    //实现Hoare形式快速排序
    public static void hoareQuickSort(int[] array){
        //调用快速排序的底层方法
        hoareQuickSortChild(array,0,array.length-1);
    }

    //Hoare形式快速排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在快速排序方法中调用此递归方法即可
    private static void hoareQuickSortChild(int[]array,int start,int end){
        //递归的结束情况
        if(start>=end){
            return;
        }
        //通过基准值对该组元素进行分组，并获取基准值下标
        int par=hoarePartition(array,start,end);
        //递归左侧元素
        hoareQuickSortChild(array,start,par-1);
        //递归右侧元素
        hoareQuickSortChild(array,par+1,end);
    }

    //递归时用到的Hoare形式分组方法
    private static int hoarePartition(int[]array,int start,int end){
        //记录基准值位置下标
        int i=start;
        //将该组元素的起始元素作为基准值
        int tmp=array[start];
        while(start<end){
            //从末端开始遍历数组，直到找到比基准值小的元素的下标
            //start<end目的是防止下标越界
            //取大于等于或者小于等于的目的是防止进入死循环
            //先走末端因为若先走始端会出现相遇的地方为比基准值大的情况
            while(start<end && array[end]>=tmp){
                end--;
            }
            //从始端开始遍历数组，直到找到比基准值大的元素的下标
            while(start<end && array[start]<=tmp){
                start++;
            }
            //两次循环结束说明分别在始端找到比基准值大的元素以及在末端找到比基准值小的元素,二者交换
            int tmp1=array[start];
            array[start]=array[end];
            array[end]=tmp1;
        }
        //start和end相遇，将基准值和相遇处元素交换，使得中间为基准值，左侧为都比基准值小的元素，右边都为比基准值大的元素
        int tmp2=array[start];
        array[start]=array[i];
        array[i]=tmp2;
        //返回基准值下标
        return start;

    }
3）代码分析：

时间复杂度：最好情况下，分组时严格从中间二分，此时时间复杂度为O(n*log n)，

最坏情况下，分组只向单侧分组，此时时间复杂度为O(n^2)；

空间复杂度：最好情况下，分组时严格从中间二分，此时空间复杂度为O(log n),最坏情况下，分组只向单侧分组，此时空间复杂度为O(n)；

稳定性：不稳定。

（2）递归形式：挖坑法型

1）核心思想：

同Hoare型，但是应用的分组方法为挖坑法。

2）代码实现（以从小到大排序为例）：
    //实现挖坑法形式快速排序
    public static void holeQuickSort(int[] array){
        //调用快速排序的底层方法
        holeQuickSortChild(array,0,array.length-1);
    }

    //快速排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在快速排序方法中调用此递归方法即可
    private static void holeQuickSortChild(int[]array,int start,int end){
        //递归的结束情况
        if(start>=end){
            return;
        }
        //通过基准值对该组元素进行分组，并获取基准值下标
        int par=holePartition(array,start,end);
        //递归左侧元素
        holeQuickSortChild(array,start,par-1);
        //递归右侧元素
        holeQuickSortChild(array,par+1,end);
    }

    //递归时用到的挖坑法形式分组方法
    private static int holePartition(int[]array,int start,int end){
        //将该组元素的起始元素作为基准值
        int tmp=array[start];
        while(start<end){
            //从末端开始遍历数组，直到找到比基准值小的元素的下标
            //start<end目的是防止下标越界
            //取大于等于或者小于等于的目的是防止进入死循环
            //先走末端因为若先走始端会出现相遇的地方为比基准值大的情况
            while(start<end && array[end]>=tmp){
                end--;
            }
            //直接从末端向始端的“坑”赋值填数
            array[start]=array[end];
            //从始端开始遍历数组，直到找到比基准值大的元素的下标
            while(start<end && array[start]<=tmp){
                start++;
            }
            //直接从始端向末端的“坑”赋值填数
            array[end]=array[start];
        }
        //start和end相遇，将基准值填入最后一个“坑”
        array[start]=tmp;
        //返回基准值下标
        return start;
    }
3）代码分析：

同Hoare型。

（3）递归形式：前后指针法型

1）核心思想：

同Hoare型，但是应用的分组方法为前后指针法。

2）代码实现（以从小到大排序为例）：
    //实现前后指针形式快速排序
    public static void pointerQuickSort(int[] array){
        //调用快速排序的底层方法
        pointerQuickSortChild(array,0,array.length-1);
    }

    //快速排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在快速排序方法中调用此递归方法即可
    private static void pointerQuickSortChild(int[]array,int start,int end){
        //递归的结束情况
        if(start>=end){
            return;
        }
        //通过基准值对该组元素进行分组，并获取基准值下标
        int par=pointerPartition(array,start,end);
        //递归左侧元素
        pointerQuickSortChild(array,start,par-1);
        //递归右侧元素
        pointerQuickSortChild(array,par+1,end);
    }

    //递归时用到的前后指针形式分组方法
    private static int pointerPartition(int[]array,int start,int end){
        //设定前后指针
        int pre=start;
        int suc=start+1;
        //以下算法实现：当suc遇到比基准值（始端元素）小的元素，前后指针均后移;遇到比基准值大的元素时，后指针先一直后移找到后面第一个比基准值小的元素，前指针再后移一位指向第一个比基准值大的元素，两指针所指元素交换
        while(suc<=end){
            if(array[suc]<array[start] && array[++pre]!=array[suc]){
                int tmp=array[pre];
                array[pre]=array[suc];
                array[suc]=tmp;
            }
            suc++;
        }
        //循环结束后前指针所在位置左侧都比基准值小，右侧都比基准值大,将基准值换到此位置
        int tmp=array[pre];
        array[pre]=array[start];
        array[start]=tmp;
        return pre;
    }
3）代码分析：

同Hoare型。

（4）通过三数取中法优化（以递归形式：Hoare型为例）

1）核心思想：

同一般形式，但是用到了三数取中的方法来获取基准值。

2）代码实现（以从小到大排序为例）：
 //实现Hoare型快速排序的优化形式
    public static void hoareQuickSort2(int[] array){
        //调用快速排序的底层方法
        hoareQuickSortChild2(array,0,array.length-1);
    }

    //Hoare形式快速排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在快速排序方法中调用此递归方法即可
    private static void hoareQuickSortChild2(int[]array,int start,int end){
        //递归的结束情况
        if(start>=end){
            return;
        }
        //调用获取中位数下标的方法
        int index=midThreeNum(array,start,end);
        //将中位数放置在该组元素起始位置作为基准值，实现优化
        int tmp=array[index];
        array[index]=array[start];
        array[start]=tmp;
        //通过基准值对该组元素进行分组，并获取基准值下标
        int par=hoarePartition2(array,start,end);
        //递归左侧元素
        hoareQuickSortChild2(array,start,par-1);
        //递归右侧元素
        hoareQuickSortChild2(array,par+1,end);
    }

    //获取中位数下标的底层方法：返回一组元素首元素，中间元素，末端元素的中位数
    private static int midThreeNum(int[]array,int start,int end){
        int mid=(start+end)/2;
        if(array[start]<array[end]){
            if(array[mid]<array[start]){
                return start;
            }else if(array[mid]>array[end]){
                return end;
            }else{
                return mid;
            }
        }else{
            if(array[mid]<array[end]){
                return end;
            }else if(array[mid]>array[start]){
                return start;
            }
            else{
                return mid;
            }
        }
    }

    //递归时用到的Hoare形式分组方法
    private static int hoarePartition2(int[]array,int start,int end){
        //记录基准值位置下标
        int i=start;
        //将该组元素的起始元素作为基准值
        int tmp=array[start];
        while(start<end){
            //从末端开始遍历数组，直到找到比基准值小的元素的下标
            //start<end目的是防止下标越界
            //取大于等于或者小于等于的目的是防止进入死循环
            //先走末端因为若先走始端会出现相遇的地方为比基准值大的情况
            while(start<end && array[end]>=tmp){
                end--;
            }
            //从始端开始遍历数组，直到找到比基准值大的元素的下标
            while(start<end && array[start]<=tmp){
                start++;
            }
            //两次循环结束说明分别在始端找到比基准值大的元素以及在末端找到比基准值小的元素,二者交换
            int tmp1=array[start];
            array[start]=array[end];
            array[end]=tmp1;
        }
        //start和end相遇，将基准值和相遇处元素交换，使得中间为基准值，左侧为都比基准值小的元素，右边都为比基准值大的元素
        int tmp2=array[start];
        array[start]=array[i];
        array[i]=tmp2;
        //返回基准值下标
        return start;
    }
3）代码分析：

时间复杂度：优化后，分组时趋向从中间二分，时间复杂度趋向为O(n*log n)，

空间复杂度：优化后，分组时趋向从中间二分，空间复杂度趋向为O(log n),

稳定性：不稳定。

（5）非递归形式（以Hoare型为例）

1）核心思想：

同递归形式，但是分组时是通过利用栈模拟递归算法向下分组的。

2）代码实现（以从小到大排序为例）：
    //实现Hoare型快速排序的非递归形式（借助栈实现）
    public static void hoareQuickSort3(int[] array){
        //创建一个栈
        Stack<Integer>stack=new Stack<>();
        int start=0;
        int end=array.length-1;
        int par=hoarePartition3(array,start,end);
        //判断基准值左侧是否有两个以上元素
        if(par>start+1){
            //将左侧部分的首尾元素入栈
            stack.push(start);
            stack.push(end-1);
        }
        //判断基准值右侧是否有两个以上元素
        if(par<end-1) {
            stack.push(par + 1);
            stack.push(end);
        }
        //栈不为空说明未全部分组完毕
        while(!stack.isEmpty()){
            //出栈获取下一个待分组的末端元素
            end=stack.pop();
            //出栈获取下一个待分组的首端元素
            start=stack.pop();
            par=hoarePartition3(array,start,end);
            //判断基准值左侧是否有两个以上元素
            if(par>start+1){
                //将左侧部分的首尾元素入栈
                stack.push(start);
                stack.push(end-1);
            }
            //判断基准值右侧是否有两个以上元素
            if(par<end-1) {
                stack.push(par + 1);
                stack.push(end);
            }
        }
    }

    //调用到的Hoare形式分组方法
    private static int hoarePartition3(int[]array,int start,int end){
        //记录基准值位置下标
        int i=start;
        //将该组元素的起始元素作为基准值
        int tmp=array[start];
        while(start<end){
            //从末端开始遍历数组，直到找到比基准值小的元素的下标
            //start<end目的是防止下标越界
            //取大于等于或者小于等于的目的是防止进入死循环
            //先走末端因为若先走始端会出现相遇的地方为比基准值大的情况
            while(start<end && array[end]>=tmp){
                end--;
            }
            //从始端开始遍历数组，直到找到比基准值大的元素的下标
            while(start<end && array[start]<=tmp){
                start++;
            }
            //两次循环结束说明分别在始端找到比基准值大的元素以及在末端找到比基准值小的元素,二者交换
            int tmp1=array[start];
            array[start]=array[end];
            array[end]=tmp1;
        }
        //start和end相遇，将基准值和相遇处元素交换，使得中间为基准值，左侧为都比基准值小的元素，右边都为比基准值大的元素
        int tmp2=array[start];
        array[start]=array[i];
        array[i]=tmp2;
        //返回基准值下标
        return start;
    }

3.以上两种交换排序示例及各算法耗时参考

1）代码结构

ExchangeSort类：内部实现冒牌排序，快速排序（包括Hoare型、挖坑型、前后指针型递归形式，Hoare型递归形式的优化形式，Hoare型非递归形式）。

Test类：实现创建顺序数组，逆序数组，随机数组的方法（用来测试不同的交换排序算法）以及测量不同交换排序算法耗时的方法，并在main方法中进行示例演示。

2）程序源码
ExchangeSort类（可以略过，其中代码和上文各算法代码一致，不过都被整合到了ExchangeSort类中）：
import java.util.Stack;

public class ExchangeSort {
    //实现冒泡排序
    public static void bubbleSort(int[] array){
        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;
                }
                //完成一次循环，此时数组中最大值被“冒泡”至数组末端
            }
        }
    }

    //实现冒泡排序的优化形式
    public static void bubbleSort2(int[] array){
        for(int i=0;i<array.length-1;i++){
            //设定标志位判断是否在一次循环中发生了交换
            boolean flg=false;
            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;
                    flg=true;
                }
                //完成一次循环，此时数组中最大值被“冒泡”至数组末端

                //判断标志位是否被置为true，若未被置为true则说明没有发生交换，整个数组有序，直接中断循环即可
                if(!flg){
                    break;
                }
            }
        }
    }

    //实现Hoare形式快速排序
    public static void hoareQuickSort(int[] array){
        //调用快速排序的底层方法
        hoareQuickSortChild(array,0,array.length-1);
    }

    //Hoare形式快速排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在快速排序方法中调用此递归方法即可
    private static void hoareQuickSortChild(int[]array,int start,int end){
        //递归的结束情况
        if(start>=end){
            return;
        }
        //通过基准值对该组元素进行分组，并获取基准值下标
        int par=hoarePartition(array,start,end);
        //递归左侧元素
        hoareQuickSortChild(array,start,par-1);
        //递归右侧元素
        hoareQuickSortChild(array,par+1,end);
    }

    //递归时用到的Hoare形式分组方法
    private static int hoarePartition(int[]array,int start,int end){
        //记录基准值位置下标
        int i=start;
        //将该组元素的起始元素作为基准值
        int tmp=array[start];
        while(start<end){
            //从末端开始遍历数组，直到找到比基准值小的元素的下标
            //start<end目的是防止下标越界
            //取大于等于或者小于等于的目的是防止进入死循环
            //先走末端因为若先走始端会出现相遇的地方为比基准值大的情况
            while(start<end && array[end]>=tmp){
                end--;
            }
            //从始端开始遍历数组，直到找到比基准值大的元素的下标
            while(start<end && array[start]<=tmp){
                start++;
            }
            //两次循环结束说明分别在始端找到比基准值大的元素以及在末端找到比基准值小的元素,二者交换
            int tmp1=array[start];
            array[start]=array[end];
            array[end]=tmp1;
        }
        //start和end相遇，将基准值和相遇处元素交换，使得中间为基准值，左侧为都比基准值小的元素，右边都为比基准值大的元素
        int tmp2=array[start];
        array[start]=array[i];
        array[i]=tmp2;
        //返回基准值下标
        return start;

    }

    //实现挖坑法形式快速排序
    public static void holeQuickSort(int[] array){
        //调用快速排序的底层方法
        holeQuickSortChild(array,0,array.length-1);
    }

    //快速排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在快速排序方法中调用此递归方法即可
    private static void holeQuickSortChild(int[]array,int start,int end){
        //递归的结束情况
        if(start>=end){
            return;
        }
        //通过基准值对该组元素进行分组，并获取基准值下标
        int par=holePartition(array,start,end);
        //递归左侧元素
        holeQuickSortChild(array,start,par-1);
        //递归右侧元素
        holeQuickSortChild(array,par+1,end);
    }

    //递归时用到的挖坑法形式分组方法
    private static int holePartition(int[]array,int start,int end){
        //将该组元素的起始元素作为基准值
        int tmp=array[start];
        while(start<end){
            //从末端开始遍历数组，直到找到比基准值小的元素的下标
            //start<end目的是防止下标越界
            //取大于等于或者小于等于的目的是防止进入死循环
            //先走末端因为若先走始端会出现相遇的地方为比基准值大的情况
            while(start<end && array[end]>=tmp){
                end--;
            }
            //直接从末端向始端的“坑”赋值填数
            array[start]=array[end];
            //从始端开始遍历数组，直到找到比基准值大的元素的下标
            while(start<end && array[start]<=tmp){
                start++;
            }
            //直接从始端向末端的“坑”赋值填数
            array[end]=array[start];
        }
        //start和end相遇，将基准值填入最后一个“坑”
        array[start]=tmp;
        //返回基准值下标
        return start;
    }

    //实现前后指针形式快速排序
    public static void pointerQuickSort(int[] array){
        //调用快速排序的底层方法
        pointerQuickSortChild(array,0,array.length-1);
    }

    //快速排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在快速排序方法中调用此递归方法即可
    private static void pointerQuickSortChild(int[]array,int start,int end){
        //递归的结束情况
        if(start>=end){
            return;
        }
        //通过基准值对该组元素进行分组，并获取基准值下标
        int par=pointerPartition(array,start,end);
        //递归左侧元素
        pointerQuickSortChild(array,start,par-1);
        //递归右侧元素
        pointerQuickSortChild(array,par+1,end);
    }

    //递归时用到的前后指针形式分组方法
    private static int pointerPartition(int[]array,int start,int end){
        //设定前后指针
        int pre=start;
        int suc=start+1;
        //以下算法实现：当suc遇到比基准值（始端元素）小的元素，前后指针均后移;遇到比基准值大的元素时，后指针先一直后移找到后面第一个比基准值小的元素，前指针再后移一位指向第一个比基准值大的元素，两指针所指元素交换
        while(suc<=end){
            if(array[suc]<array[start] && array[++pre]!=array[suc]){
                int tmp=array[pre];
                array[pre]=array[suc];
                array[suc]=tmp;
            }
            suc++;
        }
        //循环结束后前指针所在位置左侧都比基准值小，右侧都比基准值大,将基准值换到此位置
        int tmp=array[pre];
        array[pre]=array[start];
        array[start]=tmp;
        return pre;
    }

    //实现Hoare型快速排序的优化形式
    public static void hoareQuickSort2(int[] array){
        //调用快速排序的底层方法
        hoareQuickSortChild2(array,0,array.length-1);
    }

    //Hoare形式快速排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在快速排序方法中调用此递归方法即可
    private static void hoareQuickSortChild2(int[]array,int start,int end){
        //递归的结束情况
        if(start>=end){
            return;
        }
        //调用获取中位数下标的方法
        int index=midThreeNum(array,start,end);
        //将中位数放置在该组元素起始位置作为基准值，实现优化
        int tmp=array[index];
        array[index]=array[start];
        array[start]=tmp;
        //通过基准值对该组元素进行分组，并获取基准值下标
        int par=hoarePartition2(array,start,end);
        //递归左侧元素
        hoareQuickSortChild2(array,start,par-1);
        //递归右侧元素
        hoareQuickSortChild2(array,par+1,end);
    }

    //获取中位数下标的底层方法
    private static int midThreeNum(int[]array,int start,int end){
        int mid=(start+end)/2;
        if(array[start]<array[end]){
            if(array[mid]<array[start]){
                return start;
            }else if(array[mid]>array[end]){
                return end;
            }else{
                return mid;
            }
        }else{
            if(array[mid]<array[end]){
                return end;
            }else if(array[mid]>array[start]){
                return start;
            }
            else{
                return mid;
            }
        }
    }

    //递归时用到的Hoare形式分组方法
    private static int hoarePartition2(int[]array,int start,int end){
        //记录基准值位置下标
        int i=start;
        //将该组元素的起始元素作为基准值
        int tmp=array[start];
        while(start<end){
            //从末端开始遍历数组，直到找到比基准值小的元素的下标
            //start<end目的是防止下标越界
            //取大于等于或者小于等于的目的是防止进入死循环
            //先走末端因为若先走始端会出现相遇的地方为比基准值大的情况
            while(start<end && array[end]>=tmp){
                end--;
            }
            //从始端开始遍历数组，直到找到比基准值大的元素的下标
            while(start<end && array[start]<=tmp){
                start++;
            }
            //两次循环结束说明分别在始端找到比基准值大的元素以及在末端找到比基准值小的元素,二者交换
            int tmp1=array[start];
            array[start]=array[end];
            array[end]=tmp1;
        }
        //start和end相遇，将基准值和相遇处元素交换，使得中间为基准值，左侧为都比基准值小的元素，右边都为比基准值大的元素
        int tmp2=array[start];
        array[start]=array[i];
        array[i]=tmp2;
        //返回基准值下标
        return start;
    }

    //实现Hoare型快速排序的非递归形式（借助栈实现）
    public static void hoareQuickSort3(int[] array){
        //创建一个栈
        Stack<Integer>stack=new Stack<>();
        int start=0;
        int end=array.length-1;
        int par=hoarePartition3(array,start,end);
        //判断基准值左侧是否有两个以上元素
        if(par>start+1){
            //将左侧部分的首尾元素入栈
            stack.push(start);
            stack.push(end-1);
        }
        //判断基准值右侧是否有两个以上元素
        if(par<end-1) {
            stack.push(par + 1);
            stack.push(end);
        }
        //栈不为空说明未全部分组完毕
        while(!stack.isEmpty()){
            //出栈获取下一个待分组的末端元素
            end=stack.pop();
            //出栈获取下一个待分组的首端元素
            start=stack.pop();
            par=hoarePartition3(array,start,end);
            //判断基准值左侧是否有两个以上元素
            if(par>start+1){
                //将左侧部分的首尾元素入栈
                stack.push(start);
                stack.push(end-1);
            }
            //判断基准值右侧是否有两个以上元素
            if(par<end-1) {
                stack.push(par + 1);
                stack.push(end);
            }
        }
    }

    //调用到的Hoare形式分组方法
    private static int hoarePartition3(int[]array,int start,int end){
        //记录基准值位置下标
        int i=start;
        //将该组元素的起始元素作为基准值
        int tmp=array[start];
        while(start<end){
            //从末端开始遍历数组，直到找到比基准值小的元素的下标
            //start<end目的是防止下标越界
            //取大于等于或者小于等于的目的是防止进入死循环
            //先走末端因为若先走始端会出现相遇的地方为比基准值大的情况
            while(start<end && array[end]>=tmp){
                end--;
            }
            //从始端开始遍历数组，直到找到比基准值大的元素的下标
            while(start<end && array[start]<=tmp){
                start++;
            }
            //两次循环结束说明分别在始端找到比基准值大的元素以及在末端找到比基准值小的元素,二者交换
            int tmp1=array[start];
            array[start]=array[end];
            array[end]=tmp1;
        }
        //start和end相遇，将基准值和相遇处元素交换，使得中间为基准值，左侧为都比基准值小的元素，右边都为比基准值大的元素
        int tmp2=array[start];
        array[start]=array[i];
        array[i]=tmp2;
        //返回基准值下标
        return start;
    }

}
Test类：
import java.util.Arrays;
import java.util.Random;

public class Test {
    //生成一个顺序数组的方法
    public static void order(int[] array){
        for(int i=0;i< array.length;i++){
            array[i]=i;
        }
    }

    //生成一个逆序数组的方法
    public static void reverseOrder(int[] array){
        for(int i=0;i<array.length;i++){
            array[i]= array.length-i;
        }
    }

    //生成一个随机数数组的方法
    public static void randomOrder(int[] array){
        Random random=new Random();
        for(int i=0;i<array.length;i++){
            array[i]= random.nextInt(10_0000);
        }
    }

    //测试冒泡排序时间的方法
    public static void testBubbleSort(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        ExchangeSort.bubbleSort(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("冒泡排序耗时:"+(endtime-starttime));
    }

    //测试冒泡排序优化形式时间的方法
    public static void testBubbleSort2(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        ExchangeSort.bubbleSort2(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("冒泡排序优化形式耗时:"+(endtime-starttime));
    }

    //测试Hoare形式快速排序时间的方法
    public static void testHoareQucikSort(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        ExchangeSort.hoareQuickSort(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("Hoare形式快速排序耗时:"+(endtime-starttime));
    }

    //测试挖坑法形式快速排序时间的方法
    public static void testHoleQucikSort(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        ExchangeSort.holeQuickSort(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("Hole形式快速排序耗时:"+(endtime-starttime));
    }

    //测试前后指针法形式快速排序时间的方法
    public static void testPointerQucikSort(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        ExchangeSort.pointerQuickSort(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("Pointer形式快速排序耗时:"+(endtime-starttime));
    }

    //测试Hoare型快速排序的优化形式时间的方法
    public static void testHoareQucikSort2(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        ExchangeSort.hoareQuickSort2(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("Hoare型快速排序的优化形式耗时:"+(endtime-starttime));
    }

    //测试Hoare型快速排序的非递归形式时间的方法
    public static void testHoareQucikSort3(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        ExchangeSort.hoareQuickSort3(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("Hoare型快速排序的非递归形式耗时:"+(endtime-starttime));
    }

    public static void main(String[] args) {
        int[]array=new int[1_0000];
        //测试顺序数组情况
        System.out.println("***********************");
        System.out.println("顺序数组情况：");
        order(array);
        testBubbleSort(array);
        testBubbleSort2(array);
        testHoareQucikSort(array);
        testHoleQucikSort(array);
        testPointerQucikSort(array);
        testHoareQucikSort2(array);
        testHoareQucikSort3(array);
        System.out.println("***********************");

        //测试逆序数组情况
        System.out.println("逆序数组情况：");
        reverseOrder(array);
        testBubbleSort(array);
        testBubbleSort2(array);
        testHoareQucikSort(array);
        testHoleQucikSort(array);
        testPointerQucikSort(array);
        testHoareQucikSort2(array);
        testHoareQucikSort3(array);
        System.out.println("***********************");

        //测试随机数组情况
        System.out.println("随机数组情况：");
        randomOrder(array);
        testBubbleSort(array);
        testBubbleSort2(array);
        testHoareQucikSort(array);
        testHoleQucikSort(array);
        testPointerQucikSort(array);
        testHoareQucikSort2(array);
        testHoareQucikSort3(array);
        System.out.println("***********************");

    }
}
3）测试结果

上图可以直观感受各算法在不同情况下的表现。 

（二）归并排序

1.归并排序

（1）递归形式

1）核心思想：

归并排序是指，将一个元素序列多次递归分解为多组有序序列，再将所有已有序的子序列合并（一般为两两合并，即二路归并），直到合并为一个元素序列，此时该元素序列已经有序。

总体体现了分治的思想（即分而治之）。 

归并排序在外排序中经常用到。

2）代码实现（以从小到大排序为例）：
    //实现归并排序
    public static void mergeSort1(int[]array){
        //调用归并排序的递归方法
        mergeSortChild1(array,0, array.length-1);
    }
    //归并排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在归并排序方法中调用此递归方法即可
    private static void mergeSortChild1(int[]array,int start,int end){
        //判断结束情况
        if(start>=end){
            return;
        }
        //向下递归分解为有序数组
        int mid=(start+end)/2;
        //向左递归分解
        mergeSortChild1(array,start,mid);
        //向右递归分解
        mergeSortChild1(array,mid+1,end);
        //合并分解完的数组
        merge1(array,start,mid,end);
    }

    //调用到的合并数组方法
    private static void merge1(int[]array,int start,int mid,int end){
        //创建一个新的数组作为模板
        int[]tmp=new int[end-start+1];
        //设定新数组的下标
        int k=0;
        //设定左右两个待合并的组的起始，终止下标
        int s1=start;
        int e1=mid;
        int s2=mid+1;
        int e2=end;
        //由于两个待合并的数组皆有序（从小到大顺序排放），所以直接比较两数组的起始元素，取出其中较小这放入模板数组中，对应下标后移
        while(s1<=e1&&s2<=e2){
            if(array[s1]<=array[s2]){
                tmp[k++]=array[s1++];
            }else{
                tmp[k++]=array[s2++];
            }
        }
        //循环结束说明某个数组已经遍历完毕，则另一个数组剩下元素都比模板数组中存储的元素大，直接将剩余元素存入其中即可
        while(s1<=e1){
            tmp[k++]=array[s1++];
        }
        while(s2<=e2){
            tmp[k++]=array[s2++];
        }
        //此时tmp数组中已经存储了二者合并完毕的内容，将其中内容拷贝到原数组中即可，注意对应下标
        for(int i=0;i<k;i++){
            array[i+start]=tmp[i];
        }
    }
3）代码分析：

时间复杂度：O(n*log n),

空间复杂度：O(n)（建立tmp数组最大开辟大小为n的空间）,

稳定性：稳定。

（2）非递归形式 

1）核心思想：

同递归形式，但是分解时是通过特定循环算法模拟递归算法向下分组的。

2）代码实现（以从小到大排序为例）：
    //实现归并排序的非递归形式
    public static void mergeSort2(int[]array){
        //认为数组已经按照单个元素为一组的方式分解完毕，开始合并
        //设定gap增量来获取合并数组的首、中、末，并且不断使gap扩倍，以此模拟递归算法中实现的合并方式
        int gap=1;
        while(gap<array.length){
            for(int i=0;i< array.length;i+=2*gap){
                int start=i;
                int mid=start+gap-1;
                //判断是否越界，越界直接置于末端
                if(mid>array.length-1){
                    mid= array.length-1;
                }
                //判断是否越界，越界直接置于末端
                int end=mid+gap;
                if(end>array.length-1){
                    end= array.length-1;
                }
                //合并数组
                merge2(array,start,mid,end);
            }
            //gap扩倍
            gap*=2;

        }
    }

    //调用到的合并数组方法
    private static void merge2(int[]array,int start,int mid,int end){
        //创建一个新的数组作为模板
        int[]tmp=new int[end-start+1];
        //设定新数组的下标
        int k=0;
        //设定左右两个待合并的组的起始，终止下标
        int s1=start;
        int e1=mid;
        int s2=mid+1;
        int e2=end;
        //由于两个待合并的数组皆有序（从小到大顺序排放），所以直接比较两数组的起始元素，取出其中较小这放入模板数组中，对应下标后移
        while(s1<=e1&&s2<=e2){
            if(array[s1]<=array[s2]){
                tmp[k++]=array[s1++];
            }else{
                tmp[k++]=array[s2++];
            }
        }
        //循环结束说明某个数组已经遍历完毕，则另一个数组剩下元素都比模板数组中存储的元素大，直接将剩余元素存入其中即可
        while(s1<=e1){
            tmp[k++]=array[s1++];
        }
        while(s2<=e2){
            tmp[k++]=array[s2++];
        }
        //此时tmp数组中已经存储了二者合并完毕的内容，将其中内容拷贝到原数组中即可，注意对应下标
        for(int i=0;i<k;i++){
            array[i+start]=tmp[i];
        }
    }

2.以上算法示例及各算法耗时参考

1）代码结构

MergeSort类：内部实现归并排序的递归形式与非递归形式。

Test类：实现创建顺序数组，逆序数组，随机数组的方法（用来测试不同的交换排序算法）以及测量不同归并排序算法耗时的方法，并在main方法中进行示例演示。

2）程序源码
MergeSort类（可以略过，其中代码和上文各算法代码一致，不过都被整合到了ExchangeSort类中）：
public class MergeSort {
    //实现归并排序
    public static void mergeSort1(int[]array){
        //调用归并排序的递归方法
        mergeSortChild1(array,0, array.length-1);
    }
    //归并排序的底层递归方法（使用递归时要求递归有以下三个参数，为保证接口统一性，在归并排序方法中调用此递归方法即可
    private static void mergeSortChild1(int[]array,int start,int end){
        //判断结束情况
        if(start>=end){
            return;
        }
        //向下递归分解为有序数组
        int mid=(start+end)/2;
        //向左递归分解
        mergeSortChild1(array,start,mid);
        //向右递归分解
        mergeSortChild1(array,mid+1,end);
        //合并分解完的数组
        merge1(array,start,mid,end);
    }

    //调用到的合并数组方法
    private static void merge1(int[]array,int start,int mid,int end){
        //创建一个新的数组作为模板
        int[]tmp=new int[end-start+1];
        //设定新数组的下标
        int k=0;
        //设定左右两个待合并的组的起始，终止下标
        int s1=start;
        int e1=mid;
        int s2=mid+1;
        int e2=end;
        //由于两个待合并的数组皆有序（从小到大顺序排放），所以直接比较两数组的起始元素，取出其中较小这放入模板数组中，对应下标后移
        while(s1<=e1&&s2<=e2){
            if(array[s1]<=array[s2]){
                tmp[k++]=array[s1++];
            }else{
                tmp[k++]=array[s2++];
            }
        }
        //循环结束说明某个数组已经遍历完毕，则另一个数组剩下元素都比模板数组中存储的元素大，直接将剩余元素存入其中即可
        while(s1<=e1){
            tmp[k++]=array[s1++];
        }
        while(s2<=e2){
            tmp[k++]=array[s2++];
        }
        //此时tmp数组中已经存储了二者合并完毕的内容，将其中内容拷贝到原数组中即可，注意对应下标
        for(int i=0;i<k;i++){
            array[i+start]=tmp[i];
        }
    }

    //实现归并排序的非递归形式
    public static void mergeSort2(int[]array){
        //认为数组已经按照单个元素为一组的方式分解完毕，开始合并
        //设定gap增量来获取合并数组的首、中、末，并且不断使gap扩倍，以此模拟递归算法中实现的合并方式
        int gap=1;
        while(gap<array.length){
            for(int i=0;i< array.length;i+=2*gap){
                int start=i;
                int mid=start+gap-1;
                //判断是否越界，越界直接置于末端
                if(mid>array.length-1){
                    mid= array.length-1;
                }
                //判断是否越界，越界直接置于末端
                int end=mid+gap;
                if(end>array.length-1){
                    end= array.length-1;
                }
                //合并数组
                merge2(array,start,mid,end);
            }
            //gap扩倍
            gap*=2;

        }
    }

    //调用到的合并数组方法
    private static void merge2(int[]array,int start,int mid,int end){
        //创建一个新的数组作为模板
        int[]tmp=new int[end-start+1];
        //设定新数组的下标
        int k=0;
        //设定左右两个待合并的组的起始，终止下标
        int s1=start;
        int e1=mid;
        int s2=mid+1;
        int e2=end;
        //由于两个待合并的数组皆有序（从小到大顺序排放），所以直接比较两数组的起始元素，取出其中较小这放入模板数组中，对应下标后移
        while(s1<=e1&&s2<=e2){
            if(array[s1]<=array[s2]){
                tmp[k++]=array[s1++];
            }else{
                tmp[k++]=array[s2++];
            }
        }
        //循环结束说明某个数组已经遍历完毕，则另一个数组剩下元素都比模板数组中存储的元素大，直接将剩余元素存入其中即可
        while(s1<=e1){
            tmp[k++]=array[s1++];
        }
        while(s2<=e2){
            tmp[k++]=array[s2++];
        }
        //此时tmp数组中已经存储了二者合并完毕的内容，将其中内容拷贝到原数组中即可，注意对应下标
        for(int i=0;i<k;i++){
            array[i+start]=tmp[i];
        }
    }
}
Test类：
import java.util.Arrays;
import java.util.Random;

public class Test {
    //生成一个顺序数组的方法
    public static void order(int[] array){
        for(int i=0;i< array.length;i++){
            array[i]=i;
        }
    }

    //生成一个逆序数组的方法
    public static void reverseOrder(int[] array){
        for(int i=0;i<array.length;i++){
            array[i]= array.length-i;
        }
    }

    //生成一个随机数数组的方法
    public static void randomOrder(int[] array){
        Random random=new Random();
        for(int i=0;i<array.length;i++){
            array[i]= random.nextInt(10_0000);
        }
    }

    //测试归并排序时间的方法
    public static void testMergeSort(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        MergeSort.mergeSort1(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("归并排序耗时:"+(endtime-starttime));
    }

    //测试归并排序非递归形式时间的方法
    public static void testMergeSort2(int[]array){
        //拷贝一个新的数组
        array= Arrays.copyOf(array,array.length);
        //获取起始时间戳
        long starttime=System.currentTimeMillis();
        MergeSort.mergeSort2(array);
        //获取终止时间戳
        long endtime=System.currentTimeMillis();
        //输出耗时
        System.out.println("归并排序非递归形式耗时:"+(endtime-starttime));
    }


    public static void main(String[] args) {
        int[]array=new int[10_0000];
        //测试顺序数组情况
        System.out.println("***********************");
        System.out.println("顺序数组情况：");
        order(array);
        testMergeSort(array);
        testMergeSort2(array);
        System.out.println("***********************");

        //测试逆序数组情况
        System.out.println("逆序数组情况：");
        reverseOrder(array);
        testMergeSort(array);
        testMergeSort2(array);
        System.out.println("***********************");

        //测试随机数组情况
        System.out.println("随机数组情况：");
        randomOrder(array);
        testMergeSort(array);
        testMergeSort2(array);
        System.out.println("***********************");

    }
}
3）测试结果

上图可以直观感受各算法在不同情况下的表现。 

以上便是通过Java实现交换排序（包括冒泡排序；快速排序的Hoare法、挖坑法、前后指针法及递归、非递归形式）和归并排序的递归、非递归形式的全部内容，同时关于选择排序和插入排序算法的思路以及具体实现，读者可以垂阅某之博客：田硕1895：通过Java实现插入排序（直接插入，希尔）与选择排序（直接选择，堆排）-CSDN博客。

感谢各位读者支持，如有不当，敬请斧正！

田硕1895
关注
  • 25
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java基于分治法实现的快速排序算法示例
08-28
这个例子展示了快速排序算法的实现细节，包括如何选择枢轴、如何进行分区以及如何通过递归实现整个序列的排序。由于快速排序的平均时间复杂度为O(n log n)，在大多数情况下表现优秀，因此被广泛应用于实际编程中。
详解快速排序算法中的区间划分法及Java实现示例
09-02
这两种方法在大多数情况下都能实现快速排序，但在处理特殊输入（如已排序或逆序数组）时，双指针法可能表现得更优，因为它减少了不必要的交换次数。 快速排序的平均时间复杂度为O(n log n)，最坏情况（已排序数组）...
[ 数据结构 -- 手撕排序算法第五篇 ] 快速排序 ＜包含hoare法，挖坑法，前后指针法＞ 及其算法优化
CSDN博客
04-20 1223
手撕排序算法系列之第四篇：快速排序。 从本篇文章开始，我会介绍并分析常见的几种排序，大致包括直接插入排序，冒泡排序，希尔排序，选择排序，堆排序，快速排序，归并排序等。 大家可以点击此链接阅读其他排序算法：排序算法_大合集（data-structure_Sort） 本篇主要来手撕快速排序算法~ 1.常见的排序算法 1.1交换排序 快速排序属于一种交换排序，因此我们在了解快速排序之前，先了解一下交换排序的基本思想。 基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记..
【数据结构-之八大排序(下)，冒泡排序，快速排序，挖坑法，归并排序】
2301_76249062的博客
05-02 1843
【数据结构-之八大排序(下)，冒泡排序，快速排序，挖坑法，归并排序】
详解快速排序--hoare法
感谢观看
06-11 153
hoare法单趟排序详解
交换排序—冒泡排序和快速排序
weixin_60718941的博客
08-02 2121
本文主要讲解冒泡排序和归并排序。
【七大排序算法（三）】之交换排序(冒泡排序，快速排序详解，代码，常见错误等9000字巨详细)
m0_54469145的博客
01-10 534
七大排序第三篇之交换排序，本文详细讲解了关于交换排序中的冒泡排序、快速排序；其中包括动图，代码，代码分部讲解以及每一步的图解，巨详细！！！，尤其是快速排序，三种方法、递归与非递归实现，不断优化算法、欢迎有需要的小伙伴阅读。
七大排序算法详解——排序（三）交换排序（冒泡排序、快速排序，附Java代码）
m0_63793861的博客
09-11 80
排序：所谓排序，就是使一串记录，按照其中的某个或某几个关键字的大小，递增或递减排列起来的操作。稳定性：在待排序的记录序列中，存在多个具有相同关键字的记录，若经过排序，这些记录的相对次序保持不变，则称这种排序算法是稳定的。内部排序：把数据全部加载到内存中进行排序。外部排序：数据太多，内存不能存储了，将数据放到磁盘、U盘上进行排序。
【八大排序】冒泡排序 | 快速排序 + 图文详解！！
深入解析C/C++编程技巧，带你探索高效开发之路
02-03 2296
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
【C语言】-- 数据结构 -- 交换排序类(冒泡排序，快速排序)(超详解+动图+源码)
weixin_64609308的博客
07-19 961
包括时间复杂度，空间复杂度，稳定性（带图讲解）
【排序算法】----详解快速排序算法（hoare法，挖坑法，指针法，三数取中优化）
qq_41152046的博客
04-07 387
11
JAVA 冒泡法，选择法，插入法，快速排序法，实现代码
10-16
以下是关于JAVA中冒泡法、选择法、插入法和快速排序法的详细知识及其实现代码的概述。 1. **冒泡排序（Bubble Sort）**： 冒泡排序是一种简单的交换排序方法，通过不断比较相邻元素并交换位置，使较大的元素逐渐...
php实现快速排序法函数代码
12-19
它的基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据...
Java实现快速排序.rar
06-14
2. **Java实现快速排序**： 在Java中，我们可以创建一个名为`quickSort`的方法，接收一个整型数组作为参数。首先，选择数组的第一个元素作为基准，然后遍历数组，将小于基准的元素移动到其前面，大于基准的元素移动...
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3311
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
算法 —— 暴力枚举
最新发布
fen_0108的博客
07-25 3886
第二看纵向宽发生改变，长重置为1，长为1，宽为2的时候，第一行个数为7个，总共有5 x 7 个，长为2，宽为2的时候 第一行个数为6个，共有5 x 6个……首先是横着的长方形，宽始终为1，长不断发生改变，可以看出长为2的时候，第一行个数为6个，总共有6 x 6个，长为3的时候，总共有6 x 5个……这是一道简单的模拟题，枚举出所有可能情况，不会超过规定时间的，以下附上k
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1583
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
2024.7.24 作业
qq_64434282的博客
07-24 2657
【代码】2024.7.24 作业。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值