java：数据结构复习（二）数组栈

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

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

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

栈的源代码：

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 E getTop() {
        return (E) 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 + " ");
        }
    }
}

 栈的接口：

public interface MyStack<E> {
    //清空栈
    boolean clearStack();
    //判断是否为空栈
    boolean isEmpty();
    //返回栈中的元素个数
    int getLengh();
    //返回栈的栈顶元素
    E getTop();
    //入栈
    public boolean push(Object p);
    //出栈
    public E pop() ;
    //编历栈
    void stackTraverse();
    //扩容数组
   default void  reclloc(){};
    //进制转换
    default  String systemTransformation(String n,int n1,int n2)  {
        return "error";
    }
    //表达式求值
    default  boolean expressionEvaluation(String n){
        return false;
    }
    //判断运算符优先级
    default char precede(char a,char b){
        return '#';
    }
    //括号匹配
    default boolean correct(String n){
        return true;
    }
    //回文判断
    default  boolean  isPalindrome(String n){
        return false;
    }
}