leetcode:single-number,single-number ii

一. 题目描述

single-number：

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?

single-number ii:

Given an array of integers, every element appears three times except for one. Find that single one.

Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

二. 分析

(1).single-number

1. 0 ^ 1 = 1, 1 ^ 0 = 1, 0 ^ 0 = 0, 1 ^ 1 = 0

2. 对于任意整数n，n ^ 0 = n, n ^ n = 0 
   （1）当n与0异或时，由于0的所有二进制位均为0，因此，n的二进制位中为1的与0相应位的二进制位0异或结果为1，n的二进制位中为0的与0相应位的二进制位0异或结果为0，因此异或后的结果与n本身完全相同；（2）当n与n异或时，由于其二进制位完全相同，而根据1中0 ^ 0 = 0, 1 ^ 1 = 0，n ^ n结果的所有位均为0，所以结果为0。

3. 异或运算满足交换结合律 a ^ b ^ c = a ^ c ^ b. 
   其实我们可以将所有的abc均看做二进制形式，其结果可以看做是如下运算： 
   00000000 00000000 00000000 00000010 a = 2 
   ^ 
   00000000 00000000 00000000 00000001 b = 1 
   ^ 
   00000000 00000000 00000000 00000100 c = 4

   ---

   00000000 00000000 00000000 00000111 result = 7 
   即所有运算数的每一位分别异或，因此不论运算顺序如何，结果都相同。

结论 
综合1、2、3，然后再根据我们的数据的特点，有2n-1个数，其中有n-1个数出现了两次，只有一个数出现了1次，那么我们将所有的2n-1个数进行异或时，可以看成如下过程，对于出现了两次的元素，x ^ x = 0，然后是n-1个0和剩余的那个只出现了一次的y进行异或，n-1个0异或的结果还是0，最后再与y异或结果是y，y就是我们要找的缺失的元素，因此上述算法是正确的。

class Solution {public:    int singleNumber(int A[], int n) {    int result=0;        for(int i=0;i<n;i++)            {            result ^= A[i];        }        return result;    }};

最开始我的思路：用到了排序算法sort，先进行排序再前后两个进行比较

bool compare(int x,int y) {     return x<y?true:false; } class Solution {public:    int singleNumber(int A[], int n) {        sort(A,A+n,compare);        int i=0;        for(i=0;i<n-1;i++)            {                         if(A[i]==A[i+1])                i=i+1;            else                break;        }        return A[i];    }};

（2）single-number ii
我的思路：用map实现的，有键值和实值

class Solution {public:    int singleNumber(int A[], int n) {        map<int,int> my_map;        map<int,int>::iterator my_iter;        for(int i=0;i<n;i++)            {            my_iter=my_map.find(A[i]);                         if(my_iter==my_map.end() )            {                pair<int,int> value(A[i],1);                my_map.insert(value);            }            else                my_iter->second++;        }        for(my_iter=my_map.begin();my_iter!=my_map.end();++my_iter)            {            if(my_iter->second==3)                continue;            else                break;        }        return my_iter->first;                 }};

用先排序再比较的方法：

class Solution {public:    int singleNumber(int A[], int n) {    sort(A,A+n);int i;for(i=0;i<n-2;i=i+3)if(A[i]!=A[i+2])return A[i];return A[n-1];       }};

还有一种比较高级的算法：（不太懂啊）

Single Number的本质，就是用一个数记录每个bit出现的次数，如果一个bit出现两次就归0，这种运算采用二进制底下的位操作^是很自然的。Single Number II中，如果能定义三进制底下的某种位操作，也可以达到相同的效果，Single Number II中想要记录每个bit出现的次数，一个数搞不定就加两个数，用ones来记录只出现过一次的bits，用twos来记录只出现过两次的bits，ones&twos实际上就记录了出现过三次的bits，这时候我们来模拟进行出现3次就抵消为0的操作，抹去ones和twos中都为1的bits。

class Solution {public:    int singleNumber(int A[], int n) {    int ones = 0;//记录只出现过1次的bits        int twos = 0;//记录只出现过2次的bits        int threes;        for(int i = 0; i < n; i++){            int t = A[i];            twos |= ones&t;//要在更新ones前面更新twos            ones ^= t;            threes = ones&twos;//ones和twos中都为1即出现了3次            ones &= ~threes;//抹去出现了3次的bits            twos &= ~threes;        }        return ones;       }};