找出數組中的重復元素

出自劍指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;
    }
}

我比較了三種方法的程序運行時間，如下圖所示。顯然第三種解法更好點，但是限制於題目的要求，對數組元素的范圍有要求。先排序再查找的方法適合任意數組。

 

順便一提，在寫快排的時候得格外小心，我沒有一次寫對，還調試了一會，需要注意快排的細節，下圖是快排的算法邏輯。