Java 关于数组的基础算法-冒泡排序 选择排序 二分查找（的幼儿园解释）

复习一下ε=(´ο｀*)))

冒泡排序

n个数冒泡排序，从左到右两两比较，如果左边的大于右边的就交换（从小到大排序），第1轮比较下来以后最右边出现最大值，第2轮因为右1最大所以只要从 左到右2 两两比较就够了（结果：该次循环的最右出现该次循环的最大值），第三轮同理可以比第二轮少比较一次……一直到第n-1轮结束，这时左2出现 左1和左2 中的最大值（因为第n轮需要比较的数只有1个，可以省略这一轮）

选择排序

n个数选择排序，（从小到大排序）第1轮从左到右遍历记下最小值的索引，在第1轮结束的时候把 左1和最小值 进行交换（结果：左1出现最小值），第2轮因为左1是最小的，所以直接从左2开始从左到右遍历，记下该次循环的最小值索引（结果：该次循环的最左出现该次循环的最小值）……一直到第n-1轮结束，这时右2出现 右1和右2 中的最小值。

参考代码（Java）

public class test {
    public static void main(String [] args){
        int[] a = {12, 34, 14, 55, 16, 75, 28, 100};
        bubbleSort(a);
	    System.out.println(Arrays.toString(a));//输出
        selectSort(a);
        System.out.println(Arrays.toString(a));//输出
        int b = find(a,14);
        System.out.println(b);
        
    }
    /**
     * 冒泡排序（从小到大排序）两个两个比较，前面的大于后面就交换
     * @param arr 传入的数组
     */
    public static void bubbleSort(int[] arr){
        for (int i = 0;i<arr.length-1;i++){//比较到最后一个数时就不用比较了
            for(int j= 0;j<arr.length-1-i;j++){//-1是为了防止索引越界(因为是两个两个比较)
                if(arr[j]>arr[j+1]){//当前面的大于后面的，交换
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp ;
                }
            }
        }
    }
    /**
     * 选择排序，从大到小排序，选出后面最大的进行交换
     * @param arr 传入的数组
     */
    public static void selectSort(int [] arr){
        for (int i = 0;i<arr.length;i++) {
            int maxindex = i;
            for (int j = i + 1; j<arr.length; j++){
                if(arr[i]<arr[j]){
                    maxindex = j;//选出当前循环中最大值的索引
                }
            }
            int temp = arr[maxindex];//交换
            arr[maxindex]= arr[i];
            arr[i] = temp;
        }
    }

    /**
     * 二分查找
     * @param arr 传入的数组
     * @param a 要找的数字
     * @return 要找的数字的索引
     */
    public static int find(int[] arr,int a){
        int maxbound = arr.length-1;
        int minbound = 0;
        int result = arr.length>>1;
        while (a != arr[result]){
            if (a<arr[result]){
                maxbound -= 1;
            }
            else {
                minbound += 1;
            }
            if(minbound>maxbound){
                return -1;
            }
            result = (maxbound+minbound)>>1;
        }
        return result+1;
    }

}

图来自：
https://www.jianshu.com/p/9f724c880124
冒泡排序,插入排序,选择排序三种算法的优劣
这篇值得一看