精华内容
下载资源
问答
  • java语言实现链队列

    2021-05-13 09:22:28
    使用java语言实现链队列


    前言:
    队列是一种特殊的线性表,他的特殊性体现在只能在尾部进行插入,头部进行删除,所以可以将队列看成是一种特殊的线性表。他的鲜明特点就是“先进先出”或者叫“后进后出”。队列这种数据结构的实现一般都是基于线性表的,而线性表又有顺序表和链表两种,所以队列的实现就又分为顺序队列和链队列。这篇文章用以总结使用单链表来实现的队列–链队列。若是需要查看顺序队列实现请点这里: 顺序队列

    一、实现过程

    1.提供队列的接口:IQueue

    该接口定义了队列中必须实现的方法,因此在队列实现时只需要继承该接口然后正确实现该接口中的方法即可。无论是顺序队列还是链队列。都可以通过实现该接口来实现,下面是该接口中具体定义的方法。

    public interface IQueue {
        void clear();
        boolean isEmpty();
        int length();
        Object peek();//查看队列头元素
        void offer(Object object) throws Exception;//入队
        Object poll();//出队
    }
    

    2.提供节点类:Node

    因为链队列的底层是单链表,因此我们必须要为单链表提供节点类,节点类需要包含两部分:一部分是数据域用以存储数据;一部分是指针域用以存储指向下一节点的指针。同时需要提供相应的构造方法,代码如下:

    public class Node {
        public Object object;
        public Node next;
    
        public Node(){
        }
        public Node(Object object){
            this.object = object;
        }
        public Node(Node next){
            this.next = next;
        }
        public Node(Object object,Node next){
            this.object = object;
            this.next = next;
        }
    
        @Override
        public String toString() {
            return "Node{" +
                    "object=" + object +
                    ", next=" + next +
                    '}';
        }
    }
    

    3.提供链队列的实现:LinkedQueue

    链队列因为数据流向都是单向的,因此使用单链表就可以实现。又根据队列的“先进先出”规则我们可以知道我们需要同时关注首结点和尾结点,因此需要声明尾结点,这样我们在尾部插入时就会很方便,若是不使用尾结点的话,每次队列的插入操作就需要遍历到链表的尾部进行插入,这样每次插入的时间复杂度都变成了O(n),这是很耗费性能的。因此我们需要提供带有尾结点的单链表,同时提供首结点,用以标注链表的开始,注意这里是首结点不是头结点。首结点与头结点的区别是首结点存储数据,头结点是不存储数据的。提供了首结点和尾结点后我们还需要在构造器中对他们进行初始化。代码如下:

    /**
     * 链式队列就相当于,既含有首结点,也含有尾结点的单链表
     * @author pcc
     * @version 1.0.0
     * @className LinkedQueue
     * @date 2021-04-29 09:55
     */
    public class LinkedQueue implements IQueue{
        Node front;//首结点
        Node rear;//尾结点
    
        public LinkedQueue(){
            front = rear  = new Node();
        }
    
        @Override
        public void clear() {
            front = null;
            rear = null;
    
        }
    }
    

    4.提供清空(clear)、判空(isEmpty)、队列长度(length)等方法

    这些方法的实现就比较简单,就一起简单说下就好。初始状态下front和rear节点相等且他们的数据域都是null,因此清空时我们就将队列还原成这个样子即可;判空也是判断首结点和尾结点是不是在初始装态,是的话自然就是空的了;队列长度的求取有两种方案,一种是维护一个计数器每次出队和入队时进行计算。另外一种就是遍历链表计算结点个数,笔者使用的是遍历链表,代码实现如下:

        @Override
        public void clear() {
            front = rear  = new Node();
    
        }
    
        @Override
        public boolean isEmpty() {
            if(front == rear && front.object == null)
                return true;
            return false;
        }
    
        @Override
        public int length() {
            int length = 0;
            Node temp = front;
            if(front!=rear)
                while(temp!=null){
                    length++;
                    temp = temp.next;
                }
            return length;
        }
    

    5.提供入队方法:offer

    队列的典型特征是“先进先出”,因此我们肯定是在一端进行插入一端进行删除。简单分析下数据的插入场景后可以发现,在第一个数据插入时front和rear应该还是相等的,只有一个元素时首结点也是尾结点;数据量大于1时则首结点和尾结点则不会有直接关系,此时的插入只需要在尾结点后继续拼接即可,代码如下:

        @Override
        public void offer(Object object) throws Exception {
            Node temp = new Node(object,null);
            if(rear.object==null)
                rear = front = temp;
            else{
                rear.next = temp;//尾部插入
                rear = temp;
            }
    
        }
    

    6.提供出队方法:poll

    队列的典型特征是“先进先出”或者叫“后进后出”,插入时选择在尾部插入,那么我们显然就应该在头部进行删除(反过来其实一样:在链表的头部进行插入尾部进行删除)。头部进行删除我们应该考虑两种情况一种是只有一个元素时一种是多个元素时,一个元素时front和rear相等,此时出队后队列就空了。多个元素时只需要将首结点的下一个结点设置为首结点即可。代码实现如下:

        @Override
        public Object poll() {
            if(front!=null){
    
                Node frontTemp = front;
                if(front==rear){//只有一个元素时出队
                    front = rear = new Node();
                }else{//其他场景出队
                    front = front.next;
                }
                return frontTemp.object;
            }
            return null;
        }
    

    7.提供获取队列头部元素的方法:peek

    该方法只是返回队列的头部元素,并不进行出队。该方法的实现就比较简单了,我们只需要确定首结点不是null即可,非null返回首结点的数据域,否则返回null。代码如下:

        @Override
        public Object peek() {
            return front!=null?front.object:null;
        }
    

    8.提供实现的完整代码

    到这里链队列的方法就都实现了,各个方法实现起来其实都不难,难的是什么呢?好像没有难的,知道链队列的思想就可以轻松实现了。下面贴下链栈的完整代码:

    /**
     * 链式队列就相当于,既含有首结点,也含有尾结点的单链表
     * @author pcc
     * @version 1.0.0
     * @className LinkedQueue
     * @date 2021-04-29 09:55
     */
    public class LinkedQueue implements IQueue{
        Node front;//首结点
        Node rear;//尾结点
    
        public LinkedQueue(){
            front = rear  = new Node();
        }
    
        @Override
        public void clear() {
            front = rear  = new Node();
    
        }
    
        @Override
        public boolean isEmpty() {
            if(front == rear && front.object == null)
                return true;
            return false;
        }
    
        @Override
        public int length() {
            int length = 0;
            Node temp = front;
            if(front!=rear)
                while(temp!=null){
                    length++;
                    temp = temp.next;
                }
            return length;
        }
    
        @Override
        public Object peek() {
            return front!=null?front.object:null;
        }
    
        @Override
        public void offer(Object object) throws Exception {
            Node temp = new Node(object,null);
            if(rear.object==null)
                rear = front = temp;
            else{
                rear.next = temp;//尾部插入
                rear = temp;
            }
    
        }
    
        @Override
        public Object poll() {
            if(front!=null){
    
                Node frontTemp = front;
                if(front==rear){//只有一个元素时出队
                    front = rear = new Node();
                }else{//其他场景出队
                    front = front.next;
                }
                return frontTemp.object;
            }
    
    
            return null;
        }
    }
    
    

    二、测试顺序队列的相应方法

    1.测试入队和出队

    链队列的实现已经完成了,下面需要测试下实现的方法是否正确,根据队列的“先进先出”特点,若是入队和出队的顺序保持一致,则说明方法的实现没有问题,测试结果如下,可以发现方法的入队和出队是一致的,也代表队列的入队和出队方法没有问题。
    在这里插入图片描述

    2.测试其他方法

    上面的案例中已经测试了入队、出队、长度、非空等方法了,下面再配合清空方法测试下,如下图:
    在这里插入图片描述
    由上图可以看出:插入5个元素后队列长度是5、此时判空是false、然后清空操作再判空是true、然后获取首元素就是null;可以发现这些方法的操作和输出都没有问题。

    三、总结

    这篇文章总结了链队列的实现,代码是没有难度的,主要是掌握队列的思想。无论是使用单链表还是顺序表来实现队列,都只是队列的内部实现而已,平时的使用更关注的是队列的操作。队列是一种使用很广的数据结构,使用频率也很高,比如jvm中的finalize队列,线程池的等待队列,以及各种阻塞非阻塞队列等等。所以说掌握队列的思想还是很有必要的,这篇文章只是以一个实现者的角度去写的,可能并不是适合很多人,但也希望可以帮到看到这篇文章的你。

    展开全文
  • //该队带头节点,front指向头节点 private Node rear; public LinkQueue() { front = new Node(null); rear = front; } //判队空 public boolean isEmpty() { return front == rear; } //入队 public void EnQueue...

    (用来做笔记,欢迎交流讨论!)

    程序包含以下几个方法:

    1. public boolean isEmpty() //判队空

    2. public void EnQueue(T data) //入队

    3. public void DeQueue() //出队

    4. public void getFront() //读队头元素

    贴上代码:

    package com.fei.example.lib;
    
    public class LinkQueue<T> {
        private class Node {
            private T data;
            private Node next;
    
            public Node(T data) {
                this.data = data;
            }
        }
    
        private Node front;//该链队带头节点,front指向头节点
        private Node rear;
    
        public LinkQueue() {
            front = new Node(null);
            rear = front;
        }
    
        //判队空
        public boolean isEmpty() {
            return front == rear;
        }
    
        //入队
        public void EnQueue(T data) {
            Node node = new Node(data);
            node.next = null;
            rear.next = node;
            rear = node;
        }
    
        //出队
        public void DeQueue() {
            if (isEmpty()) {
                System.out.println("队为空");
                return;
            }
            front.next = front.next.next;
            if (rear == front.next) {
                rear = front;
            }
        }
    
        //读队头元素
        public void getFront() {
            if (isEmpty()) {
                System.out.println("队为空");
            } else {
                System.out.println(front.next.data);
            }
        }
    
        //测试数据
        public static void main(String[] args) {
            LinkQueue<Integer> queue = new LinkQueue<>();
            queue.getFront();
            queue.DeQueue();
            queue.EnQueue(0);
            queue.EnQueue(1);
            queue.EnQueue(2);
            queue.EnQueue(3);
            queue.EnQueue(4);
            queue.DeQueue();
            queue.getFront();
        }
    }
    

     

    展开全文
  • JAVA实现链队列

    2020-03-23 00:04:43
    JAVA实现链队列 队列是一种特殊的线性表,主要的特点在于其添加数据是在队尾进行操作的而删除数据是在队首进行操作的。 定义Node类 class Node{ int data; Node next; public Node(int data){ this.data=data; ...

    JAVA实现链队列

    队列是一种特殊的线性表,主要的特点在于其添加数据是在队尾进行操作的而删除数据是在队首进行操作的。

    定义Node类

    class Node{
    	int data;
    	Node next;
    	public Node(int data){
    		this.data=data;
    	}
    }
    

    定义链队列方法类

    class CreateQueue{
    	Node rear=null;
    	Node head=null;
    	//判断队列是否为空
    	public boolean isempty(){
    		if(head==null) {
    			return true;
    		}
    		return false;
    	}
    	//入队
    	public void add(int data) {
    		Node newNode=new Node(data);
    		
    		if(rear==null) {
    			rear=newNode;
    			head=newNode;
    			return;
    		}
    		Node pos=rear;
    		while(pos.next!=null) {
    			pos=pos.next;
    		}
    		pos.next=newNode;
    	}
    	//出队
    	public boolean out() {
    		if(head.next!=rear) {
    			head=head.next;
    			return true;
    		}
    		return false;
    	}
    	//取队首值
    	public void headnum() {
    		if(isempty()) {
    			System.out.println("队列已空");
    		}else {
    		System.out.println("队首值是:"+head.data);
    		}
    	}
    	//取队尾值
    	public void rearnum() {
    		  Node nextNode=rear; 
    		  while(nextNode.next!=null) { 
    			  nextNode=nextNode.next; 
    		  }
    		  if(isempty()) {
    			  System.out.println("队列已空");
    		  }else {
    		  System.out.println("队尾的值是:"+nextNode.data);
    		  }
    	}
    	//求队列的长度
    	public void length() {
    		Node nextNode=head;
    		int i=0;
    		if(isempty()) {
    			System.out.println("队列为空");
    		}else {
    			while(nextNode!=null) {
    				i++;
    				nextNode=nextNode.next;
    			}
    		}
    		System.out.println("队列的长度是:"+i);
    	}
    }
    

    不足处
    1.该代码存储的数据只是int类型。
    2.只实现了链队列的基础操作(入队、出队、求队列长度)大家可以参考进行扩展。

    展开全文
  • Java实现队列——顺序队列、链式队列 概念 先进者先出,这就是典型的“队列”。(First In, First Out,FIFO)。 我们知道,栈只支持两个基本操作:入栈push()和出栈pop()。队列跟栈非常相似,支持的操作也很有限,最...

    Java实现队列——顺序队列、链式队列

    概念

    先进者先出,这就是典型的“队列”。(First In, First Out,FIFO)。

    我们知道,栈只支持两个基本操作:入栈push()和出栈pop()。队列跟栈非常相似,支持的操作也很有限,最基本的操作也是两个:入队和出队。入队 enqueue(),让一个数据到队列尾部;出队 dequeue(),从队列头部取一个元素。

    栈和队列

    所以,队列跟栈一样,也是一种操作受限的线性表数据结构。

    跟栈类似,用数组实现的队列叫做顺序队列,用链表实现的队列叫做链式队列。下面我们看下如何用Java代码如何实现。

    顺序队列

    代码如下:

    public class QueueBasedArray implements QueueInterface {
        private String[] values;// 数组
        private int capacity = 0;// 数组容量
        private int head = 0;// 头部下标
        private int tail = 0;// 尾部下标
    
        public QueueBasedArray(int capacity) {
            values = new String[capacity];
            this.capacity = capacity;
        }
    
        @Override
        public Boolean enqueue(String value) {
            // tail == capacity 表示队列末尾没有空间了
            if (tail == capacity) {
                // tail == capacity && head == 0 表示整个队列都占满了。
                if (head == 0) {
                    return false;
                }
                // 数据搬移
                for (int i = head; i < tail; i++) {
                    values[i - head] = values[i];
                }
                // 搬移完成后更新 head 和 tail
                tail -= head;
                head = 0;
            }
            values[tail] = value;
            tail++;
            return true;
        }
    
        @Override
        public String dequeue() {
            // 如果 head == tail 表示队列为空
            if (0 == tail) {
                return null;
            }
            String result = values[head];
            head++;
            return result;
        }
    
        @Override
        public String toString() {
            return "QueueBasedArray{" +
                    "values=" + Arrays.toString(values) +
                    ", capacity=" + capacity +
                    ", head=" + head +
                    ", tail=" + tail +
                    '}';
        }
    }
    

    测试代码:

        QueueBasedArray qba = new QueueBasedArray(10);
        System.out.println(qba);
    
        for (int i = 0; i < 10; i++) {
            qba.enqueue("" + i + i + i);
        }
        System.out.println(qba);
    
        for (int i = 0; i < 10; i++) {
            qba.dequeue();
            System.out.println(qba);
        }
    
        for (int i = 11; i < 20; i++) {
            qba.enqueue("" + i + i + i);
        }
        System.out.println(qba);
    

    输出结果:符合预期

    QueueBasedArray{values=[null, null, null, null, null, null, null, null, null, null], capacity=10, head=0, tail=0}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=0, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=1, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=2, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=3, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=4, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=5, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=6, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=7, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=8, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=9, tail=10}
    QueueBasedArray{values=[000, 111, 222, 333, 444, 555, 666, 777, 888, 999], capacity=10, head=10, tail=10}
    QueueBasedArray{values=[111111, 121212, 131313, 141414, 151515, 161616, 171717, 181818, 191919, 999], capacity=10, head=0, tail=9}
    

    链式队列

    代码如下:

    public class QueueBasedLinkedList implements QueueInterface {
        private Node head;
        private Node tail;
    
        /**
         * 入队
         *
         * @param value
         * @return
         */
        @Override
        public Boolean enqueue(String value) {
            Node newNode = new Node(value, null);
    
            // tail为null,表示队列中没有数据
            if (null == tail) {
                head = newNode;
                tail = newNode;
            } else {
                tail.next = newNode;
                tail = newNode;
            }
    
            return true;
        }
    
        /**
         * 出队
         *
         * @return
         */
        @Override
        public String dequeue() {
            // head == null,表示队列为空。
            if (null == head) {
                return null;
            }
    
            // 获取数据
            String value = head.getItem();
            // 移除头结点,让head指向下一个结点。
            head = head.next;
            // 如果此时的头结点指向null,说明队列已空,需要将tail指向null.
            if (null == head) {
                tail = null;
            }
    
            return value;
        }
    
        @Override
        public String toString() {
            return "QueueBasedLinkedList{" +
                    "head=" + head +
                    ", tail=" + tail +
                    '}';
        }
    
        private static class Node {
            String item;
            private Node next;
    
            public Node(String item, Node next) {
                this.item = item;
                this.next = next;
            }
    
            public String getItem() {
                return item;
            }
    
            @Override
            public String toString() {
                return "Node{" +
                        "item='" + item + '\'' +
                        ", next=" + next +
                        '}';
            }
        }
    }
    

    测试代码:

        // 空队列
        QueueBasedLinkedList qbll = new QueueBasedLinkedList();
        System.out.println("空队列 " + qbll);
        System.out.println();
    
        // 入队一个数据
        System.out.println("数据入队是否成功:" + qbll.enqueue("0000"));
        System.out.println("入队一个数据后:" + qbll);
        System.out.println();
    
        // 出队一个数据
        System.out.println("出队的数据是:" + qbll.dequeue());
        System.out.println("出队一个数据后:" + qbll);
        System.out.println();
    
        // 异常测试:从空队列中出队,看结果
        System.out.println("出队的数据是1:" + qbll.dequeue());
        System.out.println("出队一个数据后1:" + qbll);
        System.out.println();
    
        // 入队十条数据
        for (int i = 0; i < 10; i++) {
            System.out.println("数据入队是否成功:" + qbll.enqueue("" + i + i + i));
            System.out.println(qbll);
        }
    

    输出结果:符合预期

    空队列 QueueBasedLinkedList{head=null, tail=null}
    
    数据入队是否成功:true
    入队一个数据后:QueueBasedLinkedList{head=Node{item='0000', next=null}, tail=Node{item='0000', next=null}}
    
    出队的数据是:0000
    出队一个数据后:QueueBasedLinkedList{head=null, tail=null}
    
    出队的数据是1:null
    出队一个数据后1:QueueBasedLinkedList{head=null, tail=null}
    
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=null}, tail=Node{item='000', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=null}}, tail=Node{item='111', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=Node{item='222', next=null}}}, tail=Node{item='222', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=Node{item='222', next=Node{item='333', next=null}}}}, tail=Node{item='333', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=Node{item='222', next=Node{item='333', next=Node{item='444', next=null}}}}}, tail=Node{item='444', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=Node{item='222', next=Node{item='333', next=Node{item='444', next=Node{item='555', next=null}}}}}}, tail=Node{item='555', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=Node{item='222', next=Node{item='333', next=Node{item='444', next=Node{item='555', next=Node{item='666', next=null}}}}}}}, tail=Node{item='666', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=Node{item='222', next=Node{item='333', next=Node{item='444', next=Node{item='555', next=Node{item='666', next=Node{item='777', next=null}}}}}}}}, tail=Node{item='777', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=Node{item='222', next=Node{item='333', next=Node{item='444', next=Node{item='555', next=Node{item='666', next=Node{item='777', next=Node{item='888', next=null}}}}}}}}}, tail=Node{item='888', next=null}}
    数据入队是否成功:true
    QueueBasedLinkedList{head=Node{item='000', next=Node{item='111', next=Node{item='222', next=Node{item='333', next=Node{item='444', next=Node{item='555', next=Node{item='666', next=Node{item='777', next=Node{item='888', next=Node{item='999', next=null}}}}}}}}}}, tail=Node{item='999', next=null}}
    

    完整代码请查看

    项目中搜索SingleLinkedList即可。
    github传送门 https://github.com/tinyvampirepudge/DataStructureDemo

    gitee传送门 https://gitee.com/tinytongtong/DataStructureDemo

    参考:
    队列:队列在线程池等有限资源池中的应用

    展开全文
  • 文章目录链队列一.链队的要素二.算法实现 之前写的另一篇文章关于循环队列的: https://blog.csdn.net/qq_44871442/article/details/96639915 链队列 链队列,用链式存储结构来存储队列中的数据元素,一般采用单链表...
  • 主要为大家详细介绍了Java自定义实现链队列的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要介绍了Java定义队列结构,并实现入队、出队操作,结合完整实例形式分析了java数据结构中队列的定义、入队、出队、判断队列是否为空、打印队列元素等相关操作技巧,需要的朋友可以参考下
  • 队列的定义: 队列是一种只允许一端进行插入操作,在另一端进行删除操作的线性表。允许插入的一端称为称为队尾,删除的一段是队头。想象你去排队购买车票时,排着一个很长的队,排在最前面的人买完票走了,这个...
  • mpscilq Java 多生产者单消费者无锁侵入式链接队列 需要 Java 1.6 和 ant 运行测试:蚂蚁测试 运行 Disruptor 测试:ant dtest
  • 队列(queue)是一种特殊的线性表,只允许在表的一端进行插入操作而在另一端进行删除的线性表。进行插入操作的端称为队尾,进行删除操作的一端称为队...它的实现方式主要有顺序队列、链队列两种。   队列的抽象数...
  • 链队列: package queueTest; import linearList.Node; public class LinkQueue implements IQueue { private Node front; private Node rear; public LinkQueue() { front = rear = null; } @...
  • 循环队列和链队列Java

    万次阅读 2020-01-04 13:59:02
    队列:只允许在一端进行插入操作,而在另一端进行删除操作的线性表。 1.循环队列  队列的顺序储存结构:用数组存储队列,引入front指针指向队头元素,rear指针指向队尾元素的下一个位置,当front=rear时,为空...
  • java实现的任务队列

    2019-08-09 01:20:29
    NULL 博文链接:https://noddle0592.iteye.com/blog/2185620
  • 1.顺序队列(循环) 基于数组的循环队列其实很简单,就是当数组满后重置入队和出队位置到数组头部。 public class CircleQueue<E> { // Object保存E,因为E不能E[] --> (E)obj private Object[] items; ...
  • 链队列实现源码,分别用C、C++、JAVA实现。
  • java实现链栈与队列

    2015-04-05 21:59:11
    java实现链栈与顺序表队列。链栈的实现没有什么难点,跟单链表差不多,只是所有的操作只在表头进行,并且没有头节点,使用top标记。关键的操作是push与pop。
  • NULL 博文链接:https://robblog.iteye.com/blog/566114
  • 链队列java实现)

    2014-09-07 19:58:42
    //定义一个内部类Node,Node实例代表链队列的结点 private class Node{ //保存结点的数据 private T data; //指向下一个结点的引用 private Node next; public Node(T data,Node next){ t
  • NULL 博文链接:https://j2ee2009.iteye.com/blog/689161
  • java循环队列之舞会配对问题

    千次阅读 2019-11-16 15:18:51
    利用循环队列模拟舞伴配对问题。在舞会上,男、女各自排成一队。舞会开始时。依次从男队和女队的队头各出一人配成舞伴。如果两队初始人数不等,则较长的那一队中未配对者等待下一轮舞曲。 假设初始男、女人数及性别...
  • java操作redis队列

    千次阅读 2018-12-26 15:48:38
    场景:  1.获取一个实体对象;  2.使用fastjson将实体对象转换为json字符串;  3.将json字符串写入队列  4.从队列中取出json字符串  5.将json字符串转换为对象本例主要jar包: ... 1. 实体类CityBean.java p...
  • Java-实现队列(一)之 链式队列

    千次阅读 2018-07-29 12:42:54
    队列的定义和结构 队列是一种特殊的线性表,其特性体现在队列只允许在表尾插入数据元素,在表头删除元素,所以队列是一种操作受限的线性表,具有先进先出的特点。允许进行插入的一端称为队尾,允许进行删除的一端...
  • java队列

    2019-04-19 01:09:39
    NULL 博文链接:https://hoochiang.iteye.com/blog/1858476
  • 队列--一种具有先进先出特点的数据结构,在我们生活中非常常见。队列可采用数组、链表存储。
  • JAVA多线程19】JAVA 阻塞队列原理

    千次阅读 2019-06-13 00:39:08
    今天我们来讨论另外一类容器:阻塞队列。  非阻塞队列,比如PriorityQueue、LinkedList(LinkedList是双向链表,它实现了Dequeue接口)。  使用非阻塞队列的时候有一个很大问题就是:它不会对当前线程产生阻塞,...
  • Java 优先级队列

    千次阅读 2018-10-13 23:35:01
    队列(queue)是一种先入先出(FIFO)的数据结构。 栈中的插入和移除数据项的命名一般都是Push、Pop,而队列至今...在 Java 中,常见的队列操作以及它们的区别如下所示: 插入 offer 向队列插入元素,在一...
  • 循环队列和链队列的比较
  • Java自定义实现链队列

    2017-11-10 21:33:37
    Java自定义实现链队列 一:写在前面  数据结构中的队列应该是比较熟悉的了,就是先进先出,因为有序故得名队列,就如同排队嘛,在对尾插入新的节点,在对首删除节点.jdk集合框架也是提供也一个Queue的接口.这个接口代表...
  • 数据结构-队列-链队列(Java语言)

    千次阅读 2020-02-01 20:19:48
    详细的代码可见github: ... ...队列一般分为顺序队列以及链队列,本文主要讲述链队列。 所需要实现的接口功能。 package com.company.ch3.queue; public interface IQueue { public void...
  • JAVA双向队列实现(链表)

    千次阅读 2018-10-20 09:40:40
    队列是很常见的一种数据存储结构,今天,介绍下如何用链表实现双向队列。 首先定义节点接口如下: public interface Node&lt;E&gt; { //设置数据元素 public void setData(E o); //获取节点元素 public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,764
精华内容 58,705
关键字:

java链队列

java 订阅