剑指 Offer . 排序数组中只出现一次的数字(中等)

原题在这里->排序数组中只出现一次的数字

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

示例 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 <= 105
0 <= nums[i] <= 105

进阶: 采用的方案可以在 O(log n) 时间复杂度和 O(1) 空间复杂度中运行吗？

来源：力扣（LeetCode）

方法一：异或

时间复杂度O(N)

int singleNonDuplicate(int* nums, int numsSize){
    int ret = 0;
    for(int i = 0;i<numsSize;i++)
    {
        ret^=nums[i];
    }
    return ret;
}

 方法二：(1).二分查找(有序)(暴力版)(可忽略)

自己刚开始做的，将每种情况都列出来了，没有任何优化(笑哭)。

int singleNonDuplicate(int* nums, int numsSize) {
    if (numsSize == 1)
    {
        return nums[0];
    }
    int left = 0;
    int right = numsSize - 1;
    int mid = (left + right) / 2;
    while (left <= right)
    {
        //情况1：mid为0，且nums[mid]不等于nums[mid+1]
        //例如：[1 2 2 3 3 4 4]
        if (mid == 0 && nums[mid] != nums[mid + 1])
        {
            return nums[mid];
        }

        //情况2：mid为数组最后一个位置，且nums[mid]不等于nums[mid-1]
        //例如：[0 0 1 1 2 2 3]
        else if (mid == numsSize - 1 && nums[mid] != nums[mid - 1])
        {
            return nums[mid];
        }

        //情况3：mid为数组中间某位置，且于前后位置的值都不相等
        //例如：[0 0 1 1 2 3 3 4 4]
        else if (nums[mid] != nums[mid + 1] && nums[mid] != nums[mid - 1])
        {
            return nums[mid];
        }

        //情况4：数组中只剩下3个(开始的三个或者末尾的三个)未查找的数,且mid位于中间
        //例如：[1 2 2 3 3 4 4](mid在第一个2的位置)
        //      [1 1 2 2 3 4 4](mid在第一个4的位置)        
        if (mid + 2 == numsSize)
        {
            break;
        }

        //mid为奇数(奇数个，mid，奇数个)，nums[mid]=nus[mid-1],答案肯定存在于右区间
        if (mid % 2 != 0 && nums[mid] == nums[mid - 1])
        {
            left = mid + 1;
        }
        //mid为奇数(奇数个，mid，奇数个)，nums[mid]=nus[mid+1],答案肯定存在于左区间
        else if (mid % 2 != 0 && nums[mid] == nums[mid + 1])
        {
            right = mid - 1;
        }
        //mid为偶数(偶数个，mid，偶数个)，nums[mid]=nus[mid+1],答案肯定存在于右区间
        else if (mid % 2 == 0 && nums[mid] == nums[mid + 1])
        {
            left = mid + 1;
        }
        //mid为偶数(偶数个，mid，偶数个)，nums[mid]=nus[mid-1],答案肯定存在于左区间
        else
        {
            right = mid - 1;
        }
        mid = (left + right) / 2;
    }
    
    //数组中只剩下3个数，nums[mid]和其中一个比较即可得出答案
    return nums[mid] == nums[mid + 1] ? nums[mid - 1] : nums[mid + 1];
}

  (2).二分查找(优化版)

int singleNonDuplicate(int* nums, int numsSize) {

    int left = 0, right = numsSize - 1;
    while (left < right) 
    {
        int mid = (left + right) / 2;

        //情况1：mid为奇数(奇数个，mid，奇数个)，如果nums[mid] = nums[mid-1]，则左区间剩余偶数个元素，则目标元素一定在右区间
        //例如：[1 1 2 2 3 3 4] (mid位于第二个2的位置，即下标为3)
        if (mid % 2 == 1 && nums[mid] == nums[mid - 1]) 
        {
            left = middle + 1;
        }

        //情况2：mid为奇数(奇数个，mid，奇数个)，如果nums[mid] != nums[mid-1]，则nums[mid]=nums[mid+1],则左区间剩余奇数个元素，则目标元素一定在左区间
        //注：此种情况下mid位置处必不可能是目标值，因为左右区间均为奇数个元素，若mid为目标值，左右区间中会不匹配
        //例如：[1 1 2 3 3 4 4] (mid位于3的位置，即下标为3)
        else if (mid % 2 == 1 && nums[mid] != nums[mid - 1]) 
        {
            right = mid-1;
        }

        //情况3：mid为偶数(偶数个，mid，偶数个)，如果nums[mid] = nums[mid-1]，则左区间剩余奇数个元素，则目标元素一定在左区间
        //例如：[1 2 2 3 3 4 4 5 5] (mid位于第二个3的位置，即下标为3)
        else if (mid % 2 == 0 && nums[mid] == nums[mid - 1]) 
        {
            right = mid - 2;//nums[mid-1]因为已经和nums[mid]相等，所以必不可能是目标值
        }

        //情况4：mid为偶数(偶数个，mid，偶数个)，如果nums[mid] != nums[mid+1]，则mid+右区间剩余奇数个元素，则目标元素一定在右区间或mid位置
        //注：此种情况mid位置处可能为目标值，所以left应调整为mid
        //例如：[1 1 2 2 3 3 4 5 5] (mid位于第一个3的位置，即下标为3)
        //      [1 1 2 2 3 4 4 5 5] (mid位于3的位置，即下标为3)
        else 
        {
            left = mid;
        }
    }

    return nums[left];//只剩最后一个元素时必定是目标值，返回left/right均可
}

如有一些好的解题方法，望不吝赐教~