剑指offer：数组中只出现1次的数字

题目描述

一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。

 

解题思路：

本题考查位运算中异或的性质：两个相同数字异或结果为0，一个数和0异或结果还是它本身。
当只有一个数只出现一次时，我们把数组中所有的数，依次做异或运算，最后剩下的就是落单的数，因为成对的数在异或中都抵消了。
依照这个思路，我们来看两个数（假设是AB）出现一次的数组。首先对数组中的所有数先进行异或，剩下的数字肯定是AB异或的结果，这个 结果的二进制中的1，表现的是A和B的不同位，我们取第一个1所在的位数，假设是第3位，接着将原数组分为2组，分组标准是第3位是否为1.
 如此，相同的数肯定在同一组中，因为相同数字所有位都相同，而不同的数，肯定不在一组。然后将这两个组按照最开始的思路，依次异或， 剩下的两个结果就是两个只出现一次的数字。

 

方法一：异或，位运算

 1.除了有2个数字只出现了一次，其他数都出现了2次。而在异或运算中，任何数和自己本身异或都为0，和0异或结果都是它本身。
2.如果尝试将数组分为2个子数组，且刚好每个子数组中包含一个只出现一次的数，则在这个前提下，在每个子数组中，只有一个数字出现了 一次，其他数字都出现了2次。
3.针对每个子数组，从头到尾依次异或每个数字，最后的结果就是只出现了一次的数字，因为出现2次的数字在异或的过程中抵消了。
 4.如何实现子数组的划分？如果我们对原数组从头到尾进行异或，则最后得到的结果就是两个只出现1次的数字的异或结果，这个结果的二进制表示中，至少有一位为1，因为这两个数字不同。该位记为从最低位置开始计数的第n位。
 5.分组的标准定为从最低位开始计数的第n位是否为1。因为出现两次的同一个数字，各个位数上都是相同的，所以一定会分到同一个子数组中，且每个子数组中只包含一个只出现1次的数字。

 

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        int len=array.length;
        if(len==2){
            num1[0]=array[0];
            num2[0]=array[1];
            return;
        }
        int bitResult=0;
        //对原数组中的所有元素进行异或
        for(int i=0;i<len;i++){
            bitResult^=array[i];
        }
        //找到异或结果中位1所在的索引
        int index=findBit1(bitResult);
        //按照该索引对原数组进行分组
        for(int i=0;i<len;i++){
            if(isBit1(array[i],index)){
                num1[0]^=array[i];
            }else{
                num2[0]^=array[i];
            }
        }
    }
     
    private int findBit1(int bitResult){
        int index=0;
        while((bitResult&1)==0&&index<32){
            bitResult>>=1;
            index++;
        }
        return index;
    }
     
    private boolean isBit1(int target,int index){
        return ((target>>index)&1)==1;
    }
}

 

方法二：栈

将数组先排序，依次入栈，每一次入栈时，和当前栈的栈头进行比较，如果当前栈为空，则进行入栈，否则，将
该数和当前栈的栈头进行比较，如果相同，则出栈，否则压入栈中。当数组中所有元素都入栈完毕，则当前栈中剩余的2个元素就是两个只出现一次的元素

import java.util.Arrays;
import java.util.Stack;
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        //先对数组中的数字进行排序
        Arrays.sort(array);
        Stack<Integer> s=new Stack<>();
        for(int i=0;i<array.length;i++){
            if(s.isEmpty()){
                s.push(array[i]);
            }else{
                if(s.peek()==array[i]){
                    s.pop();
                }else{
                    s.push(array[i]);
                }
            }
        }
        //最后堆栈中剩下的两个元素就是只出现一次的元素
        num1[0]=s.pop();
        num2[0]=s.pop();     
    }
}

方法三：哈希表

import java.util.Queue;
import java.util.LinkedList;
import java.util.HashMap;
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        Queue<Integer> arr=new LinkedList<>();
        HashMap<Integer,Integer> map=new HashMap<>();
        //将数组中的元素存入hashMap中
        for(int i=0;i<array.length;i++){
            if(!map.containsKey(array[i])){
                map.put(array[i],1);
            }else{
                map.put(array[i],map.get(array[i])+1);
            }
        }
        //遍历数组，将出现次数为1的元素取出
        for(int i=0;i<array.length;i++){
            if(map.get(array[i])==1){
                arr.add(array[i]);
            }
        }
        num1[0]=arr.poll();
        num2[0]=arr.poll();
    }
}

 

本题还有很多解法，但是考察的是位运算，所以方法一是我们的首选方法。

 

参考博客：

https://blog.youkuaiyun.com/ouyangyanlan/article/details/72668012