數據結構Java實現07----隊列：順序隊列&順序循環隊列、鏈式隊列、順序優先隊列

一、隊列的概念：

　　隊列（簡稱作隊，Queue）也是一種特殊的線性表，隊列的數據元素以及數據元素間的邏輯關系和線性表完全相同，其差別是線性表允許在任意位置插入和刪除，而隊列只允許在其一端進行插入操作在其另一端進行刪除操作。

隊列中允許進行插入操作的一端稱為隊尾，允許進行刪除操作的一端稱為隊頭。隊列的插入操作通常稱作入隊列，隊列的刪除操作通常稱作出隊列。

下圖是一個依次向隊列中插入數據元素a0,a1,...,an-1后的示意圖：

上圖中，a0是當前 隊頭數據元素，an-1是當前 隊尾數據元素。

為了避免當只有一個元素時，對頭和隊尾重合使得處理變得麻煩，所以引入兩個指針：front指針指向隊頭元素，rear指針指向隊尾元素的下一個位置，這樣的話，當front指針等於rear時，此隊列不是還剩一個元素，而是空隊列。

 

二、隊列的抽象數據類型：

數據集合：

　　隊列的數據集合可以表示為a0,a1,…,an-1，每個數據元素的數據類型可以是任意的類型。

操作集合：

（1）入隊列append(obj)：把數據元素obj插入隊尾。

（2）出隊列delete()：把隊頭數據元素刪除並由函數返回。

（3）取隊頭數據元素getFront()：取隊頭數據元素並由函數返回。

（4）非空否isEmpty()：非空否。若隊列非空，則函數返回false，否則函數返回true。

 

三、循環順序隊列：

線性表有順序存儲和鏈式存儲，隊列是一種特殊的線性表，同樣也存在這兩種存儲方式。我們先來看一下隊列的順序存儲。

1、順序隊列的“假溢出”：

上圖中，front指針指向隊頭元素，rear指針指向隊尾元素的下一個位置。圖(d)中b、c、d出隊后，front指針指向元素e，rear指針在數組外面。假設這個隊列的總個數不超過5個，但目前如果接着入隊的話，因數組末尾元素已經被占用，再向后加就會產生數組越界的錯誤，可實際上隊列在下標為0、1、2、3、4的地方還是空閑的，我們把這種現象叫做“假溢出”。

2、循環順序隊列：

    所以解決假溢出的辦法就是后面滿了，就再從頭開始，也就是頭尾相接的循環。我們把隊列的這種邏輯上首尾相連的順序存儲結構稱為循環隊列。

如何判斷循環隊列究竟是空的還是滿的：

　　現在問題又來了，我們之前說，空隊列時，front指針等於rear指針，那么現在循環隊列滿的時候，也是front等於rear，那么如何判斷循環隊列究竟是空的還是滿的？有如下辦法：

• 辦法1：設置一個標志位flag。初始時置flag=0；每當入隊列操作成功就置flag=1；每當出隊列操作成功就置flag=0。則隊列空的判斷條件為：rear == front && tag==0；隊列滿的判斷條件為：rear = = front && tag= =1。

• 辦法2：保留一個元素的存儲空間。此時，隊列滿時的判斷條件為  (rear + 1) % maxSize == front；隊列空的判斷條件還是front == rear。
• 辦法3：設計一個計數器count，統計隊列中的元素個數。此時，隊列滿的判斷條件為：count > 0 && rear == front ；隊列空的判斷條件為count == 0。

我們在接下來的代碼中采用方法3來實現。

 

3、代碼實現：(循環順序隊列的創建)

(1)Queue.java:(隊列接口)

//隊列接口
public interface Queue {

    //入隊
    public void append(Object obj) throws Exception;

    //出隊
    public Object delete() throws Exception;

    //獲得隊頭元素
    public Object getFront() throws Exception;

    //判斷對列是否為空
    public boolean isEmpty();
}

(2)CircleSequenceQueue.java:（循環順序隊列）

//循環順序隊列
public class CircleSequenceQueue implements Queue {

    static final int defaultSize = 10; //默認隊列的長度
    int front;  //隊頭
    int rear;   //隊尾
    int count;  //統計元素個數的計數器
    int maxSize; //隊的最大長度
    Object[] queue;  //隊列

    public CircleSequenceQueue() {
        init(defaultSize);
    }

    public CircleSequenceQueue(int size) {
        init(size);
    }

    public void init(int size) {
        maxSize = size;
        front = rear = 0;
        count = 0;
        queue = new Object[size];
    }

    @Override
    public void append(Object obj) throws Exception {
        // TODO Auto-generated method stub
        if (count > 0 && front == rear) {
            throw new Exception("隊列已滿！");
        }
        queue[rear] = obj;
        rear = (rear + 1) % maxSize;
        count++;
    }

    @Override
    public Object delete() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("隊列為空！");
        }
        Object obj = queue[front];
        front = (front + 1) % maxSize;
        count--;
        return obj;
    }

    @Override
    public Object getFront() throws Exception {
        // TODO Auto-generated method stub
        if (!isEmpty()) {
            return queue[front];
        } else {
            return null;
        }
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return count == 0;
    }

}

(3)Test.java:

public class Test {
    public static void main(String[] args) throws Exception {

        CircleSequenceQueue queue = new CircleSequenceQueue();
        queue.append("a");
        queue.append("b");
        queue.append("c");
        queue.append("d");
        queue.append("e");
        queue.append("f");

        queue.delete();
        queue.delete();

        queue.append("g");

        while (!queue.isEmpty()) {
            System.out.println(queue.delete());
        }
    }
}

運行效果：

 

 

4、循環隊列應用：

　　使用順序循環隊列和多線程實現一個排隊買票的例子。而且，我們只允許這個隊伍中同時排隊的只有10個人，那就需要用到隊列了。

　　　　生產者（等候買票）

　　　　消費者 (買票離開)

這里面我們需要用到上面的Queue.java類和CircleSequenceQueue.java類。

代碼結構：

(3)WindowQueue.java:

//賣票窗口
public class WindowQueue {

    //賣票的隊列
    int maxSize = 10;
    CircleSequenceQueue queue = new CircleSequenceQueue(maxSize);
    int num = 0; //統計賣票的數量，一天最多賣100張票。
    boolean isAlive = true; //判斷是否繼續賣票。

    //排隊買票
    public synchronized void producer() throws Exception {
        if (queue.count < maxSize) {
            queue.append(num++); //等待買票的數量加1
            System.out.println("第" + num + "個客戶排隊等待買票！");
            this.notifyAll();//喚醒賣票的線程
        } else {
            try {
                System.out.println("隊列已滿...請等待！");
                this.wait();//隊列滿時，排隊買票線程等待。
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    //賣票
    public synchronized void consumer() throws Exception {
        if (queue.count > 0) {
            Object obj = queue.delete();
            int temp = Integer.parseInt(obj.toString());
            System.out.println("第" + (temp + 1) + "個客戶買到票離開隊列！");
            //如果當前隊列為空，並且賣出票的數量大於等於100，說明賣票結束
            if (queue.isEmpty() && this.num >= 100) {
                this.isAlive = false;
            }
            this.notifyAll(); //喚醒排隊買票的線程。
        } else {
            try {
                System.out.println("隊列已空...請等待！");
                this.wait();//隊列空時，賣票線程等待。
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
}

(4)Producer.java:

//買票者
public class Producer implements Runnable {

    WindowQueue queue;

    public Producer(WindowQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (queue.num < 100) {
            try {
                queue.producer();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

}

(5)Consumer.java:

//賣票者
public class Consumer implements Runnable {

    WindowQueue queue;

    public Consumer(WindowQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (queue.isAlive) {
            try {
                queue.consumer();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

}

 (6)test.java:

public class Test {

    public static void main(String[] args) throws Exception {

        WindowQueue queue = new WindowQueue();

        Producer p = new Producer(queue);//注意一定要傳同一個窗口對象
        Consumer c = new Consumer(queue);

        //排隊買票線程
        Thread pThread = new Thread(p);
        //賣票線程
        Thread cThread = new Thread(c);

        pThread.start(); //開始排隊買票
        cThread.start();  //開始賣票
    }

}

注意第07行的注釋。

運行效果：

  

四、鏈式隊列：

    鏈式隊列其實就是特殊的單鏈表，只不過它只能尾進頭出而已。鏈式隊列的存儲結構如下圖所示：

1、鏈式隊列的實現：

(1)Node.java:結點類

//結點類
public class Node {

    Object element; //數據域
    Node next;  //指針域

    //頭結點的構造方法
    public Node(Node nextval) {
        this.next = nextval;
    }

    //非頭結點的構造方法
    public Node(Object obj, Node nextval) {
        this.element = obj;
        this.next = nextval;
    }

    //獲得當前結點的后繼結點
    public Node getNext() {
        return this.next;
    }

    //獲得當前的數據域的值
    public Object getElement() {
        return this.element;
    }

    //設置當前結點的指針域
    public void setNext(Node nextval) {
        this.next = nextval;
    }

    //設置當前結點的數據域
    public void setElement(Object obj) {
        this.element = obj;
    }

    public String toString() {
        return this.element.toString();
    }
}

(2)Queue.java:

//隊列接口
public interface Queue {

    //入隊
    public void append(Object obj) throws Exception;

    //出隊
    public Object delete() throws Exception;

    //獲得隊頭元素
    public Object getFront() throws Exception;

    //判斷對列是否為空
    public boolean isEmpty();
}

(3)LinkQueue.java:

public class LinkQueue implements Queue {

    Node front; //隊頭
    Node rear;  //隊尾
    int count; //計數器

    public LinkQueue() {
        init();
    }

    public void init() {
        front = rear = null;
        count = 0;
    }

    @Override
    public void append(Object obj) throws Exception {
        // TODO Auto-generated method stub
        Node node = new Node(obj, null);

        //如果當前隊列不為空。
        if (rear != null) {
            rear.next = node; //隊尾結點指向新結點
        }

        rear = node; //設置隊尾結點為新結點

        //說明要插入的結點是隊列的第一個結點
        if (front == null) {
            front = node;
        }
        count++;
    }

    @Override
    public Object delete() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            new Exception("隊列已空！");
        }
        Node node = front;
        front = front.next;
        count--;
        return node.getElement();
    }

    @Override
    public Object getFront() throws Exception {
        // TODO Auto-generated method stub
        if (!isEmpty()) {
            return front.getElement();
        } else {
            return null;
        }
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return count == 0;
    }

}

(4)Test.java:

public class Test {

    public static void main(String[] args) throws Exception {

        LinkQueue queue = new LinkQueue();
        queue.append("a");
        queue.append("b");
        queue.append("c");
        queue.append("d");
        queue.append("e");
        queue.append("f");

        queue.delete();
        queue.delete();

        queue.append("g");

        while (!queue.isEmpty()) {
            System.out.println(queue.delete());
        }
    }
}

運行效果：

 

 

2、鏈式隊列的應用：

題目：

　　編寫一個判斷一個字符串是否是回文的算法。

思路：

　　設字符數組str中存放了要判斷的字符串。把字符數組中的字符逐個分別存入一個隊列和棧中，然后逐個出隊和出棧比較出隊的字符與出棧的字符是否相同，若全部相等則該字符串為回文。

代碼實現：

　　這里面需要用到上面一段中的LinkQueue類。代碼結構如下：

(4)Stack.java:棧接口

//棧接口
public interface Stack {

    //入棧
    public void push(Object obj) throws Exception;

    //出棧
    public Object pop() throws Exception;

    //獲得棧頂元素
    public Object getTop() throws Exception;

    //判斷棧是否為空
    public boolean isEmpty();
}

(5)LinkStack.java:

public class LinkStack implements Stack {

    Node head;  //棧頂指針
    int size;  //結點的個數

    public LinkStack() {
        head = null;
        size = 0;
    }

    @Override
    public Object getTop() throws Exception {
        // TODO Auto-generated method stub
        return head.getElement();
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return head == null;
    }

    @Override
    public Object pop() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("棧為空！");
        }
        Object obj = head.getElement();
        head = head.getNext();
        size--;
        return obj;

    }

    @Override
    public void push(Object obj) throws Exception {
        // TODO Auto-generated method stub
        head = new Node(obj, head);
        size++;
    }

}

(6)Test.java:測試類

public class Test {

    public static void main(String[] args) throws Exception {

        String str1 = "ABCDCBA"; //是回文
        String str2 = "ABCDECAB"; //不是回文

        try {
            if (Test.isHuiWen(str1)) {
                System.out.println(str2 + ":是回文！");
            } else {
                System.out.println(str2 + ":不是回文！");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }


    //方法：判斷字符串是否回文
    public static boolean isHuiWen(String str) throws Exception {
        int n = str.length();
        LinkStack stack = new LinkStack();//創建堆棧
        LinkQueue queue = new LinkQueue();//創建隊列
        for (int i = 0; i < n; i++) {
            stack.push(str.subSequence(i, i + 1)); //把字符串每個字符壓進堆棧
            queue.append(str.subSequence(i, i + 1));//把字符串每個字符壓入隊列
        }
        while (!queue.isEmpty() && !stack.isEmpty()) {
            if (!queue.delete().equals(stack.pop())) {  //出隊列，出棧，同時判斷是否相同
                return false;
            }
        }

        return true;
    }

}

  

3、循環隊列和鏈式隊列的比較：

（1）從時間上看，它們的基本操作都是常數時間，即O(1)的。不過循環隊列是事先申請好空間，使用期間不釋放；而鏈式隊列，每次申請和釋放結點也會存在一定的時間開銷，如果入棧和出棧比較頻繁，則兩者還是有細微的差別。

（2）從空間上看，循環隊列必須有一個固定的長度，所以就有了存儲元素個數和空間浪費的問題。而鏈式隊列不存在這個問題，盡管它需要一個指針域，會產生一些空間上的開銷，但也可以接受。所以在空間上，鏈式隊列更加靈活。

總結：總的來說，在可以確定隊列長度的最大值的情況下，建議用循環隊列，如果你無法估計隊列的長度，那就用鏈式隊列。

 

五、優先級隊列：

　　優先級隊列是帶有優先級的隊列。

　　　　用順序存儲結構實現的優先級隊列稱作順序優先級隊列。

　　　　用鏈式存儲結構存儲的優先級隊列稱作鏈式優先級隊列。

順序優先級隊列和順序循環隊列相比主要有兩點不同：

（1）對於順序優先級隊列來說，出隊列操作不是把隊頭數據元素出隊列，而是把隊列中優先級最高的數據元素出隊列。（入隊操作沒區別）

（2）對於順序優先級隊列來說，數據元素由兩部分組成，一部分是原先意義上的數據元素，另一部分是優先級。通常設計優先級為int類型的數值，並規定數值越小優先級越高。

 

1、順序優先隊列的實現：

設計順序優先級隊列分為兩個類：

　　數據元素類

　　優先級隊列類

代碼實現：

(1)Element.java:

//優先級隊列元素類
public class Element {

    private Object element; // 數據
    private int priority; // 優先級

    public Element(Object obj, int priority) {
        this.element = obj;
        this.priority = priority;
    }

    public Object getElement() {
        return element;
    }

    public void setElement(Object element) {
        this.element = element;
    }

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

}

 (2)Queue.java:

//隊列接口
public interface Queue {

    //入隊
    public void append(Object obj) throws Exception;

    //出隊
    public Object delete() throws Exception;

    //獲得隊頭元素
    public Object getFront() throws Exception;

    //判斷對列是否為空
    public boolean isEmpty();
}

(3)PrioritySequenceQueue.java:

//優先級隊列
public class PrioritySequenceQueue implements Queue {

    static final int defaultSize = 10; //默認隊列長度
    int front; //隊頭
    int rear;  //隊尾
    int count;  //計數器
    int maxSize; //隊列最大長度
    Element[] queue; //隊列

    public PrioritySequenceQueue() {
        init(defaultSize);
    }

    public PrioritySequenceQueue(int size) {
        init(size);
    }

    public void init(int size) {
        maxSize = size;
        front = rear = 0;
        count = 0;
        queue = new Element[size];
    }

    @Override
    public void append(Object obj) throws Exception {
        // TODO Auto-generated method stub
        //如果隊列已滿
        if (count >= maxSize) {
            throw new Exception("隊列已滿！");
        }
        queue[rear] = (Element) obj;
        rear++;
        count++;
    }

    @Override
    public Object delete() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("隊列為空！");
        }
        //默認第一個元素為優先級最高的。
        Element min = queue[0];
        int minIndex = 0;
        for (int i = 0; i < count; i++) {
            if (queue[i].getPriority() < min.getPriority()) {
                min = queue[i];
                minIndex = i;
            }
        }

        //找的優先級別最高的元素后，把該元素后面的元素向前移動。
        for (int i = minIndex + 1; i < count; i++) {
            queue[i - 1] = queue[i]; //移動元素
        }
        rear--;
        count--;
        return min;
    }

    @Override
    public Object getFront() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("隊列為空！");
        }
        //默認第一個元素為優先級最高的。
        Element min = queue[0];
        int minIndex = 0;
        for (int i = 0; i < count; i++) {
            if (queue[i].getPriority() < min.getPriority()) {
                min = queue[i];
                minIndex = i;
            }
        }
        return min;
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return count == 0;
    }

}

2、代碼測試：

　　設計一個程序模仿操作系統的進程管理問題。進程服務按優先級高的先服務，優先級相同的先到先服務的原則管理。

　　模仿數據包含兩個部分：進程編號和優先級。如下有五個進程：

　　　　1      30

　　　　2      20

　　　　3      40

　　　　4      20

　　　　5      0       ----------優先級最高，先服務

(4)Test.java:

public class Test {

    public static void main(String[] args) throws Exception {

        PrioritySequenceQueue queue = new PrioritySequenceQueue();
        Element temp;

        //五個進程入隊
        queue.append(new Element(1, 30));
        queue.append(new Element(2, 20));
        queue.append(new Element(3, 40));
        queue.append(new Element(4, 20));
        queue.append(new Element(5, 0));

        //按照優先級出隊。
        System.out.println("編號  優先級");
        while (!queue.isEmpty()) {
            temp = (Element) queue.delete();
            System.out.println(temp.getElement() + " " + temp.getPriority());
        }
    }
}

運行效果：