Java数据结构之栈详解

最新推荐文章于 2024-02-02 13:19:02 发布

Carper Diem丶

最新推荐文章于 2024-02-02 13:19:02 发布

阅读量5.9k

点赞数 17

文章标签：数据结构 java 开发语言

本文链接：https://blog.csdn.net/weixin_51375190/article/details/122489128

版权

栈的定义：

栈（stack）是一种用于存储数据的简单数据结构。栈一个有序线性表，只能在表的一端（PS：栈顶）执行插人和删除操作。最后插人的元素将被第一个删除。所以，栈也称为后进先出（Last In First Out,LIFO）或先进后出（First In Last Out,FILO）线性表。

这里写图片描述

Java 集合框架中的 Stack 继承自 Vector：

由于 Vector 有 4 个构造函数，加上 Stack 本身的一种，也就是说有 5 中创建 Stack 的方法
跟 Vector 一样，它是可以由数组实现的栈。

栈的几种主要基本操作：

void push(int data)：入栈（将数据data插入到栈中）
int pop()：出栈（删除并返回最后一个插入栈的元素）
int top()：返回最后一个插入栈的元素，但不删除
int size()：返回存储在栈中的元素个数
boolean isEmpty()：返回栈是否是空栈
boolean isFull()：返回是否是满栈
void Clear()：清除整个栈

栈的应用：

符号匹配
HTML和XML文件中的标签匹配（实质还是符号匹配）
实现函数调用
文本编辑器中的撤销
网页浏览器中已访问页面的历史记录
作为一个算法的辅助数据结构

栈的基本方法：

public interface Stack<E> extends Iterable<E> {
    
    //获取栈的size大小
    public int size();
    
    //判断栈是否为空
    public boolean isEmpty();
 
    //入栈 进栈一个元素 在线性表的表尾添加一个元素
    public void push(E element);

    //出栈 弹出一个元素 在线性表的表尾删除一个元素
    public E pop();

    //查看当前栈顶元素 并不是移除 查看线性表中最后一个元素
    public E peek();

    //对当前栈进行清空
    public void clear();
}

栈的几种实现方式

基于简单数组的实现方式
基于动态数组的实现方式
基于链表的实现方式
基于队列的实现方式

1.基于简单数组的实现：

基于简单数组实现一个栈，其基本思路是这样的：从左至右向数组中添加所有的元素，并定义一个变量用来记录数组当前栈顶(top)元素的下标。当数组存满了栈元素时，执行入栈(插入元素)操作将抛出栈满异常；当对一个没有存储栈元素的数组执行出栈(删除元素)操作将抛出栈空异常，当然，这种实现方式有一个很明显的局限性。那就是：栈的最大空间必须预先声明且不能改变。试图对一个满栈执行入栈操作将会产生异常。

2.基于动态数组的实现：

基于动态数组的实现一个栈，其基本思路跟上面类似。不同的是，这种方式下当数组中存储的元素达到一定量时（如：数组空间的0.75或者整个数组空间），这时我们通常会选择新建一个比原数组空间大一倍的新数组，然后将原数组按照原来的顺序复制进去，接着便可以继续进行入栈操作了。

import p1.Stack;（上方的Stack包）

import java.util.Iterator;

public class ArrayStack<E> implements Stack<E> {
    
    //定义私有变量List
    private ArrayList<E> list;
    
    //默认构造
    public ArrayStack() {
        list = new ArrayList<>();
    }
    //自己定义数组长度
    public ArrayStack(int capacity) {
        list = new ArrayList<>(capacity);
    }
    
    //size实现
    @Override
    public int size() {
        return list.size();
    }
    //判空实现
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }
    //push方法
    @Override
    public void push(E element) {
        list.add(element);
    }
    //pop方法实现
    @Override
    public E pop() {
        return list.remove(list.size() - 1);
    }
    //peek实现
    @Override
    public E peek() {
        return list.get(list.size() - 1);
    }
    //clear方法
    @Override
    public void clear() {
        list.clear();
    }
    //迭代方法
    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }
    //toString方法实现
    @Override
    public String toString() {
        return list.toString();
    }
    //继承Object equals方法
    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        if (o instanceof ArrayStack) {
            ArrayStack other = (ArrayStack) o;
            return this.list.equals(other.list);
        }
        return false;
    }
}

3.基于链表的实现:

基于链表实现一个栈，其基本思路是这样的：通过在链表的表头插入元素的方式来实现push操作；通过删除链表的表头节点的方式来实现pop操作.

public class SinglyNode<K extends Object> {
    private K data; // 数据
    private SinglyNode<K> next; // 该节点的下个节点
 
    public SinglyNode(K data) {
        this.data = data;
    }
 
    public SinglyNode(K data, SinglyNode<K> next) {
        this.data = data;
        this.next = next;
    }
 
    public K getData() {
        return data;
    }
 
    public void setData(K data) {
        this.data = data;
    }
 
    public SinglyNode<K> getNext() {
        return next;
    }
 
    public void setNext(SinglyNode<K> next) {
        this.next = next;
    }
 
    @Override
    public String toString() {
        return "SinglyNode [data=" + data + "]";
    }
 
}

public class LinkStack<K extends Object> implements Stack<K> {
 
    private SinglyNode<K> headNode;
    //是否为满栈
    public boolean isFull() {
        return false;
    }
    //是否为空
    public boolean isEmpty(){
        return headNode == null ? true : false;
    }
    
    
    //入栈
    public void push(K data){
        if(headNode == null){
            headNode = new SinglyNode<K>(data);
        }else{
            SinglyNode<K> newNode = new SinglyNode<K>(data);
            newNode.setNext(headNode);
            headNode = newNode;
        }
    }
    
    //出栈
    public K pop(){
        if(headNode == null){
            throw new EmptyStackException();
        }else{
            K data = headNode.getData();
            headNode = headNode.getNext();
            return data;
        }
    }
    
    //返回栈顶元素
    public K top(){
        if(headNode == null){
            throw new EmptyStackException();
        }else{
            return headNode.getData();
        }
    }
    
    //返回栈中元素个数
    public int size(){
        if(headNode == null){
            return 0;
        }else{
            int length = 0;
            SinglyNode<K> currentNode = headNode;
            while (currentNode != null) {
                length++;
                currentNode = currentNode.getNext();
            }
            return length;
        }
    }
    
    //清空栈
    public void ClearStack(){
        headNode = null;
    }
 
   //遍历栈从前往后
    @Override
    public void print() {
        SinglyNode<K> tmpNode = headNode;
        printFromEnd(tmpNode);
    }
    
    //遍历栈从后往前
    public void printFromEnd(SinglyNode<K> headNode){
        if(headNode != null){
            if(headNode.getNext() != null){
                printFromEnd(headNode.getNext());
            }
            
            System.out.print(headNode.getData() + " ");
        }
    }
 
}

基于数组实现和基于链表实现的比较

（1）基于数组实现的栈：

各个操作都是常数时间开销
每隔一段时间进行的倍增操作的时间开销较大

（2）基于链表实现的栈：

栈规模的增加和减小都很容易
各个操作都是常数时间开销
每个操作都需要使用额外的空间和时间开销来处理指针

4.基于队列实现栈：

import java.util.Iterator;

//队列实现栈
public class QueueToStack {
    public static void main(String[] args) {
        StackImplByQueue<Integer> stack = new StackImplByQueue<>();
        System.out.println(stack);
        for (int i = 1; i <= 5; i++) {
            stack.push(i); //队列A
        }
        System.out.println(stack.toString());
        System.out.println(stack.pop());
        System.out.println(stack);  //队列B

    }
}

class StackImplByQueue<E> implements Stack<E> { //上方的栈调用
    private ArrayQueue<E> queueA;
    private ArrayQueue<E> queueB;

    public StackImplByQueue() {
        queueA = new ArrayQueue<>();
        queueB = new ArrayQueue<>();
    }

    @Override
    public int size() {
        if (queueA.isEmpty() && queueB.isEmpty()) {
            return 0;
        } else if (!queueA.isEmpty()) {
            return queueA.size();
        } else {
            return queueB.size();
        }
    }

    @Override
    public boolean isEmpty() {
        return queueA.isEmpty() && queueB.isEmpty();
    }

    @Override
    public void push(E element) {
        if (queueA.isEmpty() && queueB.isEmpty()) {
            queueA.offer(element);
        } else if (!queueA.isEmpty()) {
            queueA.offer(element);
        } else {
            queueB.offer(element);
        }
    }

    @Override
    public E pop() {
        if (isEmpty()) {
            return null;
        }
        E ret = null;
        if (!queueA.isEmpty()) {
            while (queueA.size() != 1) {
                queueB.offer(queueA.poll());
            }
            ret = queueA.poll();
        } else {
            while (queueB.size() != 1) {
                queueA.offer(queueB.poll());
            }
            ret = queueB.poll();
        }
        return ret;
    }

    @Override
    public E peek() {
        if (isEmpty()) {
            return null;
        }
        E ret = null;
        if (!queueA.isEmpty()) {
            while (queueA.size() != 1) {
                queueB.offer(queueA.poll());
            }
            ret = queueA.poll();
            queueB.offer(ret);
        } else {
            while (queueB.size() != 1) {
                queueA.offer(queueB.poll());
            }
            ret = queueB.poll();
            queueA.offer(ret);
        }
        return ret;
    }

    @Override
    public void clear() {
        queueA.clear();
        queueB.clear();
    }

    @Override
    public Iterator<E> iterator() {
        if (isEmpty()) {
            return queueA.iterator();
        } else if (!queueA.isEmpty()) {
            return queueA.iterator();
        } else {
            return queueB.iterator();
        }
    }
    @Override
    public String toString() {
        if (isEmpty()) {
            return "[]";
        } else if (!queueA.isEmpty()) {
            return queueA.toString();
        } else {
            return queueB.toString();
        }
    }

}

Java 集合框架中的 Stack 具有以下特点：

继承自 Vector
有 5 种创建 Stack 的方法
采用数组实现
除了 push()，剩下的方法都是同步的。

双端栈：

双端栈定义：

是指一个线性表的两端当做栈底，分别进行入栈和出栈操作，主要利用了栈：栈底不变，栈顶变化的特征；

双端栈是线性表的一种,更是栈的一个特殊分类，可用借用动态数组+栈的组合实现。

双端栈实现方法以及基本方法：

import java.util.Iterator;
    //双端栈
public class ArrayDoubleEndStack<E> implements Iterable<E> {
    //左端栈的栈顶
    private int ltop;
    //右端栈的栈顶
    private int rtop;
    //存储元素的容器
    private E[] data;
    //数组容器的默认容量
    private static int DEFAULT_CAPACITY = 10;
    //构造
    public ArrayDoubleEndStack() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        ltop = -1;
        rtop = data.length;
    }
    //左入栈
    public void pushLeft(E element) {
        if (ltop + 1 == rtop) {
            resize(data.length * 2);
        }
        data[++ltop] = element;
    }
    //右入栈
    public void pushRight(E element) {
        if (ltop + 1 == rtop) {
            resize(data.length * 2);
        }
        data[--rtop] = element;
    }
    //扩容
    private void resize(int newLen) {
        E[] newData = (E[]) new Object[newLen];
        //复制左端栈的元素
        for (int i = 0; i <= ltop; i++) {
            newData[i] = data[i];
        }
        //复制右端栈的元素
        int index = rtop;
        for (int i = newLen - sizeRight(); i < newLen; i++) {
            newData[i] = data[index++];
        }
        rtop = newLen - sizeRight();
        data = newData;
    }
    //左出栈
    public E popLeft() {
        if (isLeftEmpty()) {
            throw new IllegalArgumentException("left stack is null");
        }
        E ret = data[ltop--];
        if (sizeLeft() + sizeRight() <= data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }
    //右出栈
    public E popRight() {
        if (isRightEmpty()) {
            throw new IllegalArgumentException("right stack is null");
        }
        E ret = data[rtop++];
        if (sizeLeft() + sizeRight() <= data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }
    //获取左栈顶
    public E peekLeft() {
        if (isLeftEmpty()) {
            throw new IllegalArgumentException("left stack is null");
        }
        return data[ltop];
    }
    //获取右栈顶
    public E peekRight() {
        if (isRightEmpty()) {
            throw new IllegalArgumentException("right stack is null");
        }
        return data[rtop];
    }
    
    //判断是否左边为空
    public boolean isLeftEmpty() {
        return ltop == -1;
    }
    //判断是否右边为空
    public boolean isRightEmpty() {
        return rtop == data.length;
    }
    //通过左指针获取长度
    public int sizeLeft() {
        return ltop + 1;
    }
    //通过右指针获取长度
    public int sizeRigh() {
        return data.length - rtop;
    }
    //重写toString方法
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isLeftEmpty() && isRightEmpty()) {
            sb.append(']');
            return sb.toString();
        }
        //先左边
        for (int i = 0; i <= ltop; i++) {
            sb.append(data[i]);
            if (i == ltop && isRightEmpty()) {
                sb.append(']');
                return sb.toString();
            } else {
                sb.append(',');
            }
        }
        //后右边
        for (int i = rtop; i < data.length; i++) {
            sb.append(data[i]);
            if (i == data.length - 1) {
                sb.append(']');
            } else {
                sb.append(',');
            }
        }
        return sb.toString();
    }
    //迭代器
    @Override
    public Iterator<E> iterator() {
        return new ArrayDoubleEndStackIterator();
    }

    class ArrayDoubleEndStackIterator implements Iterator<E> {
        private ArrayList<E> list;
        private Iterator<E> it;
        public ArrayDoubleEndStackIterator() {
            list = new ArrayList<>();
            for (int i = 0; i <= ltop; i++) {
                list.add(data[i]);
            }
            for (int i = rtop; i < data.length; i++) {
                list.add(data[i]);
            }
            it = list.iterator();
        }

        @Override
        public boolean hasNext() {
            return it.hasNext();
        }

        @Override
        public E next() {
            return it.next();
        }
    }
}

双端栈的扩容与缩容问题；

双端栈A中有下标0-5的6个元素，对其进行扩容；

对其扩容时候，先考虑左边，从原来双端栈A的左边原封不动直接进入双端栈B，此时与双端栈A的左指针相同，皆为下标2，此时双端栈B的前3个元素不动，下标为【0，ltop】。

其次考虑右边的情况，通过观察，发现index为5的元素对应到11，所以即为newLen-1，而先前的rtop从双端栈A的3变到了双端栈B的9，可以观察到9 = 12 - 3;此时rtop = newLen - size（1）

这时候原先双端栈A的右边完全到了双端栈B的左边，完成了对双端栈A的扩容问题。

关于栈的习题应用：

1.关于题解回文数；

给定一个字符串，判断是否该字符串是否是回文字符串，即"aba" 则为一个满足回文的条件；

public class JudgingPalindrome {
    public static void main(String[] args) {
        solution01();
        System.out.println(solution02());
    }
    //通过栈的思想
    private static void solution01() {
        String text = "上海自来水来自海上"; 
        ArrayStack<Character> stack = new ArrayStack<>();
           //遍历栈中元素
         for (int i = 0; i < text.length(); i++) {
            //对于栈中元素是奇是偶进行判断
            if (text.length() % 2 == 1 && i == text.length() / 2) {
                continue;
            }
            char c = text.charAt(i);
            //栈空进栈，相同时候元素弹出，不同时候进栈，判断最后是否栈为空，为空则回文
            if (stack.isEmpty()) {
               stack.push(c);
            } else {
                if (c != stack.peek()) {
                    stack.push(c);
                } else {
                    stack.pop();
                }
            }
        }
        System.out.println(stack.isEmpty());
    }
        //通过双指针的思想
        private static boolean solution02() {
        String text = "上海自来水来自海上";
        //头指针
        int i = 0;
        //尾指针
        int j = text.length() - 1;
        //循环条件，头尾同时进行，首位匹配下一位，不同则返回false；
        while (true) {
            if (text.charAt(i) == text.charAt(j)) {
                i++;
                j--;
            } else {
                return false;
            }
            //尾指针要小于等于头指针
            if (j <= i) {
                return true;
            }
        }
    }
}

2.关于括号匹配问题

给定一些列括号‘（‘ ，’）’，‘【‘，’】’等，判断给定的括号串，是否完全匹配。如：“（{（）（）}）”；


//括号匹配
import java.util.HashMap;

public class MatchBracket {
    public static void main(String[] args) {
        solution01();
        solution02();
    }

    //通过栈的思想解决
    private static void solution01() {
        String str = "{()[[()]]<>{}()<>}()";
        ArrayStack<Character> stack = new ArrayStack<>();
     
           //循环该数组下标，栈为空进栈
            for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (stack.isEmpty()) {
                stack.push(c);
            } else {
               //当前栈顶
                char top = stack.peek();
                //通过ascll码匹配当满足条件时候，弹栈，即完成匹配
                if (top - c == -1 || top - c == -2) {
                    stack.pop();
                } else {
                    stack.push(c);
                }
            }
        }
        //当stack为空时候说明括号完全匹配
        System.out.println(stack.isEmpty());
    }
        
        //通过HashMap实现
        private static void solution02() {
        String str = "{()[[()]]<{()>}()";
        //给定hashmap的键值对应关系
        HashMap<Character,Character> map = new HashMap<>();
        map.put('[',']');
        map.put('<','>');
        map.put('(',')');
        map.put('{','}');
        ArrayStack<Character> stack = new ArrayStack<>();
        //遍历和法1相同
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (stack.isEmpty()) {
                stack.push(c);
            } else {
                char top = stack.peek();
                //contains保证键值关系，包含时候，看c是否满足关系，满足时候弹栈，不满足继续入栈
                if (map.containsKey(top) && c == map.get(']')) {
                    stack.pop();
                } else {
                    stack.push(c);
                }
            }
        }
        System.out.println(stack.isEmpty());
    }
}

3.简单计算器的实现

给定（），+ - */四则运算，做出来一个简单的计算器如(10+20/2*3)/2+8 = 28

3.1中缀表达式计算器

//中缀表达式计算器
public class InfixCalculator {
    public static void main(String[] args) {
        String expression = "(10+20/2*3)/2+8";
        try {
            int result = evaluateExpression(expression);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("Wrong expression :" + expression);
        }
    }

    private static int evaluateExpression(String expression) {
        //需要两个辅助栈
        ArrayStack<Character> operatorStack = new ArrayStack<>();
        ArrayStack<Integer> numberStack = new ArrayStack<>();

        //格式化表达式
        expression = insertBlanks(expression);
        String[] tokens = expression.split(" ");
        for (String token : tokens) {   //token == tokens[i]
            //过滤空串
            if (token.length() == 0) {
                continue;
                //遍历到 + - 号
            } else if (token.equals("+") || token.equals("-")) {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '+' || operatorStack.peek() == '-' || operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
                    //如果之前是别的+ - * / 则需要弹栈 并计算
                    processAnOperator(numberStack, operatorStack);
                }
                //如果操作符栈为空 或者 不为空但栈顶为(
                operatorStack.push(token.charAt(0));

                //遍历到 * / 号
            } else if (token.equals("*") || token.equals("/")) {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == '*' || operatorStack.peek() == '/')) {
                    //如果之前是别的* / 则需要弹栈 并计算
                    processAnOperator(numberStack, operatorStack);
                }
                //如果操作符栈为空 或者 不为空但栈顶为(
                operatorStack.push(token.charAt(0));

                //遍历到 (
            } else if (token.equals("(")) {
                operatorStack.push(token.charAt(0));

                //遍历到 )
            } else if (token.equals(")")) {
                //只要操作符栈的栈顶不是左括号( 就挨个弹栈计算即可
                while (operatorStack.peek() != '(') {
                    processAnOperator(numberStack, operatorStack);
                }
                //最后 清掉左括号
                operatorStack.pop();

                //遍历到数字
            } else {
                numberStack.push(new Integer(token));
            }
        }

        //处理最后面的操作符
        while (!operatorStack.isEmpty()) {
            processAnOperator(numberStack, operatorStack);
        }
        return numberStack.pop();
    }

    //操作符栈弹栈一个元素 数字栈弹栈两个数字 进行计算 并将新的结果进栈到数字栈
    private static void processAnOperator(ArrayStack<Integer> numberStack, ArrayStack<Character> operatorStack) {
        char op = operatorStack.pop();
        int num1 = numberStack.pop();
        int num2 = numberStack.pop();
        //num2 op num1
        if (op == '+') {
            numberStack.push(num2 + num1);
        } else if (op == '-') {
            numberStack.push(num2 - num1);
        } else if (op == '*') {
            numberStack.push(num2 * num1);
        } else {
            numberStack.push(num2 / num1);
        }
    }

    //对原表达式进行格式化处理 给所有的非数字字符两边添加空格
    private static String insertBlanks(String expression) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/') {
                sb.append(' ');
                sb.append(c);
                sb.append(' ');
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

3.2后缀表达式计算器

//后缀表达式的计算器
public class SuffixCalculator {
    public static void main(String[] args) {
        String infixExpression = "(10+20/2*3)/2+8";
        String suffixExpression = InfixToSuffix.infixToSuffix(infixExpression);
        int result = evaluateSuffix(suffixExpression);
        System.out.println(result);
    }

    private static int evaluateSuffix(String expression) {
        ArrayStack<Integer> stack = new ArrayStack<>();
        String[] tokens = expression.split(" ");
        for (String token : tokens) {
            if (token.length() == 0) {
                continue;
            }
            if (isNumber(token)) {
                stack.push(new Integer(token));
            } else {
                processAnOperator(stack,token);
            }
        }
        return stack.pop();
    }

    private static void processAnOperator(ArrayStack<Integer> stack, String token) {
        int num1 = stack.pop();
        int num2 = stack.pop();
        if (token.equals("+")) {
            stack.push(num2 + num1);
        } else if (token.equals("-")) {
            stack.push(num2 - num1);
        } else if (token.equals("*")) {
            stack.push(num2 * num1);
        } else if (token.equals("/")) {
            stack.push(num2 / num1);
        }
    }

    private static boolean isNumber(String token) {
        return token.matches("\\d+");
    }
}

3.3中缀转换后缀

//中缀表达式转后缀表达式
public class InfixToSuffix {
    public static void main(String[] args) {
        String expression = "(10+20/2*3)/2+8";
        expression = infixToSuffix(expression);
        System.out.println(expression);
    }
    private static String infixToSuffix(String expression) {
        //操作符的栈
        ArrayStack<String> opStack = new ArrayStack<>();
        //后缀表达式的线性表
        ArrayList<String> suffixList = new ArrayList<>();
        //格式化表达式
        expression = insertBlanks(expression);
        String[] tokens = expression.split(" ");
        for (String token : tokens) {
            //过滤空串
            if (token.length() == 0) {
                continue;
            }
            //判断操作符+ - * /
            if (isOperator(token)) {
                /*
                什么时候操作符进栈？
                1.如果栈为空
                2.如果栈顶是 (
                3.如果栈顶是操作符，且优先级比当前token小
                什么时候需要将栈顶操作符出栈？
                1.栈顶操作符的优先级 >= 当前token
                */
                while (true) {
                    if (opStack.isEmpty() || opStack.peek().equals("(") || priority(opStack.peek()) < priority(token)) {
                        opStack.push(token);
                        break;
                    }
                    suffixList.add(opStack.pop());
                }
            } else if (token.equals("(")) {
                opStack.push(token);
            } else if (token.equals(")")) {
                while (!opStack.peek().equals("(")) {
                    suffixList.add(opStack.pop());
                }
                opStack.pop();
            } else if (isNumber(token)) {
                suffixList.add(token);
            } else {
                throw new IllegalArgumentException("wrong char :" + expression);
            }
        }
        while (!opStack.isEmpty()) {
            suffixList.add(opStack.pop());
        }
        //将数字元素和操作符元素进行拼接
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < suffixList.size(); i++) {
            sb.append(suffixList.get(i));
            sb.append(' ');
        }
        return sb.toString();
    }

    private static int priority(String token) {
        if (token.equals("+") || token.equals("-")) {
            return 0;
        }
        if (token.equals("*") || token.equals("/")) {
            return 1;
        }
        return -1;
    }

    private static boolean isNumber(String token) {
        return token.matches("\\d+");
    }

    private static boolean isOperator(String token) {
        return token.equals("+") || token.equals("-") || token.equals("*") || token.equals("/");
    }

    //对原表达式进行格式化处理 给所有的非数字字符两边添加空格
    private static String insertBlanks(String expression) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/') {
                sb.append(' ');
                sb.append(c);
                sb.append(' ');
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

Carper Diem丶

关注

17
点赞
踩
76

收藏

觉得还不错? 一键收藏
1
评论
Java数据结构之栈详解

栈的定义：栈（stack）是一种用于存储数据的简单数据结构。栈一个有序线性表，只能在表的一端（PS：栈顶）执行插人和删除操作。最后插人的元素将被第一个删除。所以，栈也称为后进先出（Last In First Out,LIFO）或先进后出（First In Last Out,FILO）线性表。Java 集合框架中的 Stack 继承自Vector：由于 Vector 有 4 个构造函数，加上 Stack 本身的一种，也就是说有 5 中创建 Stack 的方法跟 Vector 一样，..
复制链接

扫一扫