精华内容
下载资源
问答
  • 主要介绍了java实现队列数据结构代码详解,简单介绍了队列结构以应用场景,涉及详细实现代码,还是比较不错的,这里分享给大家,需要的朋友可以参考下。
  • 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

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

    展开全文
  • 本文主要介绍了两种java实现消息队列的方式,利用Spring消息模板发送消息和Apache ActiveMQ官方实例发送消息,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java实现的任务队列

    2019-08-09 01:20:29
    NULL 博文链接:https://noddle0592.iteye.com/blog/2185620
  • JAVA实现队列

    千次阅读 2019-02-24 19:22:54
    本文使用java中的数据和列表来实现队列类,从而更加详细和直观的理解队列的使用和性质。 1、使用数组实现队列 public class QueueWithArray { private int [] queueArray; private int front ...

    和栈一样,队列也是线性的集合。对于队列来说,插入限制在一端,也就是队尾,删除限制在另一端,也就是对头。队列支持先进先出的协议。

    本文使用java中的数据和列表来实现队列类,从而更加详细和直观的理解队列的使用和性质。

    1、使用数组实现队列

    public class QueueWithArray {
    	private int [] queueArray;
    	private int front = 0;
    	private int rear = 0;
    	
    	public QueueWithArray() {
    		this(5);
    	}
    	
    	public QueueWithArray(int queueSize) {
    		queueArray = new int [queueSize];
    	} 
    	
    	public void push(int element) {
    		if (rear >= front && rear < queueArray.length - 1) {
    			queueArray [rear ++] = element;
    		}
    		else if(rear == queueArray.length - 1 && front == 0) {
    			int [] tempArray = new int [queueArray.length * 2];
    			System.arraycopy(queueArray, 0, tempArray, 0, queueArray.length);
    			queueArray [rear ++] = element;
    		}
    		else if (front > 0 && rear == queueArray.length - 1) {
    			queueArray [rear] = element;
    			rear = 0;
    		}
    		else if (rear < front - 1) 
    			queueArray [rear ++ ] = element;
    		else if (rear < front && rear == front - 1) {
    			loopArrayCopy();
    			queueArray [rear ++] = element;
    		}
    	}
    	
    	public int pop() {
    		if (front == queueArray.length - 1) {
    			int reasult = queueArray [front];
    			front = 0;
    			return reasult;
    		}
    		else if (front == rear - 1) {
    			int reasult = queueArray [front];
    			front = 0;
    			rear = 0;
    			return reasult;
    		}
    		else
    			return queueArray [front ++];
    	}
    	
    	public int peek() {
    		return queueArray [front];
    	}
    	
    	public boolean isEmpty() {
    		return front == 0 && rear == 0;
    	}
    	
    	public int getSize() {
    		if (front < rear)
    			return rear - front;
    		else if (front > rear) {
    			int frontNumber = queueArray.length - front;
    			int rearNumber = rear;
    			return frontNumber + rearNumber;
    		}
    		else
    			return 0;
    	}
    	
    	private void loopArrayCopy() {
    		int [] tempArray = new int [queueArray.length * 2];
    		System.arraycopy(queueArray, front, tempArray, 0, queueArray.length - front);
    		System.arraycopy(queueArray, 0, tempArray, queueArray.length - front, rear);
    		front = 0;
    		rear = queueArray.length - 1;
    		queueArray = tempArray;
    	}
    	
    	public void clear() {
    		rear = 0;
    		front = 0;
    	}
    	
    	@Override
    	public String toString() {
    		String s = " ";
    		if (front < rear) {
    			for (int index = front; index < rear; index ++) 
    				s += (Integer.toString(queueArray [index]) + " ");
    			return s;
    		}
    		else if (front > rear) {
    			for (int index = front; index < queueArray.length; index ++)
    				s += (Integer.toString(queueArray [index]) + " ");
    			for (int index = 0; index < rear; index ++) 
    				s += (Integer.toString(queueArray [index]) + " ");
    			return s;
    		}
    		else
    			return "The queue is empty";
    			
    	}
    }

    为了验证类的正确性下面提供验证程序

    
    public class TestQueueWithArray {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		QueueWithArray queue = new QueueWithArray(4);
    		queue.push(1);
    		queue.push(2);
    		int a = queue.pop();
    		System.out.println(a);
    		System.out.println(queue.toString());
    		queue.push(3);
    		queue.push(4);
    		queue.push(5);
    		System.out.println(queue.getSize());
    		queue.push(6);
    		System.out.println(queue.getSize());
    		System.out.println(queue.toString());
    		queue.clear();
    		System.out.println(queue.isEmpty());
    	}
    
    }
    

    2、使用列表实现队列

    import java.util.ArrayList;
    
    public class QueueWithList {
    	private ArrayList<Integer> queueList= new ArrayList<>();
    	public QueueWithList() {
    		
    	}
    	
    	public void add(int number) {
    		queueList.add(number);
    	}
    	
    	public int pop() {
    		int number = queueList.remove(0);
    		return number;
    	}
    	
    	public int peek() {
    		return queueList.get(0);
    	}
    	
    	public boolean isEmpty() {
    		return queueList.isEmpty();
    	}
    	
    	public int len() {
    		return queueList.size();
    	}
    	
    	public void clear() {
    		queueList.clear();
    	}
    	@Override
    	public String toString() {
    		String s = "";
    		for (int index = 0; index < queueList.size(); index ++ ) {
    			if (index < queueList.size() - 1) 
    				s += (Integer.toString(queueList.get(index)) + " ");
    			else
    				s += Integer.toString(queueList.get(index));
    		}
    		return s;
    	}
    }
    

    测试程序:

    
    public class TestQueue {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		QueueWithList queue = new QueueWithList();
    		queue.add(1);
    		queue.add(2);
    		System.out.println(queue.toString());
    		int a = queue.peek();
    		System.out.println(a);
    		System.out.println(queue.toString());
    		System.out.println(queue.len());
    		queue.clear();
    		System.out.println(queue.isEmpty());
    	}
    	
    }
    

     

    展开全文
  • 1、Java实现队列(Queue)的方式

    万次阅读 多人点赞 2018-08-28 22:37:14
    1.请用Java实现队列(Queue)。 队列实现的三种方式: (1)通过数组实现一个队列; (2)通过集合实现一个对列; (3)通过两个堆栈实现一个队列。 示例代码: (1)通过数组实现一个队列: package ...

    编程题目:

    1.请用Java实现队列(Queue)。

    队列实现的三种方式:

    (1)通过数组实现一个队列;

    (2)通过集合实现一个对列;

    (3)通过两个堆栈实现一个队列。

    示例代码:

    (1)通过数组实现一个队列:

    package program.stack.arrayImpl;
    
    /**
    * 1.使用数组实现队列功能,使用int数组保存数据特点:先进先出,后进后出
    */
    
    public class QueueTest1 {  
        public static void main(String[] args){  
    
            //测试队列
            System.out.println("测试队列:");
            Queue queue = new Queue();  
            queue.in(1);  
            queue.in(2);  
            queue.in(3);  
            System.out.println(queue.out()); 
            System.out.println(queue.out()); 
            queue.in(4);  
            System.out.println(queue.out());  
            System.out.println(queue.out());  
            queue.in(5);  
            System.out.println(queue.out()); 
    
        }  
    }  
    
    //使用数组定义一个队列
    class Queue {  
    
        int[] a = new int[5];  
        int i = 1; //数组下标
    
        //入队
        public void in(int m){  
           a[i++] = m;
        } 
    
        //出队
        public int out(){  
           int index = 0;  
           int temp = a[1];  
           for(int j=1;j<i;j++){  
             a[j-1] = a[j];  
             index++;  
           }  
           i = index;  
           return temp;  
        }  
    } 

    (2)通过集合实现一个对列:

    package program.stack.listImpl;
    
    import java.util.*;
    
    /**
    * 2.使用集合实现队列功能,使用int数组保存数据特点:先进先出,后进后出
    */
    
    public class QueueTest2 {  
        public static void main(String[] args){  
    
            //测试队列
            System.out.println("测试队列:");
            Queue queue = new Queue();  
            queue.in(1);  
            queue.in(2);  
            queue.in(3);  
            System.out.println(queue.out()); 
            System.out.println(queue.out()); 
            queue.in(4);  
            System.out.println(queue.out());  
            System.out.println(queue.out());  
            queue.in(5);  
            System.out.println(queue.out()); 
    
        }  
    }  
    
    //使用集合定义一个队列
    class Queue {  
    
        List<Integer> list = new ArrayList<Integer>();  
        int index = 0;  //下标
    
        //入队
        public void in(int n){  
            list.add(n);  
            index++;  
        } 
    
        //出队
        public int out(){  
           if(!list.isEmpty()){  
               index--;  
               return list.remove(0);  
           }  
           return -1;  
        }  
    
    }  

    (3)通过两个堆栈实现一个队列:

    package program.stack.twoStackImpl;
    
    import java.util.Stack;
    
    /**
     * 3.两个堆栈实现一个队列
     *  1.原理分析:
     *  队列的主要操作有两个:入队操作和出队操作,出队时从队头出,入队是从队尾插入,
     *  入队的操作和入栈的操作类似,而最关键的问题是出队操作,要出队列的是队列的第一个元素,
     *  而出栈的是栈的栈顶元素,所以我们可以这样:
     *  假设两个栈A和栈B,A主要用来处理入队操作,B用于处理出队操作。入队操作和入栈操作类似,
     *  直接将元素压入栈即可。出队的时候,实现我们假设栈B为空,则要把栈A的第一个元素(即栈底元素)弹出,
     *  直接从A弹出这是不可能的,但如果我们把栈A里面的元素的顺序逆过来,这样直接用栈弹出栈顶元素即可,
     *  所以我们可以把栈A的元素全部弹出来,并俺顺序压入栈B中,这样每次栈B弹出的栈顶元素就是栈A相对应的栈底元素,就是出队操作。
     *  若B不为空,则代表之前从A复制过来的元素还没有完全弹出,要出栈的时候直接弹出即可。若栈B的元素都弹出来了,就需要从A中补充。
     *
     *  2.总结操作就是:    
     *  入队:将元素进栈A
     *  出队:判断栈B是否为空,如果为空,则将栈A中所有元素pop,并push进栈B,栈B出栈;如果不为空,栈B直接出栈。
     *
     */
    
    public class QueueTest3 {
         public static void main(String[] args) {
    
             System.out.println("3.两个堆栈实现一个队列:");
             Queue queue = new Queue();  
             queue.in(1);  
             queue.in(2);  
             queue.in(3);  
             System.out.println(queue.out()); 
             System.out.println(queue.out()); 
             queue.in(4);  
             System.out.println(queue.out());  
             System.out.println(queue.out());  
             queue.in(5);  
             System.out.println(queue.out()); 
    
        }
    
    }
    
    //两个堆栈实现一个队列
    class Queue {
    
        Stack<Integer> stackA = new Stack<Integer>();
        Stack<Integer> stackB = new Stack<Integer>();
    
        //入队
        public void in(int n) {
            stackA.push(n);
        }
    
        //出队
        public int out() {
            if(stackB.isEmpty()){
                while (stackA.size() > 0) {
                    stackB.push(stackA.pop());
                }
            }
            return stackB.pop();
        }
    
    }

    结果显示:

    这里写图片描述
    这里写图片描述
    这里写图片描述

    展开全文
  • Java实现二叉树,Java实现队列.pdf
  • 主要介绍了JAVA 实现延迟队列的方法,文中讲解非常详细,供大家参考和学习,感兴趣的朋友可以了解下
  • Java实现简单的阻塞队列2种方式,1使用wait(),notify();2使用countdownlatch实现
  • 主要介绍了Java定义队列结构,并实现入队、出队操作,结合完整实例形式分析了java数据结构中队列的定义、入队、出队、判断队列是否为空、打印队列元素等相关操作技巧,需要的朋友可以参考下
  • 本篇文章主要介绍了Java消息队列的简单实现代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java实现队列的入队和出队方法

    千次阅读 2021-02-25 19:18:27
    java实现队列的入队和出队方法发布时间:2020-06-23 23:09:30来源:亿速云阅读:245作者:Leah这篇文章运用简单易懂的例子给大家介绍java实现队列的入队和出队方法,代码非常详细,感兴趣的小伙伴们可以参考借鉴,...

    java实现队列的入队和出队方法

    发布时间:2020-06-23 23:09:30

    来源:亿速云

    阅读:245

    作者:Leah

    这篇文章运用简单易懂的例子给大家介绍java实现队列的入队和出队方法,代码非常详细,感兴趣的小伙伴们可以参考借鉴,希望对大家能有所帮助。

    首先要定义几个变量与数组:

    a:表示队列的数组

    rear:表示队列尾,这里初始化为0

    (入队一个元素下标就往后移动一位)

    front:表示队列头,同样初始化为0

    (出队一个元素下标就往后移动一位)

    maxsize:最大下标,这里初始化为4,但是队列只能存放3个。(队列的长度加一)

    这里数组预留出的一个位置用来判断队列的空或满。

    参考下面的图方便理解:

    此时元素个数为3已经是满了的,因为数组个数是有效的元素个数加一。

    注:元素下标只能为0——3

    代码如下://数据结构——队列

    import java.util.Scanner;

    public class Queue {

    int[] a ;

    int rear;

    int front;

    int maxsize;

    public static void main(String[] args) {

    Queue queue = new Queue();

    Scanner scan = new Scanner(System.in);

    int i;

    do {

    System.out.println("请输入:1入队 2出队 3查看 0退出");

    i = scan.nextInt();

    switch(i) {

    case 1:

    System.out.println("请输入要入队的元素:");

    queue.addQueue(scan.nextInt());

    break;

    case 2:

    queue.exitQueue();

    break;

    case 3:

    queue.showqueue();

    break;

    }

    }while(i!=0);

    System.out.println("退出成功");

    }

    //构造函数

    public Queue(){

    a = new int[4];

    rear = 0;

    front = 0;

    maxsize = 4;

    }

    //判断队列是否为空

    public boolean judgeNull() {

    return rear == front;

    }

    //判断队列是否已满

    public boolean judgeFull() {

    return (rear+1) % maxsize == front;

    }

    //入队

    public void addQueue(int num) {

    //判断,若队列已满则结束,不满则将其添加

    if(judgeFull()) {

    System.out.println("队列已满");

    return ;

    }

    a[rear] = num;

    rear = (rear+1) % maxsize;

    }

    //出队

    public void exitQueue() {

    //判断,若队列为空则结束,非空则将其最前的元素取出

    if(judgeNull()) {

    System.out.println("队列为空");

    return ;

    }

    front = (front+1) % maxsize;

    }

    //显示队列的元素

    public void showqueue() {

    if(judgeNull()) {

    System.out.println("队列为空");

    return ;

    }

    for (int i = front; i < front+count(); i++) {

    System.out.printf("a[%d] = %d\n",i%maxsize,a[i%maxsize]);

    }

    }

    //求出队列的有效个数

    public int count() {

    return (rear+maxsize-front)%maxsize;

    }

    }

    关于java实现队列的入队和出队方法就分享到这里了,希望以上内容可以对大家有一定的帮助,可以学到更多知识。如果觉得文章不错,可以把它分享出去让更多的人看到。

    展开全文
  • Java优先队列实现

    2018-10-31 17:14:16
    数据结构与算法第六章,优先队列,heap_maximum 返回优先队列的最大值 heap_extract_max 删除并返回最大值 max_heap_insert插入值为key的元素进优先队列中 。
  • 本篇文章主要介绍了Java利用Redis实现消息队列的示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 下面小编就为大家分享一篇java队列实现方法(顺序队列,链式队列,循环队列),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • java队列实现(顺序队列、链式队列、循环队列
  • java队列模拟实现

    2013-01-06 18:00:25
    这是一个java队列实现的全部工程文件,包含了所有代码,具体的设计文档在上传的另外文件中。这个工程能够实现所有队列的操作,运行没有问题。设计的是在应用程序上的基于界面的队列操作的实现
  • 队列在计算机术语中使用queue,和list(排)其实是一个意思。队列也是一种数据结构,类似于栈,只是与栈相反,在队列中先...  下面用Java实现队列的基本功能(数组版)。 package cn.zhf.list; public class MyQueu
  • 下面小编就为大家分享一篇基于Java数组实现循环队列的两种方法小结,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Java队列实现

    万次阅读 多人点赞 2017-09-19 11:42:26
    一、队列简单介绍队列是一种常用的数据结构之一,与...二、队列实现队列有很多种,这里只是介绍最基本的实现,采用链式存储,也就是链式队列,与之前的链表存储形式一样,通过结点对象描述一个数据,结点对象包含具体数
  • 主要介绍了java数组实现队列及环形队列实现过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • NULL 博文链接:https://j2ee2009.iteye.com/blog/689161
  • 使用java自己实现一个队列

    千次阅读 2020-03-15 11:42:25
    大家好,今天和大家分享一个自定义队列实现,这也是很多面试中,容易问到,或者直接让大家写的一个题目。围绕这个题目,那么我们首先需要分析如何实现,那就要结合队列的特点。队列这种数据结构的特点我想大家肯定...
  • 主要介绍了剖析Java中阻塞队列实现原理及应用场景,这里也对阻塞和非阻塞队列的不同之处进行了对比,需要的朋友可以参考下
  • 队列是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,只允许在表的后端(rear)进行插入操作,下面介绍一下java使用数组和链表实现队列的示例
  • 队列实现,数据结构作业练习参考,Java实现,环境eclipes1.8
  • 主要介绍了Java 队列实现原理及简单实现代码的相关资料,需要的朋友可以参考下
  • 主要介绍了java阻塞队列实现原理及实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 458,719
精华内容 183,487
关键字:

java实现队列

java 订阅
友情链接: qn8035.zip