了解面试算法之 - 栈&队列&位运算

算法，一门既不容易入门，也不容易精通的学问。

对于笔者来讲算法算是我程序员生涯很不擅长的技能之一了，自从互联网界招人进入平静期后，愈来愈多的大厂在社招的时候不但会考验面试者的工做所用到的技能，并且会用算法题来考验面试者的逻辑思惟能力和基本数据结构的掌握能力。这也就让想要社招进入大厂的部分同窗有了一些望而却步的心理，毕竟工做中大部分时间在与UI层面的逻辑打交道，数据处理方面即便以前在学校中掌握的还还不错，几年的 CV 生活，估计也忘的差很少了。

可是做为一条有梦想的咸鱼，咱们仍是要重拾这些知识的。以前写过一篇 搞懂单链表常见面试题，有兴趣的同窗能够跳转浏览。今天笔者将会挑选几道栈与队列和位运算的相关题目来回顾下相关算法的基本知识。

栈与队列

栈与队列分别是两种数据结构，不一样语言对于栈和队列有着不一样的声明，在 java 中 Stack 类是继承自 Vector 集合的子类，Queue 则是以接口形式存在，经常使用的其实现类是 LinkedList 这个双向队列。在C++的标准模版库也是有这两个数据结构定义的具体类的。

栈数据结构的特色是 FILO（first in last out） 即先进后出，队列则是 FIFO（first in first out）即先进先出。相信栈与队列的数据结构的基本特色你们也是熟记于胸了。下面就带你们看一道面试题来带你们看下这二者在面试题中的形式。

由两个栈实现一个队列 （✭✭✩✩✩）

题目难度两颗星，主要考察了对于栈和队列的数据结构特色。

前文介绍了，对于一个栈来讲遵循 pop 操做时从栈的顶部取一个元素，对于队列来讲 poll 操做时从队列队首取一个元素。因此该题翻译过来就是使用两个栈定义一种先放入的元素，最早被取出的数据结构。

此题应考虑到两种状况，首先最简单的一种状况，假设有 1，2，3，4，5 个元素依次进入自定义的队列，再依次取出。因为是进栈操做都进行完了才进行出栈操做，因此咱们只需在元素出队时，将进栈元素倒入另外一个空栈中便可。示意图以下：

 

 

再一种状况是，若是 add poll 操做是交替进行的，那么如何保证数据结构先进先出的定义呢？好比先放入 1，2，3而后要进行一次取出操做取出 1，随后在进行 add 操做放入4，5，这种状况下如何操做两个栈，才能保证以后再取出的时候元素为 2，3，4，5 顺序？实际上咱们只须要保证一下两点就能够：

1. 不管若是 StackA（最开始add元素的那个栈） 要往 StackB 中压入元素，那么必须选择一次性所有压入。
2. 不管何时从队列中取元素，必须保证元素是从 StackB 中 pop 出的，也就是说，当 StackB 不为空的时候毫不能再次向 StackB 中压入元素。

为了方便理解能够看下边这幅图：

 

 

明白了须要注意的点后就是该写代码的时候了，须要注意的点在图中已经用红色字体标出了，也就是在存入元素一直往 StackA 中存，取元素是从 StackB 中取，但要要注意的是取的时候须要保证 StackB 为空的时候要先将 StackA 中元素一次性压如 StackB 中，在进行从 StackB 中取的操做。

public static class  TwoStackQueue<E>{
        private Stack<E> stackA;
        private Stack<E> stackB;

        public TwoStackQueue() {
            stackA = new Stack<>();
            stackB = new Stack<>();
        }

        /**
         * 添加元素逻辑
         * @param e 要添加的元素
         * @return 这里只是遵循 Queue 的习惯，这里简单处理返回 true 便可
         */
        public boolean add(E e){
            stackA.push(e);
            return true;
        }

        /**
         * 去除元素的时候须要判断两个地方，StackA & StackB 是否都为空
         * StackB 为空的时候讲StackA中的元素所有依次压入 StackB
         * @return 返回队列中的元素 若是队列为空返回 null
         */
        public E poll(){
            //若是队列中没有元素则直接返回空，也能够选择抛出异常
            if (stackB.isEmpty() && stackA.isEmpty()){
                return null;
            }
            
            if (stackB.isEmpty()){
                while (!stackA.isEmpty()){
                    stackB.add(stackA.pop());
                }
            }
            
            return stackB.pop();
        }

        /**
         * peek 操做不取出元素，只返回队列头部的元素值 
         * @return 队列头部的元素值
         */
        public E peek(){
            //若是队列中没有元素则直接返回空，也能够选择抛出异常
            if (stackB.isEmpty() && stackA.isEmpty()){
                return null;
            }

            if (stackB.isEmpty()){
                while (!stackA.isEmpty()){
                    stackB.add(stackA.pop());
                }
            }

            return stackB.peek();
        }
    }
复制代码

对应的 C++ 解法：

#include <stdio.h>
#include <stack>
using namespace std;

template <typename T> class TStackQueue
{
public:
    void add(T t);
    T poll();
    
private:
    stack<T> stackA;
    stack<T> stackB;
};

template <typename T> void TStackQueue<T>::add(T node) {
    stackA.push(node);
}
template<typename T> T TStackQueue<T>::poll(){
    if (stackB.empty() && stackA.empty()) {
        return NULL;
    }
    
    if (stackB.empty()) {
        while (!stackA.empty()) {
            stackB.push(stackA.top());
            stackA.pop();
        }
    }
    T node = stackB.top();
    stackB.pop();
    return node;
}
复制代码

两个队列实现一个栈 （✭✭✩✩✩）

上道题咱们完成了两个栈实现一个队列的题目，那么两个队列实现一个栈又该注意哪些呢？

首先队列是先进先出，咱们能够发现队列不管怎么倒，咱们不能逆序一个队列。既然不能套用上题的解法，那么就得另谋出路，可是能够预知无非就是两个队列进行交替的入队出队操做，那么惟一要作的就是判断目前出队的值是不是按照放入元素顺序中最后放入的元素。 依旧画图举例

 

 

这里咱们只看首次取出操做，那么须要注意一点， 如何判断哪一次取出操做后 QueueA 为空？

事实上做为 Queue 做为容器，咱们能够经过事先定义好的方法 queue.size() 去判断一个队列中元素的个数，有人可能说这是犯规，其实不是的。题目中给出是让你用队列去实现，那么队列中公共 API 都是你能够用的。因此能够想象出下面的伪代码：

 

//若是 queueA 的大小不为 0 则循环取出元素
while(queueA.size() > 0){
    //被取出的元素
    int result = queueA.poll();
    // 这里注意咱们取出元素后再去判断一次，队列是否为空，若是为空表明是最后一个元素
    if(queueA.size() != 0){
        queueB.add(result)
    }else{
        return result;
    }
}
复制代码

上文咱们只是说了一次取出操做，那么一次取出操做后，再次放入元素应该怎么放，咱们彷佛又遇到了困难。

与上题不一样的是，咱们应该先思考若是连续两次取出应该怎么操做，上面一次取出后 QueueA 空了，因此咱们若是按照相同的思路将 B 中的元素倒入 A 中，那么将会获得 3 ，这看起来没什么问题。那么若是下一步进行的 push 操做，那么应该放入 QueueA 仍是 QueueB 中才能保证元素先进后出的规则呢，很容易想到是放入 B 中。 那么总结一下操做要点：

1. 任什么时候候两个队列总有一个是空的。
2. 添加元素老是向非空队列中 add 元素。
3. 取出元素的时候老是将元素除队尾最后一个元素外，导入另外一空队列中，最后一个元素出队。

接上图咱们开看第一次取出操做后可能的两种操做状况：

 

 

思路屡清楚了，那么时候写代码了：

public static class TwoQueueStack<E> {
   private Queue<E> queueA;
   private Queue<E> queueB;

   public TwoQueueStack() {
       queueA = new LinkedList<>();
       queueB = new LinkedList<>();
   }

   /**
    * 选一个非空的队列入队
    *
    * @param e
    * @return
    */
   public E push(E e) {
       if (queueA.size() != 0) {
           System.out.println("从 queueA 入队 " + e);
           queueA.add(e);
       } else if (queueB.size() != 0) {
           System.out.println("从 queueB 入队 " + e);
           queueB.add(e);
       } else {
           System.out.println("从 queueA 入队 " + e);
           queueA.add(e);
       }
       return e;
   }

   public E pop() {
       if (queueA.size() == 0 && queueB.size() == 0) {
           return null;
       }

       E result = null;
       if (queueA.size() != 0) {
           while (queueA.size() > 0) {
               result = queueA.poll();
               if (queueA.size() != 0) {
                   System.out.println("从 queueA 出队 并 queueB 入队 " + result);
                   queueB.add(result);
               }
           }
           System.out.println("从 queueA 出队 " + result);

       } else {
           while (queueB.size() > 0) {
               result = queueB.poll();
               if (queueB.size() != 0) {
                   System.out.println("从 queueB 出队 并 queueA 入队 " + result);
                   queueA.add(result);
               }
           }
           System.out.println("从 queueB 出队" + result);
       }
       return result;
   }
}
复制代码

为了方便你们理解我将文章进行下测试：

public static void main(String[] args) {
        TwoQueueStack<Integer> queueStack = new TwoQueueStack<>();
        queueStack.push(1);
        queueStack.push(2);
        queueStack.push(3);
        queueStack.push(4);
        queueStack.pop();
        queueStack.pop();
        queueStack.push(5);
        queueStack.pop();
    }
复制代码

结果为下面所示,看上去咱们的代码是对的

从 queueA 入队 1
从 queueA 入队 2
从 queueA 入队 3
从 queueA 入队 4
从 queueA 出队 并 queueB 入队 1
从 queueA 出队 并 queueB 入队 2
从 queueA 出队 并 queueB 入队 3
从 queueA 出队 4
从 queueB 出队 并 queueA 入队 1
从 queueB 出队 并 queueA 入队 2
从 queueB 出队3
从 queueA 入队 5
从 queueA 出队 并 queueB 入队 1
从 queueA 出队 并 queueB 入队 2
从 queueA 出队 5
复制代码

付C++ 代码实现：

 

#include <stdio.h>
#include<queue>
#include<exception>

using namespace std;

template <typename T> class TQueueStack
{
public:
    void push(const T& node);
    T pop();
    
private:
    queue<T> queueA;
    queue<T> queueB;
};

// 插入元素
template<typename T> void TQueueStack<T>::push(const T& node)
{
    
    //插入到非空队列，若是均为空则插入到queueB中
    if (queueA.size() == 0)
    {
        queueB.push(node);
    }
    else
    {
        queueA.push(node);
    }
}

template<typename T> T TQueueStack<T>::pop()
{
    if (queueA.size() == 0 && queueB.size() == 0)
    {
        return NULL;
    }
    T head;
    if (queueA.size() > 0)
    {
        while (queueA.size()>1)
        {
            //queueA中的元素依次删除，并插入到queueB中，其中queueA删除最后一个元素
            //至关于从栈中弹出队尾元素
            T& data = queueA.front();
            queueA.pop();
            queueB.push(data);
        }
        head = queueA.front();
        queueA.pop();
    }
    else
    {
        while (queueB.size()>1)
        {
            //queueB 中的元素依次删除，并插入到 queueA 中，其中 queueB 删除最后一个元素
            //至关于从栈中弹出队尾元素
            
            T& data = queueB.front();
            queueB.pop();
            queueA.push(data);
        }
        head = queueB.front();
        queueB.pop();
    }
    return head;
}
复制代码

判断出栈顺序是否符合要求（✭✭✭✩✩）

经历了上两道题，你们是否是感受对栈和队列更反感，哦不对是更了解了呢。（额~ 一不当心把实话说出来了）。下面咱们来看第二道题这是一个有关于出栈顺序的判断的题目:

题目: 输入两个整数数组，第一个表示一个栈的压入序列，请写一个函数，判断第二个数组是否为该栈的出栈序列，假设数组中的全部数字均不相等。例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不多是该压栈序列的弹出序列。

看到这道题咱们首先应该去理解题目中的怎么去判断是否符合出栈顺序，其实题目想要表达的意思是若是以数组 A 的方式进栈但并非一次所有进栈，好比咱们先进栈1，2，3，4 而后出栈 4，而后进栈 5，而后在出栈 5，3，2，1。 那么什么状况下是不可能知足的出栈顺序呢？好比 1，确定是比 2 先进栈的，因此 2确定比 1先出栈。因此解题的关键就在于，如何判断数组2 中的元素，是按数组1 中某种进栈顺序操做的出栈序列。

思路是若是咱们在进栈的同时维护一个出栈角标，若是栈顶元素等于 popA[popIndex] 的时候，将角标加一，并出栈该元素，并继续判断下一个栈顶元素，若是栈顶元素不等于 popA[popIndex] 的时候继续入栈元素，直到全部元素入栈完毕若是，栈不为空则表示 popA 不是一个出栈序列。经过下图能够更好的理解题目要考察的内容：

 

 

因此在编程的只须要注意一下三点：

1. 执行放入操做后，若是栈顶的元素等于对应角标在 popA 数组中的元素值，那么就须要出栈该元素，同事角标加1
2. 若是栈顶的元素不等于对应角标在 popA 数组中的元素值，那么就执行放入操做。
3. 待全部的元素都被放入栈中，此时若是栈为空，那么 popA 就是一个出栈序列，反之则不是。

下面看代码实现：

public static class Solution {

   public boolean IsPopOrder(int[] pushA, int[] popA) {
       int len = pushA.length;

       Stack<Integer> stack = new Stack<>();
       for (int pushIndex = 0, popIndex = 0; pushIndex < len; pushIndex++) {
           stack.push(pushA[pushIndex]);
           //若是栈顶元素等于 popA[popIndex] 则一直出栈且 popIndex++
           while (popIndex < popA.length && popA[popIndex] == stack.peek()) {
               stack.pop();
               popIndex++;
           }
       }
       return stack.isEmpty();
   }
}
复制代码

C++实现以下

 

class Solution {
public:
    bool IsPopOrder(vector<int> pushA, vector<int> popA) {
        if(pushA() == 0) return false;
        vector<int> stack;
        for(int i = 0,j = 0 ;i < pushA.size();){
            stack.push_back(pushA[i++]);
            while(j < popA.size() && stack.back() == popA[j]){
                stack.pop_back();
                j++;
            }       
        }
        return stack.empty();
    }
};
复制代码

测试结果以下：

public static void main(String[] args) {

   Solution solution = new Solution();
   int[] pushA = new int[]{1, 2, 3, 4, 5};
   int[] popA1 = new int[]{4, 3, 5, 1, 2};
   int[] popA2 = new int[]{4, 5, 3, 2, 1};

   System.out.println("popA1 是不是出栈队列 " + solution.IsPopOrder(pushA, popA1));
   System.out.println("popA2 是不是出栈队列 " + solution.IsPopOrder(pushA, popA2));
}
// 结果
//popA1 是不是出栈队列 false
//popA2 是不是出栈队列 true
复制代码

位运算

上一小节咱们用三道题了解一下面试过程当中栈和队列的常见面试题。本小节笔者将经过几个位运算的题目来带你们熟悉下经常使用的位运算知识。

相比于栈和队列来说，笔者自身认为位运算须要掌握的知识就要多一些，包括对于数字的二进制表示，二进制的反码，补码。以及二进制的常见运算都须要了解。固然若是系统的去学，可能没有经历，也可能即便学完了，仍旧不会作题。因此笔者认为经过直接去刷一些相应的题目，则是一个比较便捷的途径。

给定一个整数，请写一个函数判断该整数的奇偶性（✭✩✩✩✩）

该题目做为后续题目的铺垫，看上去仍是没有任何难度的。主要考察了面试可否想到用二进制的位运算方法去解决。

首先整数能够分为正数，负数，0。也能够分为奇数和偶数。偶数的定义是：若是一个数是2的整数倍数，那么这个数即是偶数。若是不使用位运算的方法，咱们彻底可使用下面的方式解决：

public boolean isOdd(int num){//odd 奇数
    return num % 2 != 0;
}
复制代码

但是面试题不可能去简单就考察这么简单的解法，进而咱们想到了二进制中若是 一个数是偶数那么最后一个必定是 0 若是一个数是奇数那么最后一位必定是 1；而十进制 1 在 8 位二进制中表示为 0000 0001，咱们只需将一个数个 1相与（&） 获得的结果若是是 1 则表示该数为奇数，否知为偶数。因此这道题的最佳解法以下：

public boolean isOdd(int num){
    return num & 1 != 0;
}
复制代码

#include "iostream"  
using namespace std;  
//声明
bool IsOdd(int num)；

bool IsOdd(int num)
{
    int res = (num & 1);
    return res != 0;
}
复制代码

测试：

int main(int argc, const char * argv[]) {
  std::cout << "是不是奇数 ： " << IsOdd(1) <<endl;
  std::cout << "是不是奇数 ： " << IsOdd(4) <<endl;
  return 0;
}

//结果
是不是奇数 ： 1//是 true
是不是奇数 ： 0//不是 false
复制代码

一样给定一个整数，请写一个函数判断该整数是否是2的整数次幂（✭✩✩✩✩）

这道题仍旧考察面试者对于一个数的二进制的表示特色，一个整数若是是2的整数次幂，那么他用二进制表示完确定有惟一一位为1其他各位都为 0，形如 0..0100...0。好比 8 是 2的3次幂，那么这个数表示为二进制位 0000 1000 。

除此以外咱们还应该想到，一个二进制若是表示为 0..0100...0，那么它减去1获得的数二进制表示确定是 0..0011..1 的形式。那么这个数与自本身减一后的数相与获得结果确定为0。

如：

 

 

因此该题最佳解法为：

public boolean log2(int num){
   return (num & (num - 1)) == 0;
}
复制代码

#include "iostream"  
using namespace std;  
//声明
bool IsLog2(int num)；
//定义
bool IsLog2(int num)
{
    return (num & (num -1)) == 0;
}
复制代码

测试：

int main(int argc, const char * argv[]) {
    std::cout << "是不是2的整数次幂 ： " << IsLog2(1) <<endl;
    std::cout << "是不是2的整数次幂 ： " << IsLog2(3) <<endl;
    return 0;
}

//结果
是不是2的整数次幂 ： 1 //是 true
是不是2的整数次幂 ： 0 //不是 false
复制代码

给定一个整数，请写一个函数判断该整数的二进制表示中1的个数（✭✭✩✩✩）

此题较之上一题又再进一步，判断一个整数二进制表示中1的个数，假设这个整数用32位表示，可正可负可0，那么这个数中有多少个1，就须要考虑到符号位的问题了。

相信读者应该都能想到最近基本的解法即经过右移运算后与 1 相与获得的结果来计算结果，若是采用这种解法，那么这个题的陷阱就在于存在负数的状况，若是负数的话标志位应该算一个1。因此右移的时候必定要采用无符号右移才能获得正确的解法。

ps 对于正数右移和无符号右移获得结果同样，若是是负数，右移操做将在二进制补码左边添加追加1，而无符号右移则是补 0 。

因此此题一种解法以下：

 

public int count1(int n) {
   int res = 0;
   while (n != 0) {
       res += n & 1;
       n >>>= 1;
   }
   return res;
}
复制代码

#include "iostream"  
using namespace std;
  
//注意C++中没有无符号右移操做，因此这里传入一个 unsigned 数做为 params
int count1(unsigned int n){
    int res = 0;
    while(n != 0){
        res += n & 1;
        n >>= 1;
    }
    return res;
}
复制代码

测试结果：

int main(int argc, const char * argv[]) {
    std::cout << "二进制中1的个数 ： " <<  count1(-1) <<endl;
    std::cout << "二进制中1的个数 ： " <<  count1(1) <<endl;
    return 0;
}

//结果
二进制中1的个数 ： 32
二进制中1的个数 ： 1
复制代码

能回答出上边的答案你的面试确定是及格了，可是做为练习来讲，是否有额外的解法呢？首先上述结果最坏的状况可能须要循环32次。上面咱们算过一道如何判断一个数是不是2的整数倍，咱们用过了 n&(n-1)==0 的方法。其实该题的第二个解法也能够用这个方法。为何呢？咱们开看一次上边的图：

 

 

咱们是否能发现，每次与比本身小1的数与那么该数的二进制表示最后一个为1位上的1将将会被抹去。其实这是一个知道有这种原理才能想到的方法，因此你们也不用哀叹说我怎么想不到，经过此次记住有这个规律下次就多一个思路也不是很么坏事。

下面咱们来看下判断一个数中有多少个1的完整图解：

 

 

因此咱们能够经过以下方法来获得题解，这样咱们能够减小移动次数

public int countA(int n){
   int res = 0;
   while(n != 0){
       n &= (n - 1);
       res++;
   }
   return res;
}
复制代码

#include "iostream"  
using namespace std;  
// 同上传入无符号整数 
int countA(unsigned int n){
    int res = 0;
    while(n != 0){
        n &= (n - 1);
        res++;
    }
    return res;
}
复制代码

测试结果：

int main(int argc, const char * argv[]) {
    std::cout << "二进制中1的个数 ： " <<  countA(-1) <<endl;
    std::cout << "二进制中1的个数 ： " <<  countA(1) <<endl;
    return 0;
}

//结果
二进制中1的个数 ： 32
二进制中1的个数 ： 1
复制代码

在其余数都出现两次的数组中找到只出现一次的那个数（✭✭✩✩✩）

这道题一样是考察为位运算的一道题，可是若是对于不熟悉位运算的朋友可能压根都不会往这方面想，也许当场直接就下边写下了遍历数组记每一个数出现次数的代码了。其实这道题要求在时间复杂度在O(n) 空间复杂度为O(1)的条件下，那种解法是不符合要求的。咱们来看下为位运算的解题思路。

首先咱们应该知道二进制异或操做，异或结果是二进制中两个位相同为0，相异为1。所以能够有个规律：

任何整数 n 与 0 异或总等于其自己 n，一个数与其自己异或那么结果确定是 0。

还须要知道一个规律：

多个数异或操做，遵循交换律和结合律。

对于第一条朋友们确定都很好理解，然而第二条规律才是这道题的解题关键。若是咱们有一个变量 eO = 0 那么在遍历数组过程当中，使每一个数与 eO 异或获得的值在赋值给额 eO 即 eO=eO ^ num 那么遍历结束后eO的值必定是那个出现一次的数的值。这是为何呢？咱们能够举个例子：

假设有这么一个序列： C B D A A B C 其中只有 D 出现一次，那么由于异或知足交换律和结合律，因此咱们遍历异或此序列的过程等价于

eO ^ (A ^ A ^ B ^ B ^ C ^ C ) ^ D = eO ^ 0 ^ D = D
复制代码

因此对于任何排列的数组，若是只有一个数只出现了奇数次，其余的数都出现了欧数次，那么最终异或的结果确定为出现奇数次的那个数。

因此此题能够有下面的这种解法：

java 解法

public int oddTimesNum(int[] arr) {
   int eO = 0;
   for (int cur : arr) {
       eO = eO ^ cur;
   }
   
   return eO;
}
复制代码

C++ 解法

 

int oddTimesNum(vector<int> arr) {
    int eO = 0;
    for (int cur : arr) {
        eO = eO ^ cur;
    }
    return eO;
}
复制代码

测试：

int main(int argc, const char * argv[]) {
  vector<int>  arr = {2,1,3,3,2,1,4,5,4};
  std::cout << "出现奇数次的那个数： " << oddTimesNum(arr) <<endl;
  return 0;
}

//结果
出现奇数次的那个数： 5
复制代码

关于这道题还有个延伸版本，就是若是数组中出现1次的数有两个，那么该如何获得这两个数。

在其余数都出现两次的数组中找到只出现一次的那两个数（✭✭✭✩✩）

咱们顺着上题的思路来思考，若是有两个数得到的结果 eO 确定是 eO = a^b,此题的关键就在于如何分别获得 a，b 这两个数。咱们应该想到，任何不相同的两个除了跟本身异或外，不可能每个位都相同，也就是说不相同的两个数 a b 异或获得结果二进制表示上确定有一位为 1。 这是关键。

咱们能够假设第 k 位不为 0 ，那么就说明 a 与 b 在这位上数值不相同。咱们要作只是设置一个数第 k 位 为 1，其他位为 0 记为 rightOne。

这时须要拿 eOhasOne = 0 再异或遍历一次数组，可是须要忽略与 rightOne 相与等于 0 的数。由于相与等于 0 则表明了这个数确定是两个数中第 k 位不为 1的那个。最终获得的 eOhasOne 就是 a b 中第 k 为为 1 的那个。

那么接下来就剩下一个问题要解决了，如何找到 rightOne ，这里采用与自己补码相与的方法获得即 int rightOne = eO & (~eO + 1) 。

能够参照下图来理解下整个过程：

 

 

咱们来看下最终的代码:

java 写法

public void printOddTimesNum(int[] arr) {
   int eO = 0;
   int eOhasOne = 0;

   for (int cur : arr) {
       eO = eO ^ cur;
   }

   int rightOne = eO & (~eO + 1);
   for (int cur : arr) {
       if ((rightOne & cur) != 0) {
           eOhasOne = eOhasOne ^ cur;
       }
   }

   System.out.println("eOhasOne = " + eOhasOne + "  " + (eOhasOne ^ eO));
}
复制代码

C++ 写法

void printOddTimesNum(vector<int> arr) {
    int eO = 0;
    int eOhasOne = 0;
    
    for (int cur : arr) {
        eO = eO ^ cur;
    }
    
    int rightOne = eO & (~eO + 1);
    
    for (int cur : arr) {
        if ((cur & rightOne) != 0) {
            eOhasOne = eOhasOne ^ cur;
        }
    }
    
    std::cout<<"一个出现1次的数 " << eOhasOne << endl;
    std::cout<<"二个出现1次的数 " << (eO ^ eOhasOne) <<endl;
}
复制代码

测试：

int main(int argc, const char * argv[]) {
    vector<int>  arr1 = {2,1,3,3,2,1,4,5};
    printOddTimesNum(arr1);
    return 0;
} 

//结果：
一个出现1次的数 5
二个出现1次的数 4
复制代码

总结

本文列举了栈队列以及位运算的一些面试题目，经过这些面试题目咱们能够了解到一些面试中算法的考点，对于位运算相关题目，咱们仍是须要多加练习，可是不要惧怕本身某些地方不会限制了解题思路，经过多加练习，记住见过的解题中的规律，相信通过一段时间练习后，也会感觉到自个人提升。

最后欢迎你们关注个人掘金专栏，不定时分享一些本身的学习工做总结。

像一只狗的掘金专栏

参考

《剑指 offer 第二版》 《程序员代码面试指南 - 左程云》