java语言实现的队列

队列特点：

队列的特点是先进先出。

最简单的代码实现:

首先需要一个存放数据的容器，这里我们使用list。其次需要一个游动的指针。

代码实现

class Queue {
    // 用于存放队列中元素的容器
    private List<Integer> data;         
    // 一个游动的初始位置的指针
    private int p_start;            
    public Queue() {
        data = new ArrayList<Integer>();
        p_start = 0;
    }
    /** 
     * 往队列添加元素，如果添加成功，返回true
     */
    public boolean enQueue(int x) {
        data.add(x);
        return true;
    };   
    /** 
     * 删除队列中的元素，如果添加成功，返回true
     */
    public boolean deQueue() {
        if (isEmpty() == true) {
            return false;
        }
        p_start++;
        return true;
    }
    /** 
     * 获取队列中的下一元素
     */
    /** Get the front item from the queue. */
    public int Front() {
        return data.get(p_start);
    }
    /** 
     * 判断队列是否为空
     */
    public boolean isEmpty() {
        return p_start >= data.size();
    }     
};

public class Main {
    public static void main(String[] args) {
        MyQueue q = new MyQueue();
        q.enQueue(5);
        q.enQueue(3);
        if (q.isEmpty() == false) {
            System.out.println(q.Front());
        }
        q.deQueue();
        if (q.isEmpty() == false) {
            System.out.println(q.Front());
        }
        q.deQueue();
        if (q.isEmpty() == false) {
            System.out.println(q.Front());
        }
    }
}

观察上面的代码，我们会发现，它创建了一个list集合，但是它只是一直添加元素，并没有真正意义上的删除。所以会严重浪费硬件资源。

优化：

为了节省资源，我们需要使用循环队列。我们可以使用一个集合，和两个指针来指示起始位置和结束位置。目的就是重用被浪费的存储

循环队列代码示例：

循环队列是一种线性数据结构，他的操作基于FIFO（先进先出）原则，队尾被连接在队首之后以形成一个循环。队列的好处就是可以利用这个队列之前用过的空间。我们能使用这些用过的空间去存储新值

实现以下操作：

CircularQueue(k): 构造器，设置队列长度为 k 。 Front: 从队首获取元素。如果队列为空，返回 -1 。 Rear: 获取队尾元素。如果队列为空，返回 -1 。 enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。 deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。 isEmpty(): 检查循环队列是否为空。 isFull(): 检查循环队列是否已满。

代码参考：

class CircularQueue {
    //创建一个数组，用来存放队列中的元素
    private int[] data;
    //头指针
    private int head;
    //尾指针
    private int tail;
    //创建数组容量的大小
    private int size;

    /**
     * 初始化队列容器，队列的容量为m
     */
    public CircularQueue(int m) {
        data = new int[k];
        head = -1;
        tail = -1;
        size = m;
    }
    
    /**
     * 向循环队列中插入一个元素，如果插入成功，返回true
     */
    public boolean enQueue(int value) {
        if (isFull() == true) {
            return false;
        }
        if (isEmpty() == true) {
            head = 0;
        }
        tail = (tail + 1) % size;
        data[tail] = value;
        return true;
    }
    
    /**
     * 删除循环队列容器中元素，如果操作成功，返回true
     */
    public boolean deQueue() {
        if (isEmpty() == true) {
            return false;
        }
        if (head == tail) {
            head = -1;
            tail = -1;
            return true;
        }
        head = (head + 1) % size;
        return true;
    }
    
    /** 获取队列中队首的元素 */
    public int Front() {
        if (isEmpty() == true) {
            return -1;
        }
        return data[head];
    }
    
    /** 获取队列中最后一个元素 */
    public int Rear() {
        if (isEmpty() == true) {
            return -1;
        }
        return data[tail];
    }
    
    /** 判断队列是否是空 */
    public boolean isEmpty() {
        return head == -1;
    }
    
    /** 判断队列是否已满 */
    public boolean isFull() {
        return ((tail + 1) % size) == head;
    }
}

java中提供的内置队列库

public class QueueTest {
    public static void main(String[] args) {
        // 初始化队列
        Queue<Integer> queue = new LinkedList();
        // 获取队列中第一个元素 - 如果队列是空返回null
        System.out.println("The first element is: " + queue.peek());
        // 向队列中添加元素
        queue.offer(5);
        queue.offer(13);
        queue.offer(8);
        queue.offer(6);
        // 从队列中删除元素
        queue.poll();
        // 获取队列中第一个元素
        System.out.println("The first element is: " + queue.peek());
        // 获取队列容量的大小
        System.out.println("The size is: " + queue.size());
    }
}

java语言实现的栈

栈的特点：

栈的特点是先进后出（LIFO）

栈代码示例：

class Stack {
    //存放元素的容器
    private List<Integer> data;               
    public Stack() {
        data = new ArrayList<>();
    }
    /** 向栈中添加元素 */
    public void push(int x) {
        data.add(x);
    }
    /** 判断栈是否是空 */
    public boolean isEmpty() {
        return data.isEmpty();
    }
    /** 获取栈顶的元素 */
    public int top() {
        return data.get(data.size() - 1);
    }
    /** 删除栈中的元素. 如果操作成功，返回true. */
    public boolean pop() {
        if (isEmpty()) {
            return false;
        }
        data.remove(data.size() - 1);
        return true;
    }
};

public class Test {
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        for (int i = 0; i < 4; ++i) {
            if (!stack.isEmpty()) {
                System.out.println(stack.top());
            }
            System.out.println(stack.pop());
        }
    }
}

java中内置的栈库

public class Test {
    public static void main(String[] args) {
        // 初始化一个栈
        Stack<Integer> s = new Stack<>();
        // 向栈中放入元素
        s.push(5);
        s.push(13);
        s.push(8);
        s.push(6);
        // 如果栈是空的，直接输出Stack is empty!
        if (s.empty() == true) {
            System.out.println("Stack is empty!");
            return;
        }
        // 删除栈中的元素
        s.pop();
        // 获取栈顶的元素
        System.out.println("The top element is: " + s.peek());
        // 获取栈的容量
        System.out.println("The size is: " + s.size());
    }
}

队列和栈实现