二分查找和优化冒泡排序

　　

二分查找

何为二分查找

1,前提:有已排序数组 A (假设已经做好)

2.定义左边界 L 、右边界 R ,确定搜索范围,循环执行二分查找(3、4两步)

3.获取中间索引 M = Floor (( L + R )/2)

4.中间索引的值 A [ M ] 与待搜索的值 T 进行比较

① A [ M ]= T 表示找到,返回中间索引

② A [ M ]> T ,中间值右侧的其它元素都大于 T ,无需比较,中间索引左边去找, M - 1设置为右边界,重新查找

③ A [ M ]< T ,中间值左侧的其它元素都小于 T ,无需比较,中间索引右边去找, M + 1设置为左边界,重新查找

5.当 L > R 时,表示没有找到,应结束循环

/***
 * 2分查找
 */
public class HalfFind {
    public static void main(String[] args) {
        int[] arr = {1,11,24,33,45,48,56,68,69,73,77,83,85,90,99,107};
        int target = 99;
        System.out.println(halfFind(arr,target));
    }

    private static String halfFind(int[] arr, int target) {
        // l:左边界 r:右边界 m:中间索引
        int l = 0,r = arr.length-1,m;
        // 记录查找次数
        int num = 0;
        // 如果左边界大于右边界说明没有找到数据退出循环
        while (l <= r) {
            num++;
            // m = (l + r) / 2;
            //使用右移1位 可以解决int最大数值数据溢出问题 不考虑大数据量可以直接使用 m = (l + r) / 2;
            m = (l + r) >>> 1;
            if (arr[m] == target) {
                return "查找"+num+"次,找到该元素的索引是:"+m;
            } else if (arr[m] > target) {
                //说明中间索引右侧元素都大于target 右侧不用比较 把右边界改为 m-1
                r = m - 1;
            } else {
                //说明中间索引左侧元素都小于target 左侧不用比较 把左边界改为 m+1
                l = m + 1;
            }
        }
        return "查找"+num+"次,没有找到该元素!";
    }
}

　　

　　冒泡排序

　　　　一般冒泡排序都使用双重for循环依次遍历比对,这里介绍一种记录每次最后一次交换索引位置实现的方法,可以减少不必要的循环次数

/***
 * 冒泡排序
 */
public class BubbleSort {

    public static void main(String[] args) {
        // 原始数组数据
        int[] arr = {7,2,11,30,26,32,46,57};
        bubbleSort(arr);
    }
    //排序方法
    public static void bubbleSort(int[] arr) {
        // 每次循环需要比较的次数 第一次是数组长度-1
        int n = arr.length - 1;
        while (true) {
            // 用来记录最后一次交换的索引的位置
            int last = 0;
            // 每次循环最大次数是上一次最后一次交换的索引的位置
            for (int i = 0; i < n; i++) {
                System.out.println("比较次数:"+(i+1));
                if (arr[i] > arr[i + 1]) {
                    // 如果前一个元素比后一个元素大交换元素的位置
                    swap(arr,i,i+1);
                    // 给最后一次交换的索引位置赋值
                    last = i;
                }
            }
            // 给下次循环次数赋值
            n = last;
            System.out.println("排序后数组:"+ Arrays.toString(arr));
            if (n == 0) {
                // 如果下次循环次数是0结束循环
                break;
            }
        }
    }
    // 交换数组位置方法
    public static void swap(int[] arr,int i,int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}