数组的高级操作 二分 冒泡 快排

数组的高级操作

二分查找

什么是二分查找

二分查找也叫折半查找，每次去掉一半的查找范围，从而提高查找效率

二分查找的前提条件

数组元素必须按照从小到大或者从大到小的顺序排列

二分查找的具体实现步骤

1. 定义两个变量，默认最小值变量min = 0，最大值变量max = 最大索引，该范围是要查找的范围
2. 循环查找，但min <= max
3. 计算出中间值mid = (max + min) / 2
4. 判断mid位置是否为要查找元素，如果是直接返回
5. 如果要查找的值小于mid，则说明该值在数组中的左半边，min值不变，max = mid - 1，重复3、4步操作
6. 如果要查找的值大于mid，则说明该值在数组中的右半边，max值不变，min = mid + 1，重复3、4步操作
7. 如果min > max，说明该值在数组中不存在，返回 -1，结束循环

二分查找代码实现

public class BinarySearch {
    public static void main(String[] args) {
        int [] arr = {1,2,3,4,5,6,7,8,9,10};
        int number = 11;

        int index = binarySearchForIndex(arr,number);
        
        System.out.println(index);
    }

    private static int binarySearchForIndex(int[] arr, int number) {
        //1,定义查找的范围
        int min = 0;
        int max = arr.length - 1;
        //2.循环查找 min <= max
        while(min <= max){
            //3.计算出中间位置 mid
            int mid = (min + max) >> 1;
            //mid指向的元素 > number
            if(arr[mid] > number){
                //表示要查找的元素在左边.
                max = mid -1;
            }else if(arr[mid] < number){
                //mid指向的元素 < number
                //表示要查找的元素在右边.
                min = mid + 1;
            }else{
                //mid指向的元素 == number
                return mid;
            }
        }
        //如果min大于了max就表示元素不存在,返回-1.
        return -1;
    }
}

冒泡排序

什么是冒泡排序

一种排序方式，将数组中的元素两两比较，将较大的数据放在后面，依次对所有数据进行操作，直到完成所有排序

冒泡排序的具体实现步骤

例：数组{48，12，52，36，5}

第一次排序得出最大数 52 放在最后

第二次排序得出第二大数 48 排在倒数第二

第三次排序得出第三大数 36 排在倒数第三

第四次排序得出第四大数 12 排在倒数第四，最后剩下 5 最小，排在最后

因此我们可以发现，如果又n个数据进行排序，则需要进行比较n-1次，每比较完一轮后，下一次比较就会少一个数据参与比较

冒泡排序代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3, 5, 2, 1, 4};
        //1 2 3 4 5
        bubbleSort(arr);

    }

    private static void bubbleSort(int[] arr) {
        //外层循环控制的是次数 比数组的长度少一次.
        for (int i = 0; i < arr.length -1; i++) {
            //内存循环就是实际循环比较的
            //-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;
                }
            }
        }

        printArr(arr);
    }

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

快速排序

什么是快速排序

快速排序当每次递归时以第一个数为基准数，找到数组中找出所有比基准数小的，再找出所有比基准数大的，小的全放在左边，大的全放在右边，最后重新创建基准数

快速排序的具体实现步骤

1. 首先确定数组中最昨天的数为基准数baseNumber = arr[0]
2. 定义两个索引 left = 0，right = arr.size() - 1
3. left从左到右判断该索引处的元素是否比基准数大，若小于基准数则 left++，找到时停止
4. right从右到左判断该索引处的元素是否比基准数小，若大于基准数则right–，找到时停止
5. left与right都停止时，交换两个位置的值
6. 继续执行3、4、5步骤，当left == right时，将基准数与该索引处的数据交换
7. 基准数归为

快速排序代码实现

public class QuiteSortDemo {
    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);//排右边
    }
}