java数据结构-栈

栈

1、栈的定义

栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。

栈顶（Top）：线性表允许进行插入删除的那一端。
栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
空栈：不含任何元素的空表。

栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构

2、栈的常见基本操作

• InitStack(&S)：初始化一个空栈S。
• StackEmpty(S)：判断一个栈是否为空，若栈为空则返回true，否则返回false。
• Push(&S, x)：进栈（栈的插入操作），若栈S未满，则将x加入使之成为新栈顶。
• Pop(&S, &x)：出栈（栈的删除操作），若栈S非空，则弹出栈顶元素，并用x返回。
• GetTop(S, &x)：读栈顶元素，若栈S非空，则用x返回栈顶元素。
• DestroyStack(&S)：栈销毁，并释放S占用的存储空间（“&”表示引用调用）

3、栈的应用场景

1)子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。

2)处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。

3)表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。

4)二叉树的遍历。

5)图形的深度优先(depth一first)搜索法。

2、栈的基础入门

2.1用数组模拟栈

/**
 * 使用数组模拟栈
 * 1.使用数组来模拟栈
 * 2.定义一个top来表示栈顶,初始化为-1
 * 3.入栈的操作,当有数据加入到栈时,top++,stack[top] = data；
 * 4.出栈的操作,int value = stack[top],top--,return value
 */
public class Stack {
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack(10);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.list();
        System.out.println("---");
        //理论上来说应该是4没有了
        stack.pop();
        stack.list();
    }
}

class ArrayStack {
    private int maxSize;//栈的大小
    private int[] stack;//数组,模拟栈,数据放在该数组
    private int top = -1;//标记栈的值

    //构造器
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        this.stack = new int[this.maxSize];
    }

    //判断栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //判断栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈-push
    public void push(int i) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = i;
    }

    //出栈-pop
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        return stack[top--];
    }

    //遍历栈[需要从栈顶开始显示数据]
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空没有数据");
            return;
        }
        //如果从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n",i,stack[i]);
        }
    }
}

2.2用链表模拟栈

public class LinkStack {
    public static void main(String[] args) {
        Node a1 = new Node(1);
        Node a2 = new Node(2);
        Node a3 = new Node(3);
        LinkStackList ll = new LinkStackList(5);
        ll.push(a1);
        ll.push(a2);
        ll.push(a3);
        Node pop = ll.pop();
        System.out.println(pop);
        ll.list();
    }

}

class LinkStackList {
    private int maxSize;//栈的大小
    private Node head = new Node(0);//数组,模拟栈,数据放在该头节点
    private int top = -1;//标记栈的值
    private Node tmp;

    public LinkStackList(int maxSize) {
        this.maxSize = maxSize;
    }

    //判断栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //判断栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //入栈-push
    public void push(Node node) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        tmp = head;
        while (true) {
            if (tmp.next == null) {
                break;
            }
            tmp = tmp.next;
        }
        tmp.next = node;
        tmp = tmp.next;
    }

    //出栈-pop
    public Node pop() {
        if (isEmpty()) {
            System.out.println("栈空");
            return null;
        }
        top--;
        Node node;
        node = tmp;
        tmp = head;
        while (true) {
            if (tmp.next.next == null) {
                tmp.next = null;
                break;
            }
            tmp = tmp.next;
        }
        return node;
    }

    //    展示
    public void list() {
        tmp = head.next;
        while (tmp != null) {
            System.out.println(tmp);
            tmp = tmp.next;
        }
    }
}

class Node {
    public int id;
    public Node next;

    public Node(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                '}';
    }
}

3、利用栈来实现一个计算器

简单的中缀表达式计算器

这是我们的思路分析

public class Calculator {
    public static void main(String[] args) {

        String expression = "103+2*6-1";
//        int a = Integer.parseInt(expression);
//        System.out.println(a);
        //创建两个栈
        //一个数栈一个符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        //定义相关的变量
        int index = 0;
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';
        String keepNum = "";
        //开始循环的扫描expression
        while (true) {
            //依次得到expression 的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            //开始判断
            if (operStack.isOper(ch)) {
                //如果运算符
                //判断当前符号栈为空
                if (!operStack.isEmpty()) {
                    //不为空处理
                    //进行比较，如果当前的操作符优先级小于或等于栈中的操作符，就要从数栈中pop出两个数
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        //如果这个元素满足
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        //把运算的结果入数栈
                        numStack.push(res);
                        //然后把当前的操作符入符号栈
                        operStack.push(ch);
                    } else {
                        //如果当前的操作符的优先级大于栈中操作符直接入栈
                        operStack.push(ch);
                    }
                } else {
                    //如果为空直接入栈
                    operStack.push(ch);

                }
            } else {
                //因为0在ascii中是48而不是0
//                numStack.push(ch - 48);
                //当入数栈的时候不能发现是一个数就立刻入栈,因为他可能是多位数
                //这样做的话无论多少位也没有关系
                keepNum += ch;
                //如果ch已经是最后一位就直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                    //重要的!!!
                    keepNum = "";
                } else {
                    //判断下一个字符表示数组,如果是数字就继续扫描,如果是运算符,则入栈
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        //如果下一位是运算符则入栈
                        numStack.push(Integer.parseInt(keepNum));
                        //重要的!!!
                        keepNum = "";
                    }
                }
            }
            //让index++,如果字符串没有字符了跳出循环
            index++;
            if (index >= expression.length()) {
                break;
            }
        }

        //当表达式扫描完毕，就顺序从符号栈中去出相应的数和符号,并运行
        while (true) {
            //如果符号栈为空则计算到最后了
            if (operStack.isEmpty()) {
                break;
            }
            //执行最后的运算
            //如果这个元素满足
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            //把运算的结果入数栈
            numStack.push(res);
        }
        int sum = numStack.pop();
        System.out.println(sum);
    }
}

//先创建一个栈,需要扩展一下功能
class ArrayStack2 {
    private int maxSize;//栈的大小
    private int[] stack;//数组,模拟栈,数据放在该数组
    private int top = -1;//标记栈的值

    //构造器
    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        this.stack = new int[this.maxSize];
    }

    //判断栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //判断栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈-push
    public void push(int i) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = i;
    }

    //出栈-pop
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        return stack[top--];
    }

    //展示当前栈顶的元素
    public int peek() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        return stack[top];
    }

    //遍历栈[需要从栈顶开始显示数据]
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空没有数据");
            return;
        }
        //如果从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    //扩展功能:返回运算符的优先级,优先级越高数字越大
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1; //假设当前的表达式只有加减乘除
        }
    }

    //判断是不是一个运算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    //计算方法
    public int cal(int num1, int num2, int oper) {
        int tmp = 0;
        switch (oper) {
            case '+':
                tmp = num1 + num2;
                break;
            case '-':
                tmp = num2 - num1;
                break;
            case '*':
                tmp = num1 * num2;
                break;
            case '/':
                tmp = num2 / num1;
                break;
        }
        return tmp;
    }
}

后缀表达式计算器

代码

首先我们先需要一个把后缀表达式转换为List的方法

//将逆波兰表达式，依次将数据和运算符放入ArrayList中
public static List<String> getListString(String suffixExpression) {
    //将suffixExpression
    String[] split = suffixExpression.split(" ");
    List<String> list = new ArrayList<String>();
    for (String ele : split) {
        list.add(ele);
    }
    return list;
}

然后就是我们真正的计算方法

//完成对逆波兰表达式的运算
//这次我们使用系统提供的栈
public static int calculate(List<String> ls) {
    //创建一个栈,只需要一个栈就ok
    Stack<String> stringStack = new Stack<String>();
    //遍历ls
    for (String item : ls) {
        //这里使用正则表达式
        if (item.matches("\\d+")) {//匹配的是多位数
            //入栈
            stringStack.push(item);
        } else {
            //pop出两个数,并运算,再入栈
            int num2 = Integer.parseInt(stringStack.pop());
            int num1 = Integer.parseInt(stringStack.pop());
            int res = 0;
            if (item.equals("+")) {
                res = num1 + num2;
            } else if (item.equals("-")) {
                res = num1 - num2;
            } else if (item.equals("*")) {
                res = num1 * num2;
            } else if (item.equals("/")) {
                res = num1 / num2;
            } else {
                throw new RuntimeException("运算符有误");
            }
            //把res入栈，把整数转换位字符串
            stringStack.push(res + "");
        }
    }
    //最后留着栈的元素是运算结果
    return Integer.parseInt(stringStack.pop());
}

中缀表达式转后缀表达式

String expression = "1+((2+3)*4)-5";

现在我们的需求是把他转换为后缀表达式的list

思路分析

代码

首先要先将中缀表达式转换为对应的list

//将中缀转换为对应的list
public static List<String> getInfixListString(String s) {
    //定义一个List,存放对应的内容
    List<String> ls = new ArrayList<String>();
    int i = 0; //这是一个指针,用于遍历s
    String str;//做多位数拼接
    char c;//用于存放到c
    do {
        //如果c是一个非数字,我们就需要加入到ls中去
        if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
            ls.add("" + c);
            i++;//i需要后移
        } else {//如果是一个数,需要考虑多位数的问题
            str = "";//先至空
            while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                str += c;//拼接字符串
                i++;
            }
            ls.add(str);
        }
    } while (i < s.length());
    return ls;
}

把中缀list转换为后缀

//将中缀表达式转换为对应的后缀表达式对应的List
public static List<String> parseSuffixExpressionList(List<String> ls){
    //定义1个栈
    Stack<String> s1 = new Stack<String>();//符号栈
    //定义一个链表
    List<String> s2 = new ArrayList<String>();

    //遍历ls
    for(String str : ls){
        //如果是一个数加入s2
        if(str.matches("\\d+")){
            s2.add(str);
        }else if (str.equals("(")) {
            s1.push(str);
        }else if (str.equals(")")) {
            //如果是右括号，依次弹出s1栈顶的运算符，压入s2，直到左括号为止，此时这对括号丢弃
            while (!s1.peek().equals("(")){
                s2.add(s1.pop());
            }
            s1.pop();//!!!将(弹出小括号
        } else {//这个就是判断的来的是运算符的情况
            //当str的优先级小于等于栈顶的优先级
            //问题我们缺失一个优先级方法
            //来一个循环不停的对比来的运算符和s1栈顶的运算符优先级
            while (s1.size() != 0 && Operation.getPriority(s1.peek()) >= Operation.getPriority(str)){
                s2.add(s1.pop());
            }
            //还需要将str压入栈
            s1.push(str);
        }
    }
    //将s1剩余的运算符依次加入s2
    while (s1.size() != 0){
        s2.add(s1.pop());
    }

    return s2;//因为是存放到List因此顺序输出就是对应的逆波兰表达式
}

辅助类

帮助我们判断运算符的优先级

class Operation {
    private static int ADD = 1;
    private static int SUB = 1;
    private static int MUL = 1;
    private static int DIV = 1;

    //写一个方法，返回对应的优先级
    public static int getPriority(String operation){
        int res = 0;
        switch (operation) {
            case "+":
                res = ADD;
                break;
            case "-":
                res = SUB;
                break;
            case "*":
                res = MUL;
                break;
            case "/":
                res = DIV;
                break;
            default :
                break;
        }
        return res;
    }
}
 int SUB = 1;
    private static int MUL = 1;
    private static int DIV = 1;

    //写一个方法，返回对应的优先级
    public static int getPriority(String operation){
        int res = 0;
        switch (operation) {
            case "+":
                res = ADD;
                break;
            case "-":
                res = SUB;
                break;
            case "*":
                res = MUL;
                break;
            case "/":
                res = DIV;
                break;
            default :
                break;
        }
        return res;
    }
}