队列的学习

wwwwwwwwwwww2

于 2024-08-07 19:32:45 发布

阅读量315

点赞数 10

文章标签：学习 java 算法 leetcode 数据结构链表

本文链接：https://blog.csdn.net/m0_56198792/article/details/140993108

版权

队列的概念

先进先出的特点，类似于排队

Queue 普通的队列，接口

Deque双端队列，接口

怎么使用队列

Queue<Integer> queue=new LinkedList<>() ;重写Queue接口

双向链表来实现队列

这个双向链表提供一个头删，尾插

public class MyLinkQueue {
    static class ListNode{
        public int val;
        public ListNode next;
        public ListNode prev;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;
    public ListNode last;
    public int useSize;

    public boolean offer(int val){
        ListNode node=new ListNode(val);
        if (head==null){//这是插入第一个节点
            head=node;
            last=node;

        }else {
            last.next=node;
            node.prev=last;
            last=last.next;

        }
        useSize++;
        return true;
    }

    public int poll(){
        if (head==null){
            return -1;
        }
        int retVal=head.val;
        if (head.next==null){

            head=null;
            last=null;
            useSize--;
            return retVal;
        }
        head=head.next;
        head.prev=null;
        useSize--;
        return retVal;
    }
    public int size(){
        return useSize;

    }
}

循环数组实现队列

设计循环队列

public class MyCircularQueue {


    public int[] elem;
    public int front;//队头
    public int rear;

    public MyCircularQueue(int k) {
        elem=new int[k+1];//多一个空间

    }

    public boolean enQueue(int value) {
        if (isFull()){
            return false;
        }
        elem[rear]=value;
        rear=(rear+1)%elem.length;
        return true;

    }

    public boolean deQueue() {
        if (isEmpty()){
            return false;
        }
        front =(front+1)%elem.length;
        return true;

    }

    //得到队头元素
    public int Front() {
        if (isEmpty()){
            return -1;
        }

        return elem[front];
    }

    public int Rear() {
        if (isEmpty()){
            return -1;
        }
        //在0时rear-1会越界
       int index=(rear==0)?elem.length-1:rear-1;
        return elem[index];

    }

    public boolean isEmpty() {
        return front==rear;

    }

    public boolean isFull() {//rar所在的这个空间被浪费了，表示满
        return (rear+1)%elem.length==front;

    }
}

双端队列

实现了Deque这个接口

两头都可以进出

及可以实现多个接口

队列的部分题目

用队列实现栈

栈是先进后出，队列是先进先出

用两个队列

class MyStack {
    private Queue<Integer> qu1;
    private Queue<Integer> qu2;

    public MyStack() {
        qu1=new LinkedList<>();
        qu2=new LinkedList<>();

    }
    
    public void push(int x) {
        if (!qu1.isEmpty()){
            qu1.offer(x);
        }else if (!qu2.isEmpty()){
            qu2.offer(x);
        }else {
            //两个队列都是空，指定存放到一个队列当中
            qu1.offer(x);
        }

    }
    
    public int pop() {
        if (empty()){
            return -1;
        }
        if(!qu1.isEmpty()){
            int size=qu1.size();
            for (int i = 0; i < size-1; i++) {
                int x=qu1.poll();
                qu2.offer(x);
            }
            return qu1.poll();
        } else {
            int size=qu2.size();
            for (int i = 0; i < size-1; i++) {
                int x=qu2.poll();
                qu1.offer(x);
            }
            return qu2.poll();
        }

    }
    
    public int top() {
        if (empty()){
            return -1;
        }
        if(!qu1.isEmpty()){
            int size=qu1.size();
            int x=-1;
            for (int i = 0; i < size; i++) {
                x=qu1.poll();
                qu2.offer(x);
            }
            return x;
        } else {
            int x=-1;
            int size=qu2.size();
            for (int i = 0; i < size; i++) {
                x=qu2.poll();
                qu1.offer(x);
            }
            return x;
        }

    }
    
    public boolean empty() {
        //两个队列同时为空说明模拟实现的栈是空的
        return qu1.isEmpty()&&qu2.isEmpty();

    }
}

用栈来实现队列

class MyQueue {

    private Stack<Integer> s1;
    private  Stack<Integer> s2;
    public MyQueue() {
        s1=new Stack<>();
        s2=new Stack<>();

    }
    
    public void push(int x) {
        s1.push(x);

    }
    
    public int pop() {
        if (empty()){
            return -1;
        }

        if (s2.empty()){
            while (!s1.empty()){
                s2.push(s1.pop());
            }

        }
        return s2.pop();
    }
    
    public int peek() {
        if (empty()){
            return -1;
        }

        if (s2.empty()){
            while (!s1.empty()){
                s2.push(s1.pop());
            }

        }
        return s2.peek();

    }
    
    public boolean empty() {
        return s1.empty()&&s2.empty();

    }
}