Java - 栈和队列

栈 （stark）

不用多说了吧，线性的，先进后出， 有栈底 栈顶 ，会入栈 弹栈，下面给出源码，自己看懂：

 

package sstack;

import java.util.Arrays;

public class MyStark {

    //底层实现用一个数组
    private long[] arr;
    private int top;


    /**
     * 构造
     */
    public MyStark(){
        arr = new long[10];
        top = -1;
    }

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

    /**
     * 添加数据
     */
    public void push(int value){
        arr[++top] = value;
    }
    /**
     * 移除数据
     */
    public long pop(){
        return arr[top--];
    }

    /**
     * 查看栈顶数据
     */
    public long peek(){
        return arr[top];
    }

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

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




    @Override
    public String toString() {
        return "MyStark{" +
                "arr=" + Arrays.toString(arr) +
                ", top=" + top +
                '}';
    }
}

package sstack;

public class StarkTest {

    /**
     * 栈测试
     * @param args
     */
    public static void main(String[] args) {
        MyStark myStark = new MyStark(4);
        myStark.push(1);
        myStark.push(2);
        myStark.push(4);
        myStark.push(5);

        System.out.println(myStark);
        System.out.println("Full : "  + myStark.isFull());
        System.out.println("Empty :" + myStark.isEmpty());
        System.out.println("栈顶元素：" + myStark.peek());

        System.out.println("弹栈过程：");
        while (!myStark.isEmpty()){
            System.out.print(myStark.pop() + " => ");
        }
    }
}

 

 

---

 

队列Queue，这个其实也不用多说，

例如，排队打饭，先来的打，后来的后打，注意关键词 “排队”。 再例如水管出水....？？

 

package queue;

import java.util.Arrays;

public class MyQueue {
    //底层用数组实现
    private long[] arr;
    //有效数据的大小
    private int elements;
    //对头
    private int front;
    //队尾
    private int end;

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

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

    /**
     * 出队（其实就是front++）
     * @return
     */
    public long remove(){
        elements--;
        return arr[front++];
    }

    /**
     * 入队
     * @param value
     */
    public void insert(long value){
        arr[++end] = value;
        elements++;
    }

    /**
     * 查看队头元素
     */
    public long peek(){
        return arr[front];
    }

    /**
     * 队列是否空
     * @return
     */
    public boolean isEmpty(){
        return elements == 0;
    }

    /**
     * 队列是否满
     * @return
     */
    public boolean isFull(){
        return elements == arr.length ;
    }

    @Override
    public String toString() {
        return "MyQueue{" +
                "arr=" + Arrays.toString(arr) +
                ", elements=" + elements +
                ", front=" + front +
                ", end=" + end +
                '}';
    }
}

package queue;

public class MyQueueTest {
    public static void main(String[] args) {
        MyQueue myQueue = new MyQueue(4);
        myQueue.insert(1);
        myQueue.insert(2);
        myQueue.insert(3);
        myQueue.insert(4);

        System.out.println(myQueue);
        System.out.println(myQueue.remove() + " 出队");//出队
        System.out.println(myQueue);


        while (!myQueue.isEmpty()){
            System.out.println(myQueue.remove() + " 出队");//出队
        }

        myQueue.insert(123);// 现在队列为空 插入会报错 所以需要解决

    }
}

测试最后一行是数组越界，本想着 队列空 还想加点东西，解决方案就是   “ 循环队列 ”。

 

 

循环队列：

package queue;

import java.util.Arrays;

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;
    }

    /**
     * 出队（其实就是front++）
     * @return
     */
    public long remove(){
        //循环队列改动2：
        // 如果 front 指向队尾元素，那么使front 为 0；
        long value = arr[front++]; //值 = arr[front]
        if (front == arr.length){
            front = 0;
        }
        elements--;
        return value;   //返回出队值
    }

    /**
     * 入队
     * @param value
     */
    public void insert(long value){
        //循环队列改动1：
        //如果 end 指向 队列最后的元素
        if (end == arr.length - 1){
            end = -1;
        }
        arr[++end] = value;
        elements++;
        //如果一直无脑插入元素 元素个数最多为满
        if (elements > arr.length)
            elements = arr.length;
    }

    /**
     * 查看队头元素
     */
    public long peek(){
        return arr[front];
    }

    /**
     * 队列是否空
     * @return
     */
    public boolean isEmpty(){
        return elements == 0;
    }

    /**
     * 队列是否满
     * @return
     */
    public boolean isFull(){
        return elements == arr.length ;
    }

    @Override
    public String toString() {
        return "MyQueue{" +
                "arr=" + Arrays.toString(arr) +
                ", elements=" + elements +
                ", front=" + front +
                ", end=" + end +
                '}';
    }
}

package queue;

public class MyQueueTest {
    public static void main(String[] args) {
        MyCycleQueue myQueue = new MyCycleQueue(4);
        myQueue.insert(1);
        myQueue.insert(2);
        myQueue.insert(3);
        myQueue.insert(4);

        System.out.println(myQueue); //打印myQueue

        System.out.println(myQueue.remove());   //出队
        myQueue.insert(111);            //入队 【index: 0 】
        System.out.println(myQueue.remove()); //出队
        System.out.println(myQueue.remove()); //出队
        System.out.println(myQueue.remove()); //出队
        myQueue.insert(222);            //入队 【index: 1 】

        System.out.println(myQueue);        //打印myQueue

        System.out.println("/*-------下面是循环出队 直到 队列为空-------*/");
        //队列不为空就出队
        while (!myQueue.isEmpty()){
            System.out.println("出队：" + myQueue.remove());
            System.out.println("队列：" + myQueue);
            System.out.println("---------------------");
        }



    }
}

其中对比普通队列的改变里面也有详细说明，测试结果图如下：

 

 

 

完。