大数据最全队列及其经典面试题_队列面试题(2)，2024年最新2024年冲刺年薪40w

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

代码如下：

int lastIndex = tail == 0 ? data.length -1 : tail - 1

---

五、队列的常见问题

1.用队列实现栈

链接如下：225.用队列实现栈

---

解题思路：

思路1：（双队列思路）

这个问题的本质和双栈实现最小栈是相同的思路，一定要保证其中一个队列就是进行实际元素存储的，另一个队列就是作为辅助操作。

q1永远是存储元素的队列，新元素添加到q2中，将此时q1中的所有元素出队再入队q2恰好就能实现添加顺序和出队顺序相反的操作。

1. 新元素永远入q2
2. 将老元素q1依次出队再入q2 （这样就交换了元素的先后顺序）
3. q1和q2交换引用

• 其中一个队列q1永远都是存储元素的队列，栈的pop就是s1的poll，栈的peek就是s1的peek，栈的push就是s1的offer。 （所以整个题的核心操作就是push()）
• 以保证s1和栈的操作一一对应。
• 另外一个队列就是作为辅助操作。

代码如下：

class MyStack {
    Deque<Integer> temp;
    Deque<Integer> q1;
    Deque<Integer> q2;
    public MyStack() {
        q1 = new LinkedList<>();
        q2 = new LinkedList<>();
    }
    
    public void push(int x) {
        q2.offer(x);
        while(!q1.isEmpty()){
            q2.offer(q1.poll());
        }
        temp = q1;
        q1 = q2 ;
        q2 = temp;
    }
    
    public int pop() {
        return q1.poll();
    }
    
    public int top() {
        return q1.peek();
    }
    
    public boolean empty() {
        return q1.isEmpty();
    }
}

思路2：（单队列思路）

1. 先记录下当前队列中的元素个数n
2. 将新元素直接入队
3. 为了让新元素变成队首元素，连续出队n次（新元素的之前的所有元素都出队列，此时新元素变成了队首元素），再依次入队n次即可。

代码如下：

class MyStack {
    private Deque<Integer> queque;
    private int length=0;//1.先记录一下栈此时的元素个数
    public MyStack() {
        queque=new LinkedList<>();
    }

    public void push(int x) {
        queque.offer(x);//2.新元素直接入队
        //3.把新元素之前的元素挨个出队再入队，此时最新的元素就是队头元素
        for (int i=0;i<length;i++){
            queque.offer(queque.poll());
        }
        length++;

    }

    public int pop() {
        length--;
        return queque.poll();

    }

    public int top() {
        return queque.peek();
    }

    public boolean empty() {
        return queque.isEmpty();
    }
}

2.用栈实现队列

链接如下：用栈实现队列

解题思路：

思路1：(入队 - 时间复杂度为O(n)，出队 - O(1))

定义s1永远是保存元素的栈

1. 先将s1中的现有元素依次弹出放入s2
2. 将新元素入s1 => 此时这个新元素就变成了s1的栈底（队尾元素）
3. 将s2中的元素再依次弹回来（先进先出）

代码如下：

class MyQueue {
    Deque<Integer> s1;
    Deque<Integer> s2;
    public MyQueue() {
        s1 = new LinkedList<>();
        s2 = new LinkedList<>();
    }
    
    public void push(int x) {
        while(!s1.isEmpty()){
            s2.push(s1.pop());
        }
        s1.push(x);
        while(!s2.isEmpty()){
            s1.push(s2.pop());
        }
    }
    
    public int pop() {
        return s1.pop();
    }
    
    public int peek() {
        return s1.peek();
    }
    
    public boolean empty() {
        return s1.isEmpty();
    }
}

思路2：(入队 - 时间复杂度为O(1)，出队-摊还复杂度O(1))

1. push是正常push的，核心操作在pop里面
2. push进s1的元素依次出栈再入s2栈的时候，出入顺序就会颠倒
3. 根据上述特性，把s2的栈顶当作队首就行了，因为队列都是队首出队的。
4. 每次pop先判断当前s2是否为空，若为空，则把s1中的元素全部出栈并且压进s2里面，此时s2的栈顶就是队首元素（先进先出）。若不为空，证明上一轮push进来的元素还没pop完，继续pop当前s2的栈顶就行。

class MyQueue {
    Deque<Integer> s1 ;
    Deque<Integer> s2 ;
    public MyQueue() {
        s1 = new LinkedList<>();
        s2 = new LinkedList<>();
    }
    
    public void push(int x) {
        s1.push(x);
    }
    
    public int pop() {
        if(s2.isEmpty()){
            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }
        }
        return s2.pop();
    }
    
    public int peek() {
        if(s2.isEmpty()){
            while(!s1.isEmpty()){
                s2.push(s1.pop());
            }
        }
        return s2.peek();
    }
    
    public boolean empty() {
        return s1.isEmpty() && s2.isEmpty();
    }
}

总结

以上就是队列及其经典面试题的全部内容了，有帮助的话麻烦各位给个三连~~感谢！！！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

47928)]
[外链图片转存中…(img-WnVOiVmV-1715763147928)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！