Java 队列

目录

• ​​队列的函数​​
• ​​java实现队列​​

队列的函数

offer(root)
poll()

不管怎么实现，只要在外部
能够进行先进先出这个功能
那么就是队列，管他是数组还是链表呢

35 _ 队列1 _ 什么是队列
线性结构的两种常见应用之二 队列
定义：
一种可以实现“先进先出”的存储结构
front，rear，这就是队列
在队首删除
出队，入队

指针的移动来进行，元素的删除与增加

java没有指针（表面上没有）

java。就是c+±>

链式队列用链表实现
静态队列，用数组来实现的

头结点
便于链表的操作

可以使用链表实现，也可以使用两个栈实现
使用链表实现
从尾部添加元素，（多一个尾节点，方便添加）
从头部删除元素

java实现队列

package cn.itcast.algorithm.linear;

import java.util.Iterator;

/**
 * @Author: 从南到北
 * @Date: 2022/01/06/20:55
 */
public class Queue<T> implements Iterable<T> {


    @Override
    public Iterator<T> iterator() {
        //接口内部返回一个实现类对象
        return new QIterator();
    }
    //写实现类对象
    private class QIterator implements Iterator{
        //遍历队列，就是遍历链表
        //用来记录每次遍历到的节点
        private Node n;

        //添加构造方法，对成员变量进行初始化
        public QIterator(){
            this.n = head;

        }

        @Override
        public boolean hasNext() {

            return n.next!=null;
        }

        @Override
        public Object next() {
            n=n.next;
            return n.item;
        }
    }

    //内部节点类
    private class Node{
        public T item;    
        public Node next;

        public Node(T item,Node next){
            this.item = item;
            this.next = next;
        }
    }

    //头节点
    private Node head;            //头接点
    //尾节点
    private Node last;
    //元素个数
    private int N;

    //初始化队列
    public Queue(){
        head = new Node(null,null);
        last = null;
        N=0;
    }

    //判断是否为空
    public boolean isempty(){
        return N==0;
    }

    //获取元素个数
    public int size(){
        return N;
    }
    //插入,是在最后一个元素后面插入
    public void enqueue(T t){
        if (last == null){
            last = new Node(t,null);
            head.next = last;
        }else {
            Node oldLast = last;
            last = new Node(t,null);
            oldLast.next = last;
        }
        N++;
    }

    //取出元素
    public T dequeue(){
        if (isempty()){
            return null;
        }

        Node oldFirst = head.next;
        head.next = oldFirst.next;
        N--;
        //因为出队列其实是在删除元素，因此如果队列中元素被删除完了，需要重置last=null;
        if (isempty()){
            last = null;
        }
        return oldFirst.item;
    }

    //遍历队伍


}

测试代码：

package cn.itcast.algorithm.test;

import cn.itcast.algorithm.linear.Queue;

/**
 * @Author: 从南到北
 * @Date: 2022/01/06/21:53
 */
public class QueueTest {
    public static void main(String[] args) {
        Queue<String> q = new Queue<>();
        q.enqueue("a");
        q.enqueue("b");
        q.enqueue("c");
        q.enqueue("d");
        q.enqueue("e");
        for (String str:q){
            System.out.println(str+" ");
        }

        System.out.println("--------------");

//        q.dequeue();
        System.out.println("出队列元素："+q.dequeue());
        System.out.println("剩余元素个数："+q.size());
    }
}

输出结果：

参考链接：
​​​https://www.bilibili.com/video/BV1iJ411E7xW?p=73​​