Stack, Queue and Priority Queue

　　In comparison with Dynamic Sets such as BST and Hash Table, Stack, Queue and Priority Queue are relatively simple abstract data types. Albeit their easy implementation in coding, their importance can never be overlooked.

1. Stack

　　A Stack conforms to the principle of First-In, Last-Out (FILO). Here is a Stack based on Single-Linked List.

class Stack<T> {
    private class Node<T> {
        public Node<T> next;
        public T data;
    }
    
    private Node<T> head;
    
    public Stack() {
        head = new Node<T>();
    }
    public void push(T item) {
        // Add an item to the top of the stack
        Node<T> top = new Node<T>();
        top.data = item;
        top.next = head.next;
        head.next = top;
    }
    public boolean isEmpty() {
        // Return whether the stack is empty
        return head.next==null;
    }
    public T peek() {
        // Return the top item of the stack
        if (head.next==null) {
            throw new RuntimeException("Stack Underflow");
        } else {
            return head.next.data;
        }
    }
    public T pop() {
        // Extract the top item of the stack
        if (head.next==null) {
            throw new RuntimeException("Stack Underflow");
        } else {
            T val = head.next.data;
            head.next = head.next.next;
            return val;
        }
    }
}

2. Queue

　　Instead of adopting FILO principle, a Queue adheres to the principle of First-In, First-Out (FIFO).

class Queue<T> {
    private class Node<T> {
        public Node<T> next;
        public T data;
    }
    
    private Node<T> head, tail;
    
    public Queue() {
        head = new Node<T>();
        tail = head;
    }
    public void add(T item) {
        // Enqueue a new item
        tail.next = new Node<T>();
        tail = tail.next;
        tail.data = item;
    }
    public boolean isEmpty() {
        // Return whether the queue is empty
        return head==tail;
    }
    public T peek() {
        // Return the head of the queue
        if (head==tail) {
            throw new RuntimeException("Queue Underflow");
        } else {
            return head.next.data;
        }
    }
    public T poll() {
        // Dequeue an item from the queue
        if (head==tail) {
            throw new RuntimeException("Queue Underflow");
        } else {
            T val = head.next.data;
            if (head.next==tail) {
                tail = head;
            }
            head.next = head.next.next;
            return val;
        }
    }
}

3. Priority Queue

　　Here I shall provide a Min-Priority Queue based on a Binary Heap.

class MinPriorityQueue<T extends Comparable> {
    private T[] items;        // data of heap items
    private int len;            // current length
    private int size;        // size of space
    
    public MinPriorityQueue(int size) {
        if (size<=0) {
            throw new RuntimeException("Illegal Initial Size");
        } else {
            this.size = size;
            items = (T[]) new Comparable[size];
        }
    }
    public void add(T item) {
        // Add a new item to the priority queue
        if (len==size) {
            doubleSize();
        }
        items[len++] = item;
        sift_up(len-1);
    }
    private void doubleSize() {  
        // Double the space size when it's filled up  
        if ((size<<1)<0) {  
            throw new RuntimeException("Size Expansion Failed");  
        } else {  
            T[] tmp = items;  
            items = (T[]) new Comparable[size<<1];  
            for (int i=0;i<len;i++) {  
                items[i] = tmp[i];  
            }  
            size <<= 1;  
        }  
    }  
    public boolean isEmpty() {
        // Return whether the priority queue is empty
        return len==0;
    }
    public T poll() {
        // Extract the head of the priority queue
        if (len==0) {
            return null;
        } else {
            T val = items[0];
            items[0] = items[--len];
            sift_down(0);
            return val;
        }
    }
    public T peek() {
        // Return the head of the priority Queue
        if (len==0) {
            return null;
        } else {
            return items[0];
        }
    }
    private void sift_up(int i) {
        // Adjustment made when items[i] is excessively small
        //                in terms of its current position
        int j = ((i-1)>>1);
        if (j<i && items[i].compareTo(items[j])<0) {
            T tmp = items[i];
            items[i] = items[j];
            items[j] = tmp;
            sift_up(j);
        }
    }
    private void sift_down(int i) {
        // Adjustment made when items[i] is excessively large
        //                in terms of its current position
        int j = (i<<1)+1, k = (i<<1)+2, idx = i;  
        if (j<len) {  
            if (items[idx].compareTo(items[j])>0) {  
                idx = j;  
            }  
            if (k<len&&items[idx].compareTo(items[k])>0) {  
                idx = k;  
            }  
            if (idx>i) {  
                T tmp = items[i];  
                items[i] = items[idx];  
                items[idx] = tmp;  
                sift_down(idx);  
            }  
        }  
    }
}