【二分查找】leetcode 540. 有序数组中的单一元素

540. 有序数组中的单一元素

题目描述

给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。

请你找出并返回只出现一次的那个数。

你设计的解决方案必须满足 $O(logn)$ 时间复杂度和 $O(1)$ 空间复杂度。

示例1：

输入： nums = [1,1,2,3,3,4,4,8,8]
输出： 2

示例2：

输入： nums = [3,3,7,7,10,11,11]
输出： 10

提示

• $1<=nums.length<=10^5$
• $0<=nums[i]<=10^5$

方法一：哈希表

解题思路

创建哈希表，用 $nums[i]$ 作为 $key$，用 $nums[i]$ 在数组中出现的次数作为 $value$。
最后再遍历创建出来的哈希表，如果查找到 $value=1$ 的键值对，则返回对应的 $key$。

代码

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        unordered_map<int, int> hash;
        for(int i = 0; i < nums.size(); i++)
            hash[nums[i]]++;
        int ans;
        for(auto x: hash)
            if(x.second == 1)
            {
                ans = x.first;
                break;
            }
        return ans;
    }
};

复杂度分析

• 时间复杂度：$O(n)$。$n$ 为 $nums$ 数组的长度。
• 空间复杂度：$O(n)$。

方法二：快慢指针

解题思路

定义两个指针 $slow$ 和 $fast$，因为数组中除了有一个元素是单个出现之外，其他全是成双出现，则 $slow$ 定位前一个元素，$fast$ 定位后一个元素，每一次都走两步，直到 $nums[slow]!=nums[fast]$ 跳出循环。

此时 $nums[slow]$ 便是我们要找的单一元素。

如果数组中只有一个元素，那这一个元素就是单一元素。

代码

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        if(nums.size() == 1)
            return nums[0];
        int slow = 0, fast = 1;
        while(nums[slow] == nums[fast])
        {
            slow += 2;
            fast += 2;
        }
        return nums[slow];
    }
};

复杂度分析

• 时间复杂度：$O(\frac{n}{2})$。
• 空间复杂度：$O(1)$。

方法三：二分查找

解题思路

因为 $nums$ 中除了单个元素之外，其他元素都是成对出现。

假设单个元素的下标为 $x$，则 $x$ 左边的元素满足 $nums[y]=nums[y+1](0\le y<x)$，只是此时的下标 $y$ 为偶数； $x$ 右边的元素满足 $nums[z]=nums[z+1](x<z<n)$，只是此时的下标 $z$ 为奇数。由于下标 $x$ 是相同元素的开始下标的奇偶性的分界，因此可以使用二分查找的方法寻找下标 $x$。

二分查找的左边界为 $0$，右边界为 $n-1$，每次取左右边界的平均值为 $mid$ ，根据 $mid$ 的奇偶性来决定是和 $mid$ 左边的元素还是右边的元素相比较：

• 若 $mid$ 为偶数，则此时 $nums[mid]=nums[mid+1]$；
• 若 $mid$ 为奇数，则此时 $nums[mid-1]=nums[mid]$；

如果上述比较相邻元素的结果是相等，则 $\text{mid}<x$，调整左边界，即 $l=mid+1$；否则 $\text{mid}\ge x$，调整右边界，即 $r=mid$。调整边界之后继续二分查找，直到确定下标 $x$ 的值。

得到下标 $x$ 的值之后，$\text{nums}[x]$ 即为只出现一次的元素。

代码

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int n = nums.size();
        int l = 0, r = n - 1, mid;
        while(l < r) {
            mid = (l + r) >> 1;
            if(mid % 2 != 0) {
                if(nums[mid] == nums[mid - 1])
                    l = mid + 1;
                else
                    r = mid;
            } else {
                if(nums[mid] == nums[mid + 1])
                    l = mid + 1;
                else
                    r = mid;
            }
        }
        return nums[r];
    }
};

复杂度分析

• 时间复杂度：$O(logn)$。二分查找的时间复杂度为 $O(logn)$。
• 空间复杂度：$O(1)$。

方法四：二分查找 + 异或

解题思路

利用按位异或的性质，可以得到 $\text{mid}$ 和相邻的数之间的如下关系，其中 $\oplus$ 是按位异或运算符：

• 当 $\text{mid}$ 是偶数时，$\text{mid}+1=\text{mid}\oplus 1$；

• 当 $\text{mid}$ 是奇数时，$\text{mid}-1=\text{mid}\oplus 1$。

因此在二分查找的过程中，不需要判断 $\text{mid}$ 的奇偶性，$\text{mid}$ 和 $\text{mid}\oplus 1$ 即为每次需要比较元素的两个下标。

代码

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
        int l = 0, r = nums.size() - 1, mid;
        while(l < r)
        {
            mid = (l + r) >> 1;
            if(nums[mid] == nums[mid ^ 1])
                l = mid + 1;
            else
                r = mid;
        }
        return nums[l];
    }
};

复杂度分析

• 时间复杂度：$O(logn)$。二分查找的时间复杂度为 $O(logn)$。
• 空间复杂度：$O(1)$。