day044:数组的高级操作（二）：冒泡排序、递归、快速排序

接上节：day043:数组的高级操作_ZQyyds：）的博客-CSDN博客

二、冒泡排序

1.什么是冒泡排序？

相邻的数据两两比较，小的放前面，大的放后面

2.冒泡排序规律

• 如果有n个数据排序，则需要比较n-1次
• 每一次比较完毕，下一次比较都会减少一个数据

代码示例：

package com.itheima;

/*冒泡排序代码优化*/
public class BubbleSortDemo2 {
    public static void main(String[] args) {
        int[] arr = {3, 5, 2, 1, 4};
        bubbleSort(arr);
        printArr(arr);
    }

    private static void bubbleSort(int[] arr) {
        /*改字母快捷键：选中,shift+F6
         快速抽取成方法的快捷键：CTRL+alt+M*/
        /*注：外循环是记录比较次数，内循环是相邻的两数据作比较
         * 内循环的arr.length - 1 - i中的-i是因为每次比较之后都会少一个数字*/
        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;
                }
            }
        }
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

三、递归

1.什么是递归？

递归概述：从编程的角度说，递归指的是方法定义中调用方法本身的现象

2.递归解决问题的思路：

把一个复杂的问题层层转化为一个与原问题相似的且规模较小的问题来求解

3.递归解决问题要找的两个内容

• 递归出口：否则会出现内存溢出
• 递归规则：与原问题相似的规模较小的问题

代码示例：

（1）递归求和：

//递归求1-100的和
public class Factorial_Demo1 {
    public static void main(String[] args) {
        int sum = getSum(100);
        System.out.println(sum);
    }

    private static int getSum(int i) {
        //代码解释：当i等于1时，返回值为1，代表已经加到最后的数1了；否则就返回当前数加上当前数减一
        //也就是说，i=100，返回100加上getSum（99），然后再调用getSum（99），以此类推...
        if (i == 1) {
            return 1;
        } else {
            return i + getSum(i - 1);
        }

    }
}

（2）递归求阶乘：

//递归求阶乘
public class Factorial_Demo2 {
    public static void main(String[] args) {
        int num = getJc(5);
        System.out.println(num);
    }

    private static int getJc(int i) {
        if (i == 1) {
            return 1;
        } else {
            return i * getJc(i - 1);
        }

    }


}

四、快速排序

1.快速排序和冒泡排序的区别

• 冒泡排序算法中，一次循环结束，就相当于确定了当前的最大值，也能确定最大值在数组中应存入的位置
• 快速排序算法中，每一次递归时以第一个数为基准数，找到数组中比基准数小的，再找到数组中比基准数大的，小的全部放左边，大的全部放右边，确定基准数的位置（基准数归位）。（快速排序在第一次递归后能确定的事情：小的数在基准数左边，大的数在基准数右边，以及基准数的位置）

 代码示例：

public class QuiteSort_demo2 {
    public static void main(String[] args) {
        int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
//        创建方法传入三个参数：数组，数组起始，数组结束
        quiteSort(arr, 0, arr.length - 1);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    private static void quiteSort(int[] arr, int left, int right) {
        if (right < left) {
            return;
        }
        //先做一个临时存储，因为后面要用到这两个数一开始位置的值
        int left0 = left;
        int right0 = right;
        //计算出基准数
        int baseNumber = arr[left0];
        while (left != right) {
            //1.从右开始找比基准数小的
            while (arr[right] >= baseNumber && right > left) {
                right--;
            }
            //2.从左开始找比基准数大的
            while (arr[left] <= baseNumber && right > left) {
                left++;
            }
            //3.交换两个值的位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        //基准数归位：
        int temp = arr[left];
        arr[left] = arr[left0];
        arr[left0] = temp;

        quiteSort(arr, left0, left - 1);
        quiteSort(arr, left + 1, right0);
    }
}