冒泡排序，选择排序，二分查找

冒泡排序

public class Px {
    public static void main(String[] args) {
        int[] arr = {3, 7, 4, 1, 5};
        /**
         *  第一次排序  3, 7, 4, 1, 5
         *      3,7,4,1,5
         *      3,4,7,1,5
         *      3,4,1,7,5
         *      3,4,1,5,7
         *  第二次排序  3,4,1,5
         *      3，4，1，5
         *      3，1，4，5
         *      3，1，4，5
         *  第三次排序  3，1，4
         *      1，3，4
         *      1，3，4
         *  第四次排序  1，3
         *      1，3
         *
         *  根据分析可以得出：
         *  循环次数=数组长度-1
         *  每次循环排序的次数 =数组长度-循环次数
         */

        for (int i = 0; i < arr.length - 1; i++) {  //循环次数  i =数组长度-1
            for (int j = 0; j < arr.length - 1 - i; j++) {  //每次循环的排序次数  j =数组长度-i
                //判断，如果前面的元素 >后面的元素就交换他们的位置
                if (arr[j] > arr[j + 1]) {
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;

                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

选择排序

class XuanZePaiXu {
    public static void main(String[] args) {
        /**
         * 选择排序比冒泡排序效率更高   主要在于交换位置上  冒泡排序是一个一个进行位置互换，而选择排序是直接进行位置互换
         *  每循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值
         *  和最前面的数据进行位置交换
         *
         *  3,1,6,2,5
         *  第一次循环       3,1,6,2,5
         *  1，3，6，2，5
         *  第二次循环       3，6，2，5
         *  2，6，3，5
         *  第三次循环       6，3，5
         *  3，6，5
         *  第四次循环       6，5
         *  5，6
         *
         *  观察可以得出： 循环次数=数组长度-1
         *  每次循环我们都可以确定一个最小的数（最左边的数）如何确定的呢？？？
         */

        int[] arr = {3, 1, 6, 2, 5};

        for (int i = 0; i < arr.length - 1; i++) {  //既是循环的次数，也是参加这堆数据比较的最左边的下标
//            假设最小的下标为i
            int min = i;
            // 为啥是 i+1 ？？？？ 因为 i 是参加这堆数据比较的最左边的下标，所以我们需要从它的后一位开始进行比较
            for (int j = i + 1; j < arr.length; j++) {
                // 假设有比最小的值还小的就进行赋值
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            // 如果 min进行了改变，说明有比假设值跟小的值，进行位置互换
            if (min != i) {
                int temp;
                temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

二分查找

class ErFenChaZhao {
    // 使用二分法查找的数组，必须是有序数组
    public static void main(String[] args) {
        int[] arr = {100, 223, 452, 523, 747, 888, 990};
        int index = binarySearch(arr, 523);
        System.out.println(index == -1 ? "改元素不存在！" : "该元素下标为：" + index);
    }

    public static int binarySearch(int[] arr, int dest) {
        //开始下标
        int begin = 0;
        // 结束下标
        int end = arr.length - 1;

        //开始元素的下标只要是在结束元素下标的左边，就有机会继续循环
        while (begin <= end) {
            //中间元素下标
            int mid = (begin + end) / 2;
            if (arr[mid] == dest) {
                return mid;
            } else if (arr[mid] < dest) {
                //目标在 中间的右边
                // 开始元素下标需要发生变化（开始元素的下标需要重新赋值）
                begin = mid + 1;  //一直增
            } else {
                //arr[mid] >dest
                // 目标在 中间的左边
                // 修改结束元素的下标
                end = mid - 1; // 一直减
            }

        }
        return -1;
    }
}