找出数组中的重复元素

出自剑指offer，题目如下。

我给出了两个解法以及官方解法，如下所示。

package com.jeaven;

/*
* 剑指offer_problem3: 找到数组中的重复元素
* */
public class Problem3 {
    /*
    * 测试
    * */
    public static void main(String[] args) {
        //测试数组
        int[] testArray = {4,3,5,2,5,3};
        //解法一
        Solution1 s1 = new Solution1();
        long startTime = System.nanoTime();
        s1.solve(testArray);
        long endTime = System.nanoTime();
        long spendTime1 = endTime - startTime;
        //解法二
        Solution2 s2 = new Solution2();
        startTime = System.nanoTime();
        s2.solve(testArray);
        endTime = System.nanoTime();
        long spendTime2 = endTime - startTime;
        //解法三
        int[] testArray1 = {4,3,5,2,5,3};
        Solution3 s3 = new Solution3();
        startTime = System.nanoTime();
        s3.solve(testArray1);
        endTime = System.nanoTime();
        long spendTime3 = endTime - startTime;
        //比较程序运行效率
        System.out.println("solution1 spends time: " + spendTime1 + " ns");
        System.out.println("solution2 spends time: " + spendTime2 + " ns");
        System.out.println("solution3 spends time: " + spendTime3 + " ns");
    }
}


/*
 * 解法一：选定某个元素，查找数组中剩下元素有没有重复的元素
 * 时间复杂度为O(n^2)
 * */
class Solution1 {
    public boolean solve(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            int curr = i;
            for(int j = 0; j < arr.length; j++) {
                if(arr[j] == arr[i] && i != j) {
                    System.out.println("solution1: " + arr[i]);
                    return true;
                }
            }

        }
        return false;
    }
}


/*
 * 那么优化一下
 * 解法二：先排序，遍历数组，查看相邻元素是否重复
 * 使用O(n)的快速排序，总的时间复杂度则为O(nlgn)
 * */
class Solution2 {
    public boolean solve(int[] arr) {
        //使用快速排序
        quickSort(arr, 0, arr.length - 1);
        int temp = 0;
        for(int i = 1; i < arr.length; i++) {
            if(arr[temp] == arr[i]) {
                System.out.println("solution2: " + arr[i]);
                return true;
            } else {
                temp = i;
            }
        }
        return false;
    }

    //快速排序partition函数
    private int partition(int[] arr, int start, int end) {
        //选数组第一个元素为排序基准
        int k = start;
        int p = start;
        for(int q = p + 1; q <= end; q++) {
            if(arr[q] < arr[k]) {
                p = p + 1;
                int temp = arr[p];
                arr[p] = arr[q];
                arr[q] = temp;
            }
        }

        int temp = arr[p];
        arr[p] = arr[start];
        arr[start] = temp;
        return p+1;
    }

    //快速排序
    private void quickSort(int[] arr, int start, int end) {
        if(start < end) {
            int k = partition(arr, start, end);
            quickSort(arr, start, k-1);
            quickSort(arr, k+1, end);
        }
    }

}


/*官方解法: 遍历数组，比较数组的下标和对应元素是否相等，如果不相等交换arr[i]和arr[arr[i]]，相等则找到重复数字*/
class Solution3 {
    public boolean solve(int[] arr) {
        for(int i = 0; i < arr.length; i++) {
            while(arr[i] != i) {
                if(arr[i] != arr[arr[i]]) {
                    int temp = arr[i];
                    arr[i] = arr[temp];
                    arr[temp] = temp;
                } else {
                    System.out.println("solution3: " + arr[i]);
                    return true;
                }
            }
        }
        return false;
    }
}

我比较了三种方法的程序运行时间，如下图所示。显然第三种解法更好点，但是限制于题目的要求，对数组元素的范围有要求。先排序再查找的方法适合任意数组。

顺便一提，在写快排的时候得格外小心，我没有一次写对，还调试了一会，需要注意快排的细节，下图是快排的算法逻辑。