java：数据结构复习数组栈

Posted 2021-02-09 dark_Souls

栈也是数据结构中重要数据结构，它分为链栈和数组栈，特性：元素先进后出，后进先出

读取也只能读取栈顶元素，栈的应用有以下几种：括号匹配，进制转换，与递归也有关系，判断回文，表达式计算（我会在以后文章专门写几篇介绍应用）

推荐在书写数据结构时，保留一个主函数进行测试

栈的源代码：

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author 李正阳
 */
public class MyArraysStack<E> implements MyStack<E> {
    private int DEFAULT_SIZE = 16;//定义栈的初始默认长度
    private int capacity;//保存顺序栈的长度涉及扩容
    public int size;//保存顺序栈中元素的个数
    private Object[] elementData;//定义一个数组用于保存顺序栈中的元素


    /**
     * 初始化栈
     */
    public MyArraysStack() {
        elementData = new Object[DEFAULT_SIZE];
        size = 0;
        capacity = DEFAULT_SIZE;
    }

    /**
     * 清除栈中所有的元素
     *
     * @return
     */
    @Override
    public boolean clearStack() {
        for (int i = 0; i < size; i++) {
            elementData[i] = null;
        }
        return true;
    }

    /**
     * 栈是否为空
     *
     * @return true 空栈 false 非空栈
     */
    @Override
    public boolean isEmpty() {
        if (size == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 返回这个数组的长度
     *
     * @return
     */
    @Override
    public int getLengh() {
        return size;
    }

    /**
     * 获得栈顶元素
     *
     * @return
     */
    @Override
    public Object getTop() {
        return elementData[size - 1];
    }

    /**
     * 压入元素
     *
     * @param p 存储的值
     * @return true 压入元素成功 false 失败
     */
    @Override
    public boolean push(Object p) {
        if (size >= capacity) {
            reclloc();
            elementData[size] = p;
            size++;
        } else {
            elementData[size] = p;
            size++;

        }
        return true;
    }

    /**
     * 扩容数组
     */
    @Override
    public void reclloc() {
        elementData = Arrays.copyOf(elementData, 2 * DEFAULT_SIZE);
        capacity = 2 * DEFAULT_SIZE;
    }

    /**
     * 弹出栈中的元素
     *
     * @return 所弹出的元素
     */
    @Override
    public E pop() {

        return (E) elementData[--size  ];
    }

    /**
     * 遍历并且输出
     */
    @Override
    public void stackTraverse() {
        for (Object a : elementData) {
            System.out.println(a + " ");
        }
    }
}

 栈的接口：

 1 public interface MyStack<E> {
 2     //清空栈
 3     boolean clearStack();
 4     //判断是否为空栈
 5     boolean isEmpty();
 6     //返回栈中的元素个数
 7     int getLengh();
 8     //返回栈的栈顶元素
 9     Object getTop();
10     //入栈
11     public boolean push(Object p);
12     //出栈
13     public Object pop() ;
14     //编历栈
15     void stackTraverse();
16     //扩容数组
17    default void  reclloc(){};
18     //进制转换
19     default  String systemTransformation(String n,int n1,int n2)  {
20         return "error";
21     }
22     //表达式求值
23     default  boolean expressionEvaluation(String n){
24         return false;
25     }
26     //判断运算符优先级
27     default char precede(char a,char b){
28         return ‘#‘;
29     }
30     //括号匹配
31     default boolean correct(String n){
32         return true;
33     }
34     //回文判断
35     default  boolean  isPalindrome(String n){
36         return false;
37     }
38 }