二分查找

public class Demo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int num = 2; //查找2在哪个位置
        int index = querySearch(arr, num, 0, arr.length - 1);
        System.out.println(index); //输出1
    }

    public static int querySearch(int[] arr, int num, int start, int end) {
        while (start <= end) {
            int midIndex = (start + end) >> 1; //除以2得到一半的元素位置
            //1, 2, 3, 4, 5, 6, 7, 8, 9, 10
            //举例: 第一次循环midIndex = (9/2 = 4) midIndex等于5
            if (num < arr[midIndex]) {  //如果要找到的数字 小于元素位置 那么尾部舍去
                //1, 2, 3, 4, 5,
                end = midIndex - 1;     //现在最后一位元素等于 最开始除以2的位置 -1位元素
                //举例: 第一遍循环时end等于4 
            } else if (num > arr[midIndex]) {  //如果要找的数字 大于元素位置 那么前面去掉
                start = midIndex + 1;  //现在最开始的元素等于 最开始除以2的位置+1
            }else{      //否则就是 == 要找的数等于现在这个数字 那么直接return 元素位置
                return midIndex;
            }
        }
        return -1;
    }
}

冒泡排序

public class Demo {
    public static void main(String[] args) {
        int[] arr = {3, 5, 6, 5, 1, 6, 9, 2, 5};

        //外层循环次数
        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;
                }
            }
        }
        System.out.println(Arrays.toString(arr)); //输出结果 [1, 2, 3, 5, 5, 5, 6, 6, 9]
        //弊端: 假如第一次就循环排序成功了 但是还是会再循环到arr.length结束位置 所以会造成资源浪费
    }
}

快排

public class Demo {
    public static void main(String[] args) {
        int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};
        
        //用递归实现 从小到大快排 
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
        //输出结果: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }

    private static void quickSort(int[] arr, int left, int right) {
        if (left > right) {
            return;
        }
        //记录每次递归的值
        int left0 = left; //记录初始最左边的元素位置
        int right0 = right; //记录初始最右边的元素位置
        int baseNumber = arr[left0];  //记录基准数的值
        while (left != right) { //左边和右边元素不重叠
            //右边要比基准数小的 如果大于则继续往左边查找
            while (arr[right] >= baseNumber && right > left) {
                right--;
            }
            //左边要比基准数大的 如果小于则继续往右边查找
            while (arr[left] <= baseNumber && right > left) {
                left++;
            }
            //如果找到则循环停止
            //交换两边数据
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        //重叠 基准数归为
        int temp = arr[left];
        arr[left] = arr[left0];
        arr[left0] = temp;

        //排左边
        quickSort(arr, left0, left - 1);
        //排右边
        quickSort(arr, left + 1, right0);
    }
}