劍指 Offer 03. 數組中重復的數字

【題目來源】

https://leetcode-cn.com/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/

【題目內容】

【解題思路】

思路一：遍歷(超出時間限制)

• 將數組中的每一個數字和后面的所有數字進行比較，當發現相等時，即為結果。

int findRepeatNumber(int* nums, int numsSize){
    // 遍歷
    for (int i = 0; i < numsSize - 1; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] == nums[j]) {
                return nums[i];
            }
        }
    }
    return 0;
}

思路二：排序 + 遍歷(執行用時：92 ms 內存消耗：10.8 MB)

• 排序后能保證重復的數字連續分布，這樣遍歷時只需要比較當前數字和下一個數字是否相同即可。

int compareNums(const void *a, const void *b)
{
    int a1 = *(int*)a;
    int b1 = *(int*)b;
    return a1 - b1;
}

int findRepeatNumber(int* nums, int numsSize){
    // 排序
    qsort(nums, numsSize, sizeof(int), compareNums);
    // 遍歷
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] == nums[i + 1]) {
            return nums[i];
        }
    }
    return 0;
}

思路三：哈希查找(執行用時：40 ms 內存消耗：10.2 MB)

• 創建哈希數組（key:數字，value:出現次數），遍歷時先檢查當前索引對應的數字是否已經出現，出現則返回結果，否則更新該數字出現次數。

#define NUMS_SIZE 100000

int findRepeatNumber(int* nums, int numsSize){
    // 哈希
    int numsHash[NUMS_SIZE] = {0};
    for (int i = 0; i < numsSize; i++) {
        if (numsHash[nums[i]] > 0) {
            return nums[i];
        }
        numsHash[nums[i]]++;
    }
    return 0;
}

思路四：原地排序(執行用時：36 ms 內存消耗：10.4 MB)

• 借用輸入數組，將當前索引對應的數字，替換到對應的數字索引下，保證索引和數字相等。如果出現替換時，索引和數字已經相等時，說明該數字重復，返回結果。相比於思路三的優點是不需要申請額外的空間存放Hash表。執行過程如下圖。
  
  

int findRepeatNumber(int* nums, int numsSize){
    // 原地排序
    int cur = 0;
    int tmp = 0;
    while (cur < numsSize) {
        if (nums[nums[cur]] != nums[cur]) {
            tmp = nums[cur];
            nums[cur] = nums[tmp];
            nums[tmp] = tmp;
            continue;
        }
        if (cur == nums[cur]) {
            cur++;
            continue;
        }
        return nums[cur];
    }
    return 0;
}

思路五：二分法(解答錯誤)

• 根據題目發現答案在[0, n-1]中, left = 0, right = n - 1, mid = (left + right) / 2，先計算整個數組中[left, mid]范圍內的數的數量，如果大於(mid - left)，說明左側有重復數字，right = mid，否則，left = mid，繼續基於新的left, right二分。該種思路無法解決場景[0, 1, 2, 0, 4, 5, 6, 7, 8, 9]。

int Count(int* nums, int numsSize, int a, int b)
{
    int cnt = 0;
    int cur = 0;
    while (cur < numsSize) {
        if (nums[cur] >= a && nums[cur] <= b) {
            cnt++;
        }
        cur++;
    }
    return cnt;
}

int findRepeatNumber(int* nums, int numsSize){
    // 二分法 無法解決場景：[0, 1, 2, 0, 4, 5, 6, 7, 8, 9]
    int left = 0;
    int right = numsSize - 1;
    int mid, count;
    while (left < right - 1) {
        mid = (left + right) / 2;
        count = Count(nums, numsSize, left, mid);
        if (count > mid + 1 - left) {
            right = mid;
            continue;
        }
        left = mid;
    }
    if (Count(nums, numsSize, left, left) > 1) {
        return left;
    }
    return right;
}

【學習小結】

數組比Hash性能更好

相比於HashSet，使用數組絕對會有性能的提高，主要表現在如下的兩個方面：

哈希表 (HashSet) 底層是使用數組 + 鏈表或者紅黑樹組成的，而且它的數組也是用不滿的，有加載因子的。所以使用數組來代替哈希表，能節省空間

哈希表在判重的時候需要經過哈希計算，還可能存在哈希沖突的情況，而使用數組則可以直接計算得到 index 的內存位置，所以使用數組訪問性能更好。

鏈接：https://leetcode-cn.com/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof/solution/duo-chong-jie-fa-xun-xu-jian-jin-yi-zhi-dao-zui-yo/

調整執行順序，性能提升

判斷場景先執行nums[nums[cur]]，再執行nums[cur]，觸發預取，提高性能。

將滿足條件概率更大的條件放到前面，可以避免大量無效判斷，提高性能。