算法：支持重复元素的二分查找

近几天在处理的一个项目，需要频繁对一些有序超大集合进行目标查找，二分查找算法是这类问题的最优解。但是java的Arrays.binarySearch()方法，如果集合中有重复元素，而且遇到目标元素正好是这些重复元素之一，该方法只能返回一个，并不能将所有的重复目标元素都返回，没办法，只能自造轮子了。

先复习下二分查找的经典算法：

    private int binarySearch1(Integer[] A, Integer x) {
        int low = 0, high = A.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (A[mid].equals(x)) {
                return mid;
            } else if (x < A[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }

思路很简单，先定位到中间元素，如果中间元素比目标元素大，则扔掉后一半，反之扔掉前一半，如果正好一次命中，直接返回。

略做改进：

    private List<Integer> binarySearch2(Integer[] A, Integer x) {
        List<Integer> result = new ArrayList<Integer>();
        int low = 0, high = A.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (A[mid].equals(x)) {
                if (mid > 0) {
                    //看前一个元素是否＝目标元素
                    if (A[mid - 1].equals(x)) {
                        for (int i = mid - 1; i >= 0; i--) {
                            if (A[i].equals(x)) {
                                result.add(i);
                            } else break;
                        }
                    }
                }
                result.add(x);
                if (mid < high) {
                    //看后一个元素是否＝目标元素
                    if (A[mid + 1].equals(x)) {
                        for (int i = mid + 1; i <= high; i++) {
                            if (A[i].equals(x)) {
                                result.add(i);
                            } else break;
                        }
                    }
                }
                return result;
            } else if (x < A[mid]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return result;

    }

思路：命中目标后，看下前一个紧挨着的元素是否也是要找的元素，如果是，则顺着向前取，直到遇到不等于目标元素为止。然后再看后一个紧挨着的元素，做类似处理。

测试：

        Integer[] A = new Integer[]{1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 9};

        System.out.println("binarySearch1 => ");
        System.out.println(binarySearch1(A, 5));

        System.out.println("binarySearch2 => ");
        System.out.println(binarySearch2(A, 5));

binarySearch1 =>
5
binarySearch2 =>
[4, 5, 6]

从返回的下标值看，都在预期之中，但是事情并未到此止步，通常要查找的列表元素，并不是数值这么简单，一般是一些复杂的对象实例，为了做到通用，得弄成一个泛型版本：

   private <T> List<Integer> binarySearch4(List<T> A, T x, Comparator<? super T> comparator) {
        List<Integer> result = new ArrayList<Integer>();
        int low = 0, high = A.size() - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            int temp = comparator.compare(x, A.get(mid));
            if (temp == 0) {
                if (mid > 0) {
                    if (comparator.compare(x, A.get(mid - 1)) == 0) {
                        for (int i = mid - 1; i >= 0; i--) {
                            if (comparator.compare(A.get(i), x) == 0) {
                                result.add(i);
                            } else break;
                        }
                    }
                }
                result.add(mid);
                if (mid < high) {
                    if (comparator.compare(x, A.get(mid + 1)) == 0) {
                        for (int i = mid + 1; i <= high; i++) {
                            if (comparator.compare(x, A.get(i)) == 0) {
                                result.add(i);
                            } else break;
                        }
                    }
                }
                return result;

            } else if (temp < 0) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        return result;
    }

为了比较二个复杂对象实例的大小，引入了Comparator接口，可以根据业务需要，则调用者自定义比较规则。

测试一下：

先定义一个业务对象类AwbDto:

package com.cnblogs.yjmyzz.test.domain;

/**
 * Created by jimmy on 15/1/8.
 */
public class AwbDto {


    /**
     * 运单号
     */
    private String awbNumber;

    /**
     * 始发站
     */
    private String originAirport;

    public AwbDto(String awbNumber, String originAirport) {
        this.awbNumber = awbNumber;
        this.originAirport = originAirport;
    }

    public String getAwbNumber() {
        return awbNumber;
    }

    public void setAwbNumber(String awbNumber) {
        this.awbNumber = awbNumber;
    }

    public String getOriginAirport() {
        return originAirport;
    }

    public void setOriginAirport(String originAirport) {
        this.originAirport = originAirport;
    }
}

还需要定义AwbData比较大小的业务规则，假设：只要运单号相同，则认为相等（即：用运单号来区分对象大小）

    private class AwbDtoComparator implements Comparator<AwbDto> {

        @Override
        public int compare(AwbDto x, AwbDto y) {
            return x.getAwbNumber().compareTo(y.getAwbNumber());
        }
    }

测试代码：

        List<AwbDto> awbList = new ArrayList<AwbDto>();
        awbList.add(new AwbDto("112-10010011", "北京"));
        awbList.add(new AwbDto("112-10010022", "上海"));
        awbList.add(new AwbDto("112-10010033", "天津"));
        awbList.add(new AwbDto("112-10010044", "武汉"));
        awbList.add(new AwbDto("112-10010044", "武汉"));
        awbList.add(new AwbDto("112-10010055", "广州"));

        AwbDtoComparator comparator = new AwbDtoComparator();

        AwbDto x = new AwbDto("112-10010044", "武汉");


        System.out.println("binarySearch4 => ");
        System.out.println(binarySearch4(awbList, x, comparator));

binarySearch4 =>
[3, 4]

测试结果，一切顺利，皆大欢喜，可以去休息了。