Java —— 用数组来实现数据结构中的栈和队列

栈

栈(先进后出)：用Java的数组来实现

package practice;

public abstract class Stack {
    /**
     * 将元素压入栈顶
     * 入栈
     * @param element 要压入的元素
     */
    abstract void push(Object element);
    /**
     * 弹出栈顶元素并返回
     * 把栈顶元素删除，并返回
     * 出栈
     * @return 弹出的栈顶元素, 如果栈为空返回 null
     */
    abstract Object pop();
    /**
     * 返回栈顶元素，但不弹出
     * @return 栈顶元素
     */
    abstract Object peek();
    /**
     * 检查栈是否为空
     * @return 如果栈为空则返回true，否则返回false
     */
    abstract boolean isEmpty();
    /**
     * 返回栈中的元素个数
     * @return 栈中元素的个数
     */
    abstract int size();
}

package practice;

import java.sql.SQLOutput;
import java.util.Scanner;

public class MyStack extends Stack{
    Object[] arr;
    int count;
    int capacity;
    Scanner sc = new Scanner(System.in);
    public MyStack(){
        this(10);
    }
    public MyStack(int capacity){
        grow();
        if (capacity<=0){
            capacity = 10;
        }
        this.capacity=capacity;
        arr = new Object[capacity];
    }
    /**
     * 数组扩容
     */
    public void grow(){
        if (count==arr.length){
            Object[] newArr = new Object[arr.length*2];
            System.arraycopy(arr,0,newArr,0,arr.length);
            arr = newArr;
        }
    }
    /**
     * 将元素压入栈顶
     * 入栈
     * @param element 要压入的元素
     */
    @Override
    void push(Object element) {
        arr[count] = element;
        count++;
    }
    /**
     * 弹出栈顶元素并返回
     * 把栈顶元素删除，并返回
     * 出栈
     * @return 弹出的栈顶元素, 如果栈为空返回 null
     */
    @Override
    Object pop() {
        if (count>0){
            Object remove = arr[count-1];
            System.arraycopy(arr,0,arr,0,count-1);
            System.arraycopy(arr,count,arr,count-1,arr.length-count);
            count--;
            return remove;
        }
        return null;

    }
    /**
     * 返回栈顶元素，但不弹出
     * @return 栈顶元素
     */
    @Override
    Object peek() {
        if (count>0){
            return arr[count-1];
        }
        return null;
    }
    /**
     * 检查栈是否为空
     * @return 如果栈为空则返回true，否则返回false
     */
    @Override
    boolean isEmpty() {
        if (count==0){
            return true;
        }
        return false;
    }
    /**
     * 返回栈中的元素个数
     * @return 栈中元素的个数
     */
    @Override
    int size() {

        return count;
    }
    public void menu(){
        System.out.println("*********************");
        System.out.println("1、入栈\n2、出栈\n3、返回栈顶元素\n4、检查栈是否为空\n5、查看栈中元素个数\n0、退出");
        System.out.println("*********************");
    }
    public void system(){
        Scanner sc = new Scanner(System.in);
        while (true){
            menu();
            System.out.println("请输入你要进行的操作");
            int op = sc.nextInt();
            switch(op){
                case 1 -> pushOperate();
                case 2 -> popOperate();
                case 3 -> peekOperate();
                case 4 -> isEmptyOperate();
                case 5 -> sizeOperate();
                case 0 -> {
                    System.out.println("退出");
                    return;
                }
            }
        }
    }
    public void pushOperate(){
        System.out.println("请输入你要入栈的数字：");
        Object num = sc.nextInt();
        push(num);
    }
    public void popOperate(){
        System.out.println(pop());
    }
    public void peekOperate(){
        System.out.println(peek());
    }
    public void isEmptyOperate(){
        if (isEmpty()){
            System.out.println("栈为空");
            return;
        }
        System.out.println("栈不为空");
    }
    public void sizeOperate(){
        System.out.println(size());
    }

}

package practice;

public class StackTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.system();
    }
}

队列

队列（先进先出）：用Java的数组来实现

package practice;

public abstract class Queue {
    /**
     * 将元素插入队尾
     *
     * @param element 要插入的元素
     */
    abstract void enqueue(Object element);
    /**
     * 移除并返回队首元素
     * 删除第一个元素，并返回
     *
     * @return 队首元素, 如果队列为空时，返回 null
     */
    abstract Object dequeue();
    /**
     * 返回队首元素，但不移除
     *
     * @return 队首元素
     */
    abstract Object peek();
    /**
     * 检查队列是否为空
     *
     * @return 如果队列为空则返回true，否则返回false
     */
    abstract boolean isEmpty();
    /**
    * 返回队列中的元素个数
    *
    * @return 队列中元素的个数
    */
    abstract int size();
}

package practice;

public class MyQueue extends Queue{
    Object[] arr;
    int count;
    int capacity=10;

    public MyQueue(){
        arr = new Object[capacity];
    }
    public MyQueue(int capacity){
        if (capacity<0){
            capacity = 10;
        }
        this.capacity = capacity;
        arr = new Object[capacity];
    }

    public void grow(){
        if (count>=arr.length){
            Object[] newArr = new Object[arr.length*2];
            System.arraycopy(arr,0,newArr,0,arr.length);
            arr = newArr;
        }
    }
    /**
     * 将元素插入队尾
     *
     * @param element 要插入的元素
     */
    @Override
    void enqueue(Object element) {
        grow();
        arr[count] = element;
        count++;
    }
    /**
     * 移除并返回队首元素
     * 删除第一个元素，并返回
     *
     * @return 队首元素, 如果队列为空时，返回 null
     */
    @Override
    Object dequeue() {
        if (count==0){
            return null;
        }
        Object remove = arr[0];
        System.arraycopy(arr,1,arr,0,arr.length-1);
        count--;
        return remove;
    }
    /**
     * 返回队首元素，但不移除
     *
     * @return 队首元素
     */
    @Override
    Object peek() {
        if(count==0){
            return null;
        }
        return arr[0];

    }
    /**
     * 检查队列是否为空
     *
     * @return 如果队列为空则返回true，否则返回false
     */
    @Override
    boolean isEmpty() {
        if (count==0){
            return true;
        }
        return false;
    }

    @Override
    int size() {
        return count;
    }
}

package practice;

public class QueueTest {

    public static void main(String[] args) {
        Student student1 = new Student("张三",'男',23);
        Student student2 = new Student("李四",'女',20);
        MyQueue mq = new MyQueue();
        mq.enqueue(student1);
        mq.enqueue(student2);
        System.out.println(mq.dequeue());
        System.out.println(mq.peek());
        System.out.println(mq.isEmpty());
        System.out.println(mq.size());
    }

}

单链表