链队列java实现,JAVA的队列

本文目录一览：

• 1、怎么编写一个简单的java队列?
• 2、JAVA里链队怎么移动指针
• 3、java中的队列用什么实现
• 4、求用Java的LinkedList类创建一个链队列（LinkedQueue）类
• 5、java：编写数据访问接口，再分别以堆栈和队列的形式实现

怎么编写一个简单的java队列?

import java.util.*;

public class MyQueueT {

private LinkedListT list = new LinkedListT();

public void addLast(T v) {

list.addLast(v); //队尾插入

}

public T getFirst() {

return list.getFirst(); //取得队受元素

}

public void remove() {

list.removeFirst(); //移除队首元素

}

//类似功能自己扩展下

public static void main(String[] args) {

MyQueueString mq = new MyQueueString();

mq.addLast(“hello world”);

mq.addLast(“hello world2”);

System.out.println(mq.getFirst());

mq.remove();

System.out.println(mq.getFirst());

}

}

JAVA里链队怎么移动指针

循环条件或者判断语句。

为了和队列的定义保持一致，所以要指明尾指针，链式队列只是队列的一种实现方式，还要把握住队列的本质，至于尾指针指向是尾结点还是尾结点的下一个结点，这个只是实现的一点区别，没有强制的要求。要根据自己的具体实现选择，不同的应用这两种会有些微小的区别，比如循环条件，判空等。

判断依据是根据栈和堆解决，栈是后进先出，用链表的话在头部操作即可，没必要再加个尾指针，队列是先进先出，头尾都要有指针记忆位置，但是循环链表的话，尾节点的下一个便是头结点，所以只要有个尾指针即可，头指针省略不用。

java中的队列用什么实现

队列的实现单纯的是数据结构的问题，既可以用链表结构实现队列，也可以用数组实现。这和语言不是紧密关系，java可以这样实现，C、C++ 也可以。

求用Java的LinkedList类创建一个链队列（LinkedQueue）类

LinkedQueue类代码：

import java.util.LinkedList;

public class LinkedQueue {

private LinkedList list;

private LinkedQueue() {

}

public LinkedQueue(LinkedList list) {

this.list = list;

}

//入队

public void add(Object obj) {

this.list.add(obj);

}

//获取队关元素

public Object get() {

return this.list.getFirst();

}

//出队

public void next() {

this.list.removeFirst();

}

//判定为空

public boolean isEmpty() {

return this.list.isEmpty();

}

//获取当前列队长度

public int size() {

return this.list.size();

}

}

测试类代码：

import java.util.LinkedList;

public class Test {

public static void main(String[] args) {

LinkedList list = new LinkedList();

list.add(“no1”);

list.add(“2”);

list.add(“215”);

//获取初始linkedqueue;

LinkedQueue lq = new LinkedQueue(list);

System.out.println(“获取队头元素 ： ” + lq.get());

lq.add(“add”);

System.out.println(“入队后队列长度：： ” + lq.size());

lq.next();

System.out.println(“出队队列长度 ： ” + lq.size());

System.out.println(“出队后队头元素 ： ” + lq.get());

System.out.println(“判定为空 ： ” + lq.isEmpty());

}

}

java：编写数据访问接口，再分别以堆栈和队列的形式实现

链队列的定义：

队列的链式存储结构简称为链队列。它是限制仅在表头删除和表尾插入的单链表。

链队列的数据存储形式：

链队列基本运算的实现：

[java] view plain copy

package study_02.datastructure.queue;

/**

* 链队列

* @author WWX

*/

public class LinkQueueT {

//链的数据结构

private class Node{

public T data;

public Node next;

//无参构造函数

public Node(){}

public Node(T data,Node next){

this.data=data;

this.next=next;

}

}

//队列头指针

private Node front;

//队列尾指针

private Node rear;

//队列长度

private int size=0;

public LinkQueue(){

Node n=new Node(null,null);

n.next=null;

front=rear=n;

}

/**

* 队列入队算法

* @param data

* @author WWX

*/

public void enqueue(T data){

//创建一个节点

Node s=new Node(data,null);

//将队尾指针指向新加入的节点，将s节点插入队尾

rear.next=s;

rear=s;

size++;

}

/**

* 队列出队算法

* @return

* @author WWX

*/

public T dequeue(){

if(rear==front){

try {

throw new Exception(“堆栈为空”);

} catch (Exception e) {

e.printStackTrace();

}

return null;

}else{

//暂存队头元素

Node p=front.next;

T x=p.data;

//将队头元素所在节点摘链

front.next=p.next;

//判断出队列长度是否为1

if(p.next==null)

rear=front;

//删除节点

p=null;

size–;

return x;

}

}

/**

* 队列长队

* @return

* @author WWX

*/

public int size(){

return size;

}

/**

* 判断队列是否为空

* @return

* @author WWX

*/

public boolean isEmpty(){

return size==0;

}

public String toString() {

if(isEmpty()){

return “[]”;

}else{

StringBuilder sb = new StringBuilder(“[“);

for(Node current=front.next;current!=null;current=current.next){

sb.append(current.data.toString() + “, “);

}

int len = sb.length();

return sb.delete(len – 2, len).append(“]”).toString();

}

}

//测试

public static void main(String[] args) {

LinkQueueInteger queue=new LinkQueueInteger();

queue.enqueue(1);

queue.enqueue(2);

queue.enqueue(3);

queue.enqueue(4);

queue.enqueue(5);

queue.enqueue(6);

System.out.println(queue);

System.out.println(“出队：”+queue.dequeue());

System.out.println(“队列长度=”+queue.size());

System.out.println(queue);

System.out.println(“出队：”+queue.dequeue());

System.out.println(“队列长度=”+queue.size());

System.out.println(queue);

System.out.println(“出队：”+queue.dequeue());

System.out.println(“队列长度=”+queue.size());

System.out.println(queue);

}

}

输出结果：

[1, 2, 3, 4, 5, 6]

出队：1

队列长度=5

[2, 3, 4, 5, 6]

出队：2

队列长度=4

[3, 4, 5, 6]

出队：3

队列长度=3

[4, 5, 6]