【leetcode】排序数组中只出现一次的数字

一、 题目描述

给定一个只包含整数的有序数组 nums ，每个元素都会出现两次，唯有一个数只会出现一次，请找出这个唯一的数字。

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

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

二、 代码思路

注意几个关键词： 有序数组 、 相同元素会出现两次。

2.1 使用异或操作的暴力解法

异或操作：不同为1 相同为0，所以0与任何数异或都是其本身，相同的数异或一定是0；

因此，我们只要用0依次异或数组的每个元素，最后剩下的元素一定是那个唯一的元素。可以实操一下
[1，1，2，3，3] ： 0 ^ 1 ^ 1 ^ 2 ^ 3 ^ 3 = 2
0 ^ 1 ^ 1 ^ 2 = 2
2 ^ 3 = 1 0 ^ 1 1 = 0 1
0 1 ^ 3 = 0 1 ^ 1 1 = 1 0 = 2 还是2 本身

2.2 使用根据题目的特点使用二分查找的手段

由于重复元素都是两两出现的，所以整个数组个数一定是奇数的。

那么，我们不妨设想一个数组，索引是 1 - index，1 - index 中有一个元素是x，即： [1,1,2,2,x,4,4,5,5] 。

• 如果 x 的索引是偶数，那么证明 1 - x 数组中有偶数个数，那么如果有array[x] = array[x - 1] , 证明 1 - x中不会出现单个数字，因为剩下的是偶数。

• 如果 x 的索引是奇数，那么证明 1 - x 数组有奇数个数，x - index 数组有偶数个个数，那么如果有array[x] = array[x + 1] , 证明 x - index 偶数个数组中不会出现单个数字，因为x - index 是偶数个数子，前两个已经相同了，后面偶数个数一定相同。

更加详细的解释

三、 代码题解

暴力异或求解：

 //0 与 任何数异或为其本身，相同数异或为 0;
    public int singleNonDuplicate1(int[] nums) {
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
            res ^= nums[i];
        }
        return res;
    }

结合题目信息进行二分查找：

public int singleNonDuplicate(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while (left < right) {
            int mid = (right - left) / 2 + left;
            //索引下标为偶数,证明 left - mid 位置的个数为奇数
            // 此时[left, mid + 1]区间元素个数为偶数
            // 区间后两个元素值是nums[mid] 和 nums[mid + 1]
            if (mid % 2 == 0) {
                if (nums[mid] == nums[mid + 1]) {
                     // 元素个数为偶数的区间[left, mid + 1]一定不会有目标值
                    left = mid + 2;
                } else {
                    //这种情况表明nums[mid] ！= nums[mid + 1]
                    //那么这两个元素都有可能是单个数字
                    //但是我们不要忘记，单个数组的索引只可能是偶数（由于index 从0 开始的，所以单个数字应该是第奇数个，索引是第偶数个）
                    //所以mid + 1 必定不是单个数字，所以right就默认赋值了mid。
                    right = mid;
                }
            } else {
                // 此时[left, mid]区间元素个数为偶数
                // 区间后两个元素值是nums[mid - 1] 和 nums[mid]
                if (nums[mid] == nums[mid - 1]) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
        }
        return nums[right]; 
    }

完整版代码如下：

class Solution {
    public int midFind(int[] arr, int key, int low, int high) {
        if (key < arr[low] || key > arr[high] || low > high) {
            return -1;
        }
        int mid = (low + high) / 2;
        if (arr[mid] > key) {
            return midFind(arr, key, low, mid - 1);
        } else if (arr[mid] < key) {
            return midFind(arr, key, mid, high);
        } else {
            return mid;
        }   
    }
    //0 与 任何数异或为其本身，相同数异或为 0;
    public int singleNonDuplicate1(int[] nums) {
        int res = 0;
        for (int i = 0; i < nums.length; i++) {
            res ^= nums[i];
        }
        return res;
    }
    //二分 + 异或
    public int singleNonDuplicate2(int[] nums) {
        int low = 0;
        int high = nums.length - 1;
        while (low < high) {
            int mid = (high - low) / 2 + low;
            //low - mid 区间个数为奇数
            //mid + 1 - height 区间个数为偶数
            if (mid % 2 == 0) {
                if (nums[mid] == nums[mid + 1]) {
                    low = mid + 2;
                } else {
                    high = mid;
                }
            } else {
                //low - mid 区间数字个数为偶数
                if (nums[mid] == nums[mid - 1]) {
                    low = mid + 1;
                } else {
                    high = mid;
                }
            }
        }
        return nums[low];
    }
    public int singleNonDuplicate(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while (left < right) {
            int mid = (right - left) / 2 + left;
            //索引下标为偶数,证明 left - mid 位置的个数为奇数
            // 此时[left, mid + 1]区间元素个数为偶数
            // 区间后两个元素值是nums[mid] 和 nums[mid + 1]
            if (mid % 2 == 0) {
                if (nums[mid] == nums[mid + 1]) {
                     // 元素个数为偶数的区间[left, mid + 1]一定不会有目标值
                    left = mid + 2;
                } else {
                    //这种情况表明nums[mid] ！= nums[mid + 1]
                    //那么这两个元素都有可能是单个数字
                    //但是我们不要忘记，单个数组的索引只可能是偶数（由于index 从0 开始的，所以单个数字应该是第奇数个，索引是第偶数个）
                    //所以mid + 1 必定不是单个数字，所以right就默认赋值了mid。
                    right = mid;
                }
            } else {
                // 此时[left, mid]区间元素个数为偶数
                // 区间后两个元素值是nums[mid - 1] 和 nums[mid]
                if (nums[mid] == nums[mid - 1]) {
                    left = mid + 1;
                } else {
                    right = mid;
                }
            }
        }
        return nums[left]; 
    }
}