Java常见排序方法，冒泡、选择、插入、快速

缺乏、安全感 2024-04-07 12:57 45阅读 0赞

**目录**

1、冒泡排序

2、选择排序

3、插入排序

4、快速排序

--------------------

#### 1、冒泡排序 ####

核心思想：1、相邻的元素两两比较，大得放右边，小的放左边 2、第一轮比较完后，最大的元素已经确定，第二轮就可以少循环一次，以此类推 3、如果数组中有n个数据，总共要执行n-1轮

代码如下：

/**
     * @authorDesc
     * @author
     * @date
     * @version 1.0.0
     * @description 冒泡排序
     * 核心思想：1、相邻的元素两两比较，大得放右边，小的放左边
     * 2、第一轮比较完后，最大的元素已经确定，第二轮就可以少循环一次，以此类推
     * 3、如果数组中有n个数据，总共要执行n-1轮
     */
    
    public class BubbleSort {
        public static void main(String[] args) {
            //定义数组
            int [] numArray = {1,3,8,2,6,7,5,4};
            //外循环：表示要循环多少轮。如果有n个数据就执行n-1轮
            for (int i = 0; i < numArray.length - 1; i++) {
                //内循环：每一轮找到当前最大值
                //-1:防止下标越界
                //-i:提高效率，=每一轮执行的次数比上一轮少1次
                for (int j = 0; j < numArray.length -i - 1; j++) {
                    //j：一次表示数组中的每一个索引；0，1，2，3，4，5，6，7
                    if (numArray[j] > numArray[j + 1]){
                        int temp = numArray[j];
                        numArray[j] = numArray[j + 1];
                        numArray[j + 1] = temp;
                    }
                }
            }
            //排序完后遍历数组
            for (int i : numArray) {
                System.out.print(i + " ");
            }
        }
    }

#### 2、选择排序 ####

核心思想：1、从0索引开始，和后面的元素一 一比较 2、小的放前面，大的放后面 3、第一次循环结束后，最小的数据已经确定 4、第二次循环从1索引开始以此类推

代码如下：

/**
     * @authorDesc
     * @author
     * @date
     * @version 1.0.0
     * @description 选择排序
     *1、从0索引开始，和后面的元素一一比较
     * 2、小的放前面，大的放后面
     * 3、第一次循环结束后，最小的数据已经确定
     * 4、第二次循环从1索引开始以此类推
     */
    
    public class SelectionSort {
        public static void main(String[] args) {
            //定义数组
            int [] numArray = {1,3,8,2,6,7,5,4};
            //外循环：表示要循环多少轮。如果有n个数据就执行n-1轮
            //i：表示这一轮中，哪个索引上的数据和后面的数据进行比较
            for (int i = 0; i < numArray.length - 1; i++) {
                //内循环：拿着i和i后面的数据进行比较交换
                for (int j = i + 1; j < numArray.length; j++) {
                    if (numArray[i] > numArray[j]){
                        int temp = numArray[i];
                        numArray[i] = numArray[j];
                        numArray[j] = temp;
                    }
                }
            }
            //排序完后遍历数组
            for (int i : numArray) {
                System.out.print(i + " ");
            }
        }
    }

#### 3、插入排序 ####

核心思想：将0索引的元素到N索引的元素看作是有序的，把N+1索引的元素到最后一个当成是无序的遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如果遇到相同的数据，插在后面

N的范围：0到最大索引

/**
     * @authorDesc
     * @author
     * @date
     * @version 1.0.0
     * @description 插入排序
     * 将0索引的元素到N索引的元素看作是有序的，把N+1索引的元素到最后一个当成是无序的
     * 遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如果遇到相同的数据，插在后面
     * N的范围：0到最大索引
     */
    
    public class InsertionSort {
        public static void main(String[] args) {
            //定义数组
            int [] numArray = {1,9,10,3,8,2,11,12,6,7,5,4};
            //找到无序的那一组，数组是从那个索引开始的
            int startIndex = -1;
            for (int i = 0; i < numArray.length; i++) {
                if (numArray[i] > numArray[i + 1]){
                    startIndex = i + 1;
                    break;
                }
            }
            //遍历从startIndex开始到最后一个元素，依次得到无序的那一组数据中的每一个元素
            for (int i = startIndex; i < numArray.length; i++) {
                //记录当前要插入数据的索引
                int j = i;
                while (j > 0 && numArray[j] < numArray[j - 1]){
                    //交换位置
                    int temp = numArray[j];
                    numArray[j] = numArray[j - 1];
                    numArray[j - 1] = temp;
                    j--;
                }
            }
            //排序完后遍历数组
            for (int i : numArray) {
                System.out.print(i + " ");
            }
        }
    }

**递归算法**

递归指的是方法中调用方法本身的现象

注意：递归一定要有出口，否则就会出现内存溢出

递归算法的作用：把一个复杂的问题转化为一个与原问题相似的规模小的问题来求解，递归策略只需要少量的程序就可以描述出解题过程所所需要的多次重复计算

核心：

找出口：什么时候不在调用方法

找规则：如何把大问题转化为小问题

代码展示

public class Recursive {
        public static void main(String[] args) {
            //1:需求：利用递归求1-100的和
            //2:需求：利用递归求5的阶乘
            // 大问题化小问题
            //1-100之间的和 = 100 + （1-99之间的和）
            //1-99之间的和 = 99 + （1-98之间的和）
            //1-98之间的和 = 98 + （1-97之间的和)......
            //1-2之间的和 = 2 + （1-1之间的和)
            //1-1之间的和 = 1 （递归出口)
            //
            System.out.println(getSum(100));
            System.out.println(getFactorial(5));
    
        }
        /**
         * @description
         * @author
         * @date
         * @param number 要求和的数
         * @return {@link int}
         */
        public static int getSum(int number){
            if (number == 1){
                return 1;
            }
            return number + getSum(number -1);
        }
        /**
         * @description
         * @author
         * @date
         * @param number 要求阶乘的数
         * @return {@link int}
         */
        public static int getFactorial(int number){
            if (number == 1){
                return 1;
            }
            return number * getFactorial(number - 1);
        }
    }

#### 4、快速排序 ####

代码如下

/**
     * @authorDesc
     * @author
     * @date
     * @version 1.0.0
     * @description 快速排序
     */
    
    public class QuickSort {
        public static void main(String[] args) {
    
            int [] arr = {13,14,6,1,2,7,9,3,4,5,10,8,16,19,17};
            quicksort(arr,0,arr.length - 1);
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
        }
    
        public static void quicksort(int [] arr,int i,int j){
            //定义两个变量记录要查找的范围
            //开始索引
            int start = i ;
            //结束索引
            int end = j;
    
            if (start > end){
                return;
            }
    
            //记录准基数
            int baseNumber = arr[i];
    
            //利用循环找到要交换的数字
            while (start != end){
                //利用end，从后往前开始找，找比基准数小的数字
                while (true){
                    if (end <= start || arr[end] < baseNumber){
                        break;
                    }
                    end--;
                }
                //利用start，从前往后开始找，找比基准数大的数字
                while (true){
                    if (end <= start || arr[start] > baseNumber){
                        break;
                    }
                    start++;
                }
                //把end和start指向的元素进行交换
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
            //当end和start指向同一个元素的时候，那么上面的循环就会结束
            //表示已经找到了基准数在数组中的位置
            //基准数归位
            //拿着这个范围中的第一个数字，跟start指向的元素进行交换
            int temp = arr[i];
            arr[i] = arr[start];
            arr[start] = temp;
    
            //使用递归
            //确定基准数左边的范围，重复刚刚所做的事情
            quicksort(arr,i,start - 1);
            //确定基准数右边的范围，重复刚刚所做的事情
            quicksort(arr,start + 1,j);
        }
    }