Given an array of integers, every element appears twice except for one. Find that single one.
Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

這道題首先由于不開辟其他內存，所以想到了先排序再尋找，首先是冒泡排序：

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int min, max;
        //冒泡排序
        for(int i = 0; i< nums.size(); i++){
            for(int j = i; j<nums.size()-i; j++){
                if(nums[j] < nums[i]){
                    swap(nums[i], nums[j]);
                }else if(nums[j] > nums[nums.size()-i-1]){
                    swap(nums[j], nums[nums.size()-i-1]);
                }
            }
        }
        //在已經排好序的數組中進行尋找
        for(int i = 0; i < nums.size(); i+=2){
            if(i == 0&&nums[0]!=nums[1]){
                return nums[0];
                break;
            }else if(i == nums.size()-1&&nums[i]!= nums[i-1]){
                return nums[nums.size()-1];
                break;
            }
            else if(nums[i]!=nums[i+1]){
                return nums[i];
                break;
            }
        }
        return 0;
    }
    
};

但是提交上去之后，超時了

屏幕快照 2016-09-16 16.34.10.png

說明思路沒有錯誤，但是排序太慢了，嘗試掃描一半：
冒泡排序變成：

 for(int i = 0; i< (nums.size()-1)/2; i++){//這句話 變成了掃描一般
            for(int j = i; j<nums.size()-i; j++){
                if(nums[j] < nums[i]){
                    swap(nums[i], nums[j]);
                }else if(nums[j] > nums[nums.size()-i-1]){
                    swap(nums[j], nums[nums.size()-i-1]);
                }
            }
        }

提交，依舊會時間超限

上網查找排序時間，總結來說，一般快排最快，一提交，果然AC，所以代碼如下
<u>Runtime: 26 ms</u>

class Solution {
public:
    vector<int> num;
    
    void quick_sort(int left, int right)
    {
        if(left<right)
        {
            int i = left;
            int j = right;
            int x = num[i];
            
            while(i<j)
            {
                while(i<j&&num[j]>x)
                    j--;
                if(i<j){
                    num[i] = num[j];
                    i++;
                }
                while(i<j&&num[i]<x)
                    i++;
                if(i<j){
                    num[j] = num[i];
                    j--;
                }
            }
            num[i] = x;
            quick_sort(left, i-1);
            quick_sort(i+1, right);
            }  
    }

    int singleNumber(vector<int>& nums) {
        num.clear();
        num = nums;
        quick_sort(0, nums.size()-1);
        for(int i = 0; i < num.size(); i+=2){
            if(i == 0&&num[0]!=num[1]){
                return num[0];
                break;
            }else if(i == num.size()-1&&num[i]!= num[i-1]){
                return num[num.size()-1];
                break;
            }
            else if(num[i]!=num[i+1]){
                return num[i];
                break;
            }
        }
        return 0;
    }
    
};

根據網友啟發，發現了一種更簡單的方法。
由于n^n=0, 而0^n = n, 所以給定一組數組
可以將所有數進行一起異或，最后剩下的那個數就是single num，時間復雜度為O(N)，代碼如下
時間為<u>19ms</u>

class Solution {
public:
    
    int singleNumber(vector<int>& nums) {
        int res = 0;
        for(int i = 0; i<nums.size(); i++){
            res = res ^ nums[i];
        }
        return res;
    }
    
};