数据结构之栈与队列

写在前面

栈与队列是两种不同特点的数据结构。
栈遵循着先进后出的特点，它就像一个器皿，先放进去的后被取出来，后放进去也就是靠近瓶口的先出来。
队列，就像它的名字一般，它的结构类似于排队，先进先出，后进后出。

栈的实现

package Stack;

public class MyStack {
    //底层实现是一个数组
    private long[] arr;
    private int top;

    public MyStack(){
        arr = new long[10];
        top = -1;
    }

    public MyStack(int maxsize){
        arr = new long[maxsize];
        top = -1;
    }

    /**
     * 添加数据
     * @param value
     */
    public void insert(int value){
        arr[++top] = value;
    }

    /**
     * 移除数据
     * @return
     */
    public long pop(){
        return arr[top--];
    }

    /**
     * 查询数据
     * @return
     */
    public long peek(){
        return arr[top];
    }

    /**
     * 判断是否为空
     * @return
     */
    public boolean isEmpty(){
        return top == -1;
    }

    /**
     * 判断是否满了
     * @return
     */
    public boolean isFull(){
        return  top == arr.length - 1;
    }
}

package Stack;

public class TestMyStack {
    public static void main(String[] args) {
        MyStack mq = new MyStack(4);
        System.out.println(mq.isEmpty());
        mq.insert(32);
        mq.insert(12);
        mq.insert(1);
        mq.insert(78);
        System.out.println(mq.isEmpty());
        System.out.println(mq.isFull());

        System.out.println(mq.peek());
        System.out.println(mq.pop());
        System.out.println(mq.peek());

    }
}

队列的实现

package Queue;
//循环列队
public class MyCycleQueue {
    //底层使用数组
    private long[] arr;
    //有效数据的大小
    private int elements;
    //队头
    private int front;
    //队尾
    private int end;

    public MyCycleQueue() {
        arr = new long[10];
        elements = 0;
        front = 0;
        end = -1;
    }

    public MyCycleQueue(int maxsize) {
        arr = new long[maxsize];
        elements = 0;
        front = 0;
        end = -1;
    }

    /**
     * 插入数据，从队尾插入
     * @param value
     */
    public void insert(long value) {
        if(end == arr.length - 1){
            end = -1;
        }
        arr[++end] = value;
        elements++;
    }

    /**
     * 删除数据，从队头删除
     * @return
     */
    public long remove() {
        long value = arr[front++];
        if (front == arr.length){
            front = 0;
        }
        elements--;
        return value;
    }

    /**
     * 查询数据，从队头查询
     * @return
     */
    public long peek() {
        return arr[front];
    }

    /**
     * 判断是否为空
     * @return
     */
    public boolean isEmpty() {
        return elements == 0;
    }

    /**
     * 判断是否已经满了
     * @return
     */
    public boolean isFull() {
        return  elements == arr.length;
    }
}

package Queue;

import Stack.MyStack;

public class TestMyQueue {
    public static void main(String[] args) {
        MyQueue mq = new MyQueue(4);
        System.out.println(mq.isEmpty());
        mq.insert(32);
        mq.insert(12);
        mq.insert(1);
        mq.insert(78);
        System.out.println(mq.isEmpty());
        System.out.println(mq.isFull());

        System.out.println(mq.peek());
        System.out.println(mq.remove());
        System.out.println(mq.peek());

    }
}