二分查找

限制：序列必须有序，每次只能查找一个

int[] st = {1, 3, 5, 7, 9};
int min = 0;
int max =st.length-1;
int mid = (min+max)/2;
int sercah = 3;

while (st[mid] != sercah){
    if(st[mid] > sercah){
        max = mid -1;
    }else if(st[mid] < sercah){
        min = mid +1;
    }
    mid = (min+max)/2;
}
System.out.println("你要查找的值在数组位置是："+mid);

冒泡排序

 冒泡排序，两两比较的元素是没有被排序过的元素

public class BubbleSort {
    public static void main(String[] args) {
        test01();
        System.out.println(Arrays.toString(test02(new int[]{10, 2, 52, 9, 10, 12, 15})));
        System.out.println(Arrays.toString(test03(new int[]{3, 4, 2, 1, 6, 7, 8})));
    }

    /** 
    * @Description: 经典冒泡排序
    * @Param:  
    * @return:  
    * @Author: BiMoYuanKong
    * @Date: 2022/5/7  
    */ 
    public static void test01() {
        int[] array = new int[]{3, 12, 1, 45, 685, 12, 4};
        for (int i = 0; i < array.length - 1; i++) {  //确定比较轮次，一共 n-1 趟，至于为什么要减1，i是从0开始的，你自己好好想想吧。
            //每次都是从0开始冒泡
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {   //两个挨着的元素进行比较
                    //定义临时变量temp,交换位置
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }

    /**
     * @Description: 冒泡排序初步优化，优化执行次数
     * 执行到最后三轮的时候，发现整个数列已经是有序的了，将进行优化一下。
     * 思路：
     *   利用布尔变量 isSorted作为标记。如果在本轮排序中，元素有交换，则说明数列无序；
     *   如果没有元素交换，说明数列已然有序，直接跳出大循环。
     * @Param:
     * @return:
     * @Author: BiMoYuanKong
     * @Date: 2022/5/6
     */
    public static int[] test02(int[] array2) {
        if (array2 == null || array2.length < 2) {
            return array2;
        }
        for (int i = 0; i < array2.length - 1; i++) {
            boolean isSorted = true;    //有序标记，每一轮的初始值都是true。
            for (int j = 0; j < array2.length - 1 - i; j++) {
                if (array2[j] > array2[j + 1]) {
                    isSorted = false;   //当出现元素交换的情况时候，说明不是有序，标记变为false.
                    int temp = array2[j];
                    array2[j] = array2[j + 1];
                    array2[j + 1] = temp;
                }
            }
            //当一趟下来之后还没有发生元素交换的时候，直接跳出大循环。
            if(isSorted){
                break;
            }
        }
        return array2;
    }

    /** 
    * @Description: 冒泡排序进一步优化，优化每次执行排序次数中的对比次数
     * 那如果数列中前半部分是无序的，后半部分是有序的呢？比如（3，4，2，1，5，6，7，8）这个数组，
     * 其实后面的许多元素已经是有序的了，但是每一轮还是白白比较了许多次呢？
     * 实现思路：
     *   在每一轮排序的最后，记录一下最后一次元素交换的位置，那个位置也就是无序数列的边界，再往后就是有序区了
    * @Param:
    * @return:
    * @Author: BiMoYuanKong
    * @Date: 2022/5/6
    */ 
    public static int[] test03(int[] array3){
        if (array3 == null || array3.length<2){
            return array3;
        }
        //设置变量记录最后一次交换的位置
        int lastExchangeIndex = 0;
        //这是无序数列的边界，每次比较只需要比到这里为止
        int sortBorder = array3.length - 1;
        for (int i = 0; i < array3.length - 1; i++) {
            boolean isSorted  = true;
            for (int j = 0; j < sortBorder; j++) {
                if(array3[j] > array3[j+1]){
                    isSorted  = false;
                    int temp = array3[j];
                    array3[j] = array3[j+1];
                    array3[j+1] = temp;
                    lastExchangeIndex = j;
                }
            }
            sortBorder = lastExchangeIndex;
            if (isSorted)
               break;
        }
        return array3;
    }

}

参考：
冒泡排序（超详细）