leetcode:single-number,single-number ii

最新推荐文章于 2020-05-02 17:02:13 发布

原创最新推荐文章于 2020-05-02 17:02:13 发布 · 305 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

算法专栏收录该内容

19 篇文章

订阅专栏

本文介绍两种算法，用于从数组中找出仅出现一次的元素。第一种适用于元素出现两次的情况，利用异或运算解决；第二种针对元素出现三次的问题，通过记录出现一次和两次的位状态来确定目标元素。

一. 题目描述

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

0 ^ 1 = 1, 1 ^ 0 = 1, 0 ^ 0 = 0, 1 ^ 1 = 0
对于任意整数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。
异或运算满足交换结合律 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;   
    }
};