鏈隊列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]