5,数组中重复的数字 剑指offer java实现

题目描述：
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

import java.util.Arrays;

public class demo9 {
    // Parameters:
    //    numbers:     an array of integers
    //    length:      the length of array numbers
    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    public static  boolean duplicate(int[] nums, int length, int[] duplication) {
        if (nums == null || length <= 0)
            return false;
        for (int i = 0; i < length; i++) {
        //代码只用到了i=0，把nums[0]号位置一直作为交换点，
        //往后挨个交换把数字都放到各自的索引上，当交换到重复的数字的时候就会检测出来
        //因为之前已经把不重复的数字放到各自的索引上了，出现了与索引值相同的数字自然重复
            while (nums[i] != i) {
                if (nums[i] == nums[nums[i]]) {
                    duplication[0] = nums[i];
                    //输出一个数组
                    System.out.println(Arrays.toString(duplication));
                    return true;
                }
                swap(nums, i, nums[i]);
            }
        }
        return false;
    }

    private  static  void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }

    public static void main(String[] args) {
        int[] a ={2,3,1,0,2,5};
        int[] b=new int[5];
        System.out.println(demo9.duplicate(a,6,b));

    }

}

网友方法：
问题一（可改变数组）

public class Duplicate1 {
    //数组长度为n，数字范围0-(n-1)，可改变数组顺序

    public static int getDuplicateNumber(int[] numbers, int length){
        //检测输入数组的有效性
        if (numbers == null || length <= 0){
            return -1;
        }
        //检测数组中数值是否合法
        for (int number : numbers){
            if (number < 0 || number>= length){
                return -1;
            }
        }

        //检测是否存在重复数字
        for (int i = 0; i < length; i++){
            //数字与下标相等跳过
            while (numbers[i] != i){
                //将numbers[i]的数字与numbers[numbers[i]]比较
                if (numbers[i] == numbers[numbers[i]]){
                    //相等则找到重复数字
                    return numbers[i];
                }
                else{
                    //否则交换数字，将numbers[i]中数字放到与下标相等的位置
                    int t = numbers[i];
                    numbers[i] = numbers[t];
                    numbers[t] = t;
                }
            }
        }

        //没有找到重复数字返回
        return -1;
    }

    //测试用例
    public static void main(String[] args){
        //不含重复数字
        int[] numbers1 = {1, 2, 3, 4, 5, 0};
        //含一个重复数字
        int[] numbers2 = {1, 2, 3, 2, 5, 0};
        //含多个重复数字
        int[] numbers3 = {1, 2, 3, 2, 5, 5};
        //不合法的输入
        int[] numbers4 = {};
        int[] numbers5 = null;
        int[] numbers6 = {1, 2, 3, 2, 7, 5};

        System.out.println("numbers1中的重复数字：" + Duplicate1.getDuplicateNumber(numbers1, 6));
        System.out.println("numbers2中的重复数字：" + Duplicate1.getDuplicateNumber(numbers2, 6));
        System.out.println("numbers3中的重复数字：" + Duplicate1.getDuplicateNumber(numbers3, 6));
        System.out.println("numbers4中的重复数字：" + Duplicate1.getDuplicateNumber(numbers4, 0));
        System.out.println("numbers5中的重复数字：" + Duplicate1.getDuplicateNumber(numbers5, 0));
        System.out.println("numbers6中的重复数字：" + Duplicate1.getDuplicateNumber(numbers6, 6));

    }
}

问题二（不可改变数组）：

public class Duplicate2 {
    //数组长度为n+1，数字范围1-n，不可改变数组顺序
    public static int getDuplicateNumber(int[] numbers, int length) {
        //检测输入数组的有效性
        if (numbers == null || length <= 0) {
            System.out.println("输入不合法");
            return -1;
        }
        //检测数值范围
        for (int number : numbers){
            if (number > numbers.length || number < 1){
                System.out.println("数组取值超出范围");
                return -1;
            }
        }

        //运用二分法
        int lo = 1;
        int hi = numbers.length - 1;
        while(hi >= lo) {
            int mid = (lo + hi) / 2;
            int count = countRange(numbers, lo, mid);
            //找到则打印
            if (lo == hi){
                if (count > 1){
                    System.out.println("重复的数字有：" + lo);
                    return lo;
                }
                break;
            }
            //缩小有重复数字的取值范围
            if (count > mid - lo + 1) {
                hi = mid;
            }
            else{
                lo = mid + 1;
            }
        }
        return -1;
    }

    private static int countRange(int[] numbers, int a, int b){
        int count = 0;
        for (int number : numbers){
            if (number >= a && number <= b)
                count++;
        }
        return count;
    }

    //测试用例
    public static void main(String[] args){
        //含一个重复数字
        int[] numbers1 = {1, 3, 3, 4, 5, 2};
        //含多个重复数字
        int[] numbers2 = {1, 2, 3, 2, 5, 5};
        //不合法的输入
        int[] numbers3 = {};
        int[] numbers4 = null;
        int[] numbers5 = {1, 2, 3, 2, 7, 5};

        System.out.println("numbers1中存在的重复数字：" + Duplicate2.getDuplicateNumber(numbers1, 6));
        System.out.println("numbers2中存在的重复数字：" + Duplicate2.getDuplicateNumber(numbers2, 6));
        System.out.println("numbers3中存在的重复数字：" + Duplicate2.getDuplicateNumber(numbers3, 0));
        System.out.println("numbers4中存在的重复数字：" + Duplicate2.getDuplicateNumber(numbers4, 0));
        System.out.println("numbers5中存在的重复数字：" + Duplicate2.getDuplicateNumber(numbers5, 6));

    }

}