二分查找算法

题目：给定一个已经排好序的数组和一个目标数据，把目标数据插入给定的数组中

思路：因为数组是已经排好序的，所以可以用二分查找来快速定位要插入的位置

代码实现：

public class InsertIntoSortedArray {
    public static void main(String[] args) {
        int[] sortedArray = {1, 2, 3, 5, 6, 7, 8, 9}; // 已经排好序的数组
        int numToInsert = 4; // 要插入的数
        int insertIndex = findInsertIndex(sortedArray, numToInsert);
        int[] newArray = insertIntoArray(sortedArray, numToInsert, insertIndex);
        System.out.println("插入后的数组：");
        for (int num : newArray) {
            System.out.print(num + " ");
        }
    }

    // 二分查找插入位置
    private static int findInsertIndex(int[] sortedArray, int target) {
        int left = 0;
        int right = sortedArray.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (sortedArray[mid] == target) {
                return mid; // 目标数已存在于数组中，插入位置为mid
            } else if (sortedArray[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return left; // 目标数不存在于数组中，插入位置为left
    }

    // 将数插入数组
    private static int[] insertIntoArray(int[] sortedArray, int target, int insertIndex) {
        int[] newArray = new int[sortedArray.length + 1];
        for (int i = 0, j = 0; i < newArray.length; i++, j++) {
            if (i == insertIndex) {
                newArray[i] = target;
                j--;
            } else {
                newArray[i] = sortedArray[j];
            }
        }
        return newArray;
    }
}

 有序数组中目标数是否存在：

 /**
     * 有序数组中目标数是否存在
     *
     * @param arr
     * @param target
     * @return
     */
    private int findExistNum(int arr[], int target) {
        int left = 0;
        int right = arr.length - 1;
        int middle = 0;
        while (left <= right) {
            middle = left + ((right - left) >> 1);
            if (arr[middle] == target) {
                return middle;
            }
            if (arr[middle] > target) {
                right = middle - 1;
            }
            if (arr[middle] < target) {
                left = middle + 1;
            }
        }
        return -1;
    }

    @Test
    public void testfindExistNum() {
        int[] arr = new int[]{1, 3, 5, 7, 10};
        System.err.println(findExistNum(arr, 7));
    }

有序数组中目标数出现在数组中的第一个位置(最左边)：

 /**
     * 有序数组中目标数的最左位置
     *
     * @param arr
     * @param target
     * @return
     */
    private int findExistNumLeft(int arr[], int target) {
        int left = 0;
        int right = arr.length - 1;
        int middle = -1;
        int tmp = -1;
        while (left <= right) {
            middle = left + ((right - left) >> 1);
            if (arr[middle] == target) {
                tmp = middle;
                right = middle - 1;
                continue;
            }
            if (arr[middle] > target) {
                right = middle - 1;
            }
            if (arr[middle] < target) {
                left = middle + 1;
            }
        }
        return tmp;
    }

    @Test
    public void testfindExistNumLeft() {
        int[] arr = new int[]{1, 3, 3, 5, 7, 10};
        System.err.println(findExistNumLeft(arr, 3));
    }

有序数组中目标数出现在数组中的最后一个位置(最有边)：

 /**
     * 有序数组中目标数的最右位置
     *
     * @param arr
     * @param target
     * @return
     */
    private int findExistNumRight(int arr[], int target) {
        int left = 0;
        int right = arr.length - 1;
        int middle = -1;
        int tmp = -1;
        while (left <= right) {
            middle = left + ((right - left) >> 1);
            if (arr[middle] == target) {
                tmp = middle;
                left = middle + 1;
                continue;
            }
            if (arr[middle] > target) {
                right = middle - 1;
            }
            if (arr[middle] < target) {
                left = middle + 1;
            }
        }
        return tmp;
    }

    @Test
    public void testfindExistNumRight() {
        int[] arr = new int[]{1, 3, 3, 3, 3, 3, 5, 7, 10};
        System.err.println(findExistNumRight(arr, 3));
    }

局部最小：给定一个无需数组，它的特点是任何相邻的两个数不相等，在这个数组中找出一个局部最小即可，局部最小的定义：如果一个数比它两边的数据都小，那么它就是局部最小

 /**
     * 给定一个无需数组，它的特点是任何相邻的两个数不相等，在这个数组中找出一个局部最小即可
     * 局部最小的定义：如果一个数比它两边的数据都小，那么它就是局部最小
     */

    private int findLocalMin(int arr[]) {
        int left = 0;
        int right = arr.length - 1;
        int middle = 0;
        if (arr[left] < arr[1]) {//第一个元素比它右边小，直接返回
            return left;
        }
        if (arr[right] < arr[right - 1]) {//最后一个元素比它左边小，直接返回
            return right;
        }
        while (left <= right) {
            middle = left + ((right - left) >> 1);
            if (middle > 0 && arr[middle] > arr[middle - 1]) {
                right = middle - 1;
            } else if (middle < arr.length - 1 && arr[middle] > arr[middle + 1]) {
                left = middle + 1;
            } else {
                return middle;
            }
        }
        return -1;
    }

    @Test
    public void testfindLocalMin() {
        int[] arr = new int[]{2, 1, 0, 1, 5};
        System.err.println(findLocalMin(arr));
    }