题目：

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

示例：

image.png

思路：

二分查找
自己思路：总是查找子数组为奇数那一部分，直到找到中间mid值不等于mid+1和mid-1的值。
cyc大神思路：令 index 为 该单一元素 在数组中的位置。在 index 之后，数组中原来存在的成对状态被改变。如果 m 为偶数，并且 m + 1 < index，那么 nums[m] == nums[m + 1]；m + 1 >= index，那么 nums[m] != nums[m + 1]。

从上面的规律可以知道，如果 nums[m] == nums[m + 1]，那么 index 所在的数组位置为 [m + 2, h]，此时令 l = m + 2；如果 nums[m] != nums[m + 1]，那么 index 所在的数组位置为 [l, m]，此时令 h = m。

因为 h 的赋值表达式为 h = m，那么循环条件也就只能使用 l < h 这种形式。

代码：

//自己的思路实现
class Solution {
    public int singleNonDuplicate(int[] nums) {
        if (nums == null || nums.length < 2) return nums[0];
        int target = 0;
        int l = 0;
        int h = nums.length - 1;
        while (l <= h) {
            //计算中点位置
            int mid = l + ((h - l) >>> 1);
            //假如 l和mid和h都相等，则该位置的数就是要寻找的数
            //假如 中间mid的值不等于mid-1和mid+1的值，就是要寻找的数
            if ((mid == l && mid == h) || (nums[mid] != nums[mid + 1] && nums[mid] != nums[mid - 1])) {
                target = nums[mid];
                l ++;
            //否则，查找长度为奇数的子数组
            } else if (nums[mid] == nums[mid - 1]) {
                if ((mid - 2 - l + 1) % 2 == 0) {
                    l = mid + 1;
                } else {
                    h = mid - 2;
                }
            } else if (nums[mid] ==a nums[mid + 1]) {
                if ((h - mid + 2 + 1) % 2 == 0) {
                    h = mid - 1;
                } else {
                    l = mid + 2;
                }
            }
        }
        return target;
    }
}


//Cyc大佬实现
class Solution {
    public int singleNonDuplicate(int[] nums) {
        int l = 0;
        int h = nums.length - 1;
        while (l < h) {
            int mid = l + ((h - l) >>> 1);
            //例如输入: [3,3,7,7,10,11,11]
            if (mid % 2 == 1) {
                mid --; //保证要查找的区域大小一直都是奇数
            }
            //例如输入: [1,1,2,3,3,4,4,8,8]
            if (nums[mid] == nums[mid + 1]) {
                l = mid + 2;
            } else {
                h = mid;
            }
        }
        return nums[l];
    }
}

时间复杂度：O(logn)，空间复杂度：O(1)