面向对象的思维实现二分查找

一维数组

首先我们关注点就需要分离，我们只需要考虑需要用什么，而不需要考虑他如何去实现，我们先写出二分查找的逻辑：当查找一维数组的时候，如果找到了，就返回下标，如果未找到，返回-1；
然后我们将区间抽象出来：
然后具体实现区间：

代码：

class Range {
    private final int[] array;
    private int left;
    private int right;

    public Range(int[] array) {
        this.array = array;
        this.left = 0;
        this.right = array.length - 1;
    }

    public int size() {
        return right - left + 1;
    }

    //中间元素的值
    public int getMidValue() {
        return array[getMidIndex()];
    }

    //中间元素的下标
    public int getMidIndex() {
        return (left + right) / 2;
    }

    public void discardLeftPart() {
        left = getMidIndex() + 1;
    }

    public void discardRightPart() {
        right = getMidIndex() - 1;
    }
}
public class BinarySearch {
    public static int binarySearch(int[] array, int target) {
        //将数组抽象成区间对象
        Range range = new Range(array);

        //当区间还有数时，查找还得继续
        while (range.size() > 0) {
            //获取中间元素
            int midValue = range.getMidValue();
            if (midValue == target) {
                return range.getMidIndex();
            } else if (midValue < target) {
                //丢掉左半边
                range.discardLeftPart();
            } else {
                //丢掉右半边
                range.discardRightPart();
            }
        }
        return -1;
    }
}

/**
 * 二分查找的测试
 */
public class BinarySearchTest {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int a = BinarySearch.binarySearch(arr, 5);
        System.out.println(a);
    }
}

具体结果：

二维数组

解法1：

将二维数组转换为一维数组：
主要思想和上面一样，我们将二维数组，首先转换为一维数组，然后在实现二分查找：返回其一维数组下标：即在二维数组中是第几个元素。

代码：

import java.util.Arrays;
/**
 *二维数组的二分查找实现
 */
class Range1 {
    private final int[][] array;
    private int left;
    private int right;
    private int[]arr;

    public Range1(int[][] array, int m, int n) {
        //二维数组转换为一维数组
        int[] arr= new int[m*n];
        int index = 0;
        for (int[] a : array) {
            for (int element : a) {
                arr[index++] = element;
            }
        }
//        System.out.println(Arrays.toString(arr));
        this.array = array;
        this.arr=arr;
        this.left = 0;
        this.right = arr.length-1;
    }
    public int size() {
        return right - left + 1;
    }

    //中间元素的值
    public int getMidValue() {
        return arr[getMidIndex()];
    }

    //中间元素的下标
    public int getMidIndex() {
        return (left + right) / 2;
    }

    public void discardLeftPart() {
        left = getMidIndex() + 1;
    }

    public void discardRightPart() {
        right = getMidIndex() - 1;
    }
}

public class BinarySearch2 {
    public static int binarySearch2(int[][] array, int m, int n, int target) {

        Range1 range1 = new Range1(array, m, n);

        while (range1.size() > 0) {
            int midValue = range1.getMidValue();
            if (midValue == target) {
                return range1.getMidIndex();
            } else if (midValue < target) {
                range1.discardLeftPart();
            } else {
                range1.discardRightPart();

            }
        }
        return -1;
    }
}

/**
 * 二分查找的测试
 */
public class BinarySearchTest {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int a = BinarySearch.binarySearch(arr, 5);
        System.out.println(a);
    }
}

具体结果：

解法2：

利用将区间抽象出来，用面向对象的思维求解：

代码：

package binary_Serch;

/**
 * 二维数组的二分查找
 */
public class binary_Search {
    //返回一个下标放在一维数组中
    public static int[] search(int[][] array, int rows, int columns, long target) {
        Range range = new Range(array, rows, columns);

        while (range.size() > 0) {
            int middleValue = range.getMiddleValue();
            if (target == middleValue) {
                return range.getMiddleIndex();
            } else if (target < middleValue) {
                range.discardRightPart();
            } else {
                range.discardLeftPart();
            }
        }
        // 只要返回特殊值表示没有找到即可
        return new int[]{-1, -1};
    }
}

package binary_Serch;

/**
 * Range 区间
 */
public class Range {
    private final int[][] array;
    private final int columns;

    private int lowRow;
    private int lowColumn;

    private int highRow;
    private int highColumn;

    public Range(int[][] array, int rows, int columns) {
        this.array = array;
        this.columns = columns;

        this.lowRow = 0;
        this.lowColumn = 0;
        this.highRow = rows - 1;
        this.highColumn = columns - 1;
    }

    //获取区间元素
    public int size() {
        return (columns - lowColumn) + ((highRow - lowRow - 1) * columns) + (highColumn + 1);
    }

    //获取中间元素的值
    public int getMiddleValue() {
        int[] index = getMiddleIndex();
        int row = index[0];
        int col = index[1];

        return array[row][col];
    }

    //获取中间元素的下标
    public int[] getMiddleIndex() {
        int halfSize = size() / 2;
        int middleRow = lowRow;
        int middleColumn = lowColumn;
        middleColumn += halfSize;
        // middleColumn 还不是一个合法下标
        while (middleColumn >= columns) {
            middleRow++;
            middleColumn -= columns;
        }
        return new int[]{middleRow, middleColumn};
    }

    //丢掉左边
    public void discardLeftPart() {
        int[] index = getMiddleIndex();
        int row = index[0];
        int col = index[1];
        lowRow = row;
        lowColumn = col + 1;
        if (lowColumn >= columns) {
            lowRow++;
            lowColumn = 0;
        }
    }

    //丢掉右边
    public void discardRightPart() {
        int[] index = getMiddleIndex();
        int row = index[0];
        int col = index[1];
        highRow = row;
        highColumn = col - 1;
        if (highColumn < 0) {
            highRow--;
            highColumn = columns - 1;
        }
    }
}

package binary_Serch;
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        int[][] array = {
                {1, 2, 3, 4, 5},
                {6, 7, 8, 9, 10},
                {11, 12, 13, 14, 15}
        };
        int rows = 3;
        int columns = 5;

        for (long target = 0; target <= 16; target++) {
            int[] index = binary_Search.search(array, rows, columns, target);

            System.out.printf("查找 %d 的结果是: %s\n", target, Arrays.toString(index));
        }
    }
}

具体结果：

ps：还有很多解法，等我学会了继续完善，嘿嘿！