zoukankan      html  css  js  c++  java
  • java:数据结构复习(三)链表队列

    @


    和栈一样,队列也是表,但是使用队列的特点是先进先出。

    队列模型

    队列的基本操作是入队,它是在表的末端插入一个元素,和出队,它是删除在表开头的一个元素

    graph LR A[<kbd>入队</kbd>] --> b[队列] b[队列] --> c[<kbd>出队</kbd>]

    队列的链表实现

    链表队列的实现

    import java.util.EmptyStackException;
    
    /**
     * @author 李正阳
     * @param <E> 泛型
     */
    public class MyLinkQueue<E> implements queue<E>  {
        /**
         * @param size 表中元素的个数
         * @param front 队头
         * @param rear 队尾
         */
        private int size=0;
        private Node<E> front;
        private Node<E> rear;
    
        /**
         * 入队方法
         * 在队尾添加节点
         * @param p 添加进表中的元素
         * @return true 添加成功 false 添加失败
         */
        @Override
        public boolean push(E p) {
    
            Node<E> d=new Node(p);
            /**
             * 空表就将队头队尾设置在同一个节点
             */
            if(isEmpty()){
                front=d;
                rear=d;
            }else{
                rear.setNext(d);
                d.setPre(rear);
                rear=d;
            }
            size++;
            return true;
        }
    
        /**
         *出队方法如果为空队列就抛出异常
         * 头删节点法
         *
         * @return
         */
        @Override
        public E pop() {
            Node<E> p;
            if(isEmpty()){
                throw new EmptyStackException();
            }else{
                p=front;
                front=front.getNext();
                front.setPre(null);
            }
            return p.getData();
        }
    
        /**
         * @return 返回表中的元素个数
         */
        @Override
        public int size() {
            return size;
        }
    
        /**
         * 输出表中元素从表头到表尾
         */
        @Override
        public void travel() {
            Node<E> p=front;
            while (p!=null){
                System.out.print(p.getData()+" ");
                p=p.getNext();
            }
            System.out.println();
        }
    
        /**
         * 判空方法
         * @return true 表为空 false 表不为空
         */
        @Override
        public boolean isEmpty() {
            if(size==0){
                return true;
            }else{
                return false;
            }
        }
    
        /**
         * 获得队尾元素
         * @return 队尾元素
         */
        @Override
        public E getRear() {
            return rear.getData();
        }
        /**
         * 获得队头元素
         * @return 队头元素
         */
        @Override
        public E getFront() {
            return front.getData();
        }
    
        /**
         * 内部内
         * @param <E> 节点类型
         */
        private class Node<E>{
            E data;
            Node<E> next;
            Node<E> pre;
            public Node(E data){
                this.data=data;
            }
    
            public Node(E data, Node next, Node pre) {
                this.data = data;
                this.next = next;
                this.pre = pre;
            }
            public Node(){
                next=null;
                pre=null;
                data=null;
            }
            public E getData() {
                return data;
            }
    
            public void setData(E data) {
                this.data = data;
            }
    
            public Node getNext() {
                return next;
            }
    
            public void setNext(Node next) {
                this.next = next;
            }
    
            public Node getPre() {
                return pre;
            }
    
            public void setPre(Node pre) {
                this.pre = pre;
            }
        }
    }
    
    

    队列的接口实现

    /**
     * 队列的接口
     * @param <E> 泛型类型
     */
    public interface queue<E> {
         /**
          * 入队方法
          * @param p
          * @return
          */
         boolean push(E p);
    
         /**
          * 出队方法
          * @return 返回泛型类型的方法
          */
         E pop();
    
         /**
          * 表中元素的大小
          * @return
          */
         int size();
    
         /**
          * 输出表中元素
          */
         void travel();
    
         /**
          * 判断表是否为空的
          * @return true 表是空的 false 表是非空
          */
         boolean isEmpty();
    
         /**
          * 获取表尾元素
          * @return 表尾的元素
          */
         E getRear();
    
         /**
          * 获取表头的元素
          * @return 表头的元素
          */
         E getFront();
    }
    
    
  • 相关阅读:
    linux下启动和关闭网卡命令及DHCP上网
    python 编码问题
    paddlepaddle
    Convolutional Neural Network Architectures for Matching Natural Language Sentences
    deep learning RNN
    Learning Structured Representation for Text Classification via Reinforcement Learning 学习笔记
    Python IO密集型任务、计算密集型任务,以及多线程、多进程
    EM 算法最好的解释
    tensorflow 调参过程
    tensorflow 学习纪录(持续更新)
  • 原文地址:https://www.cnblogs.com/lzy321/p/10800063.html
Copyright © 2011-2022 走看看