算法（冒泡、选择、二分）

今天写三种算法：冒泡排序(两种)、选择排序、二分法查询

1 冒泡排序

1.1 将较小的数向前移动

/**
     * 冒泡排序，将较小的数向前移动
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        //第一层循环，要确定位置的数组的索引，因为在确定 arr[length - 2] 的时候能直接确认 arr[length - 1]
        //所以最后确认的位置是 arr[length - 2]
        for(int i = 0;i < arr.length - 1;i++){
            // 第二层循环，数据从后往前移动，最终是和arr[i]进行比较
            for(int j = arr.length - 1;j > i;j--){
                //与前一个数字进行判断，将小的数字放在前面
                if(arr[j] < arr[j - 1]){
                    //交换
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
    }

2 较大的数向后移

/**
     * 冒泡排序，将较大的数向后移动
     * @param arr
     */
    public static void bubbleSort(int[] arr){
        //第一层循环，要确定位置的数组的索引，因为在确定 arr[1] 的时候能直接确认 arr[0]
        //所以最后确认的位置是 arr[1]
        for(int i = arr.length - 1;i >= 1;i--){
            // 第二层循环，数据从前往后移动，最终是和arr[i]进行比较
            for(int j = 0;j <= i - 1;j++){
                //与前一个数字进行判断，将大的数字放在后面
                if(arr[j] > arr[j + 1]){
                    //交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

选择排序

/**
     * 选择排序
     * 将所有待排序元素中最小的元素放在序列的指定位置
     * @param arr
     */
    public static void selectionSort(int[] arr){
        // 第一层循环表示要确定的索引位置,直到arr.length - 2，即是指定位置
        for(int i = 0;i < arr.length - 1;i++){
            //第二层表示所有的待排序元素
            for(int j = i + 1;j < arr.length;j++){
                //将最小的元素放在索引为i的位置
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

二分算法

 /**
     * 二分法的前提是元素有序排列
     * 通过每一次缩减一半的查询数据来达到快速查询
     *
     * @param arr
     * @param destNum
     * @return
     */
    public static int binarySearch(int[] arr, int destNum) {
        //头索引，和尾索引
        int start = 0;
        int end = arr.length - 1;
        //调整头索引和尾索引的位置，使得每次查询数量是上一次的一半
        while (start <= end) {
            //得到中间索引
            int middle = (end + start) >> 1;
            //中间元素就是目标元素的情况下，直接返回中间索引
            if (arr[middle] == destNum) {
                return middle;
            }
            //中间元素比目标数值大，由于元素从小到大有序排列，所以目标数值在 start 到 middle-1 中间
            if (arr[middle] > destNum) {
                //将尾索引变成middle - 1
                end = middle - 1;
                continue;
            }
            //中间元素比目标数值小，由于元素从小到大有序排列，所以目标数值在 middle+1 到 end 中间
            if (arr[middle] < destNum) {
                //将起始索引变成middle + 1
                start = middle + 1;
                continue;
            }
        }
        //数组中没有这个元素，返回 -1
        return -1;
    }