[从今天开始修炼数据结构]栈、斐波那契数列、逆波兰四则运算的实现

[从今天开始修炼数据结构]基本概念

[从今天开始修炼数据结构]线性表及其实现以及实现有Itertor的ArrayList和LinkedList

[从今天开始修炼数据结构]栈、斐波那契数列、逆波兰四则运算的实现

[从今天开始修炼数据结构]队列、循环队列、PriorityQueue的原理及实现

一、栈的定义

  栈是限定仅在表尾进行插入和删除操作的线性表。允许插入和删除的一端称为栈顶(top),另一端称为栈底(bottom)。栈又称后进先出的线性表,简称LIFO结构。

  注意:首先它是一个线性表,也就是说栈元素有前驱后继关系。

  栈的插入操作,叫做进栈,也称压栈、入栈

  栈的删除操作,叫做出栈,也叫弹栈。

  注意:最先入栈,不代表就要最后出栈。因为栈没有限制出栈的时间,例如可以先入栈两个元素,再出栈两个元素,后入栈其他元素。

二、栈的抽象数据类型

  

ADT Stack
Data
    同线性表。元素具有相同的类型,相邻元素具有前驱和后继。
Operation
    InitStack(S) : 初始化操作,建立一个空栈
    DestroyStack(S):若栈存在,销毁它。
    ClearStack(S):将栈清空
    StackEmpty:若栈为空,返回true,否则返回false。
    GetTop(S,e):若栈存在且非空,用e返回栈顶元素。
    Push(S,e):若栈S存在,插入新元素e到栈顶
    Pop(S,e):删除S中栈顶元素,并用e返回其值
    StackLength(S):返回栈S中的元素个数
endADT

三、栈的顺序结构

1,栈的顺序存储结构是什么样子

  栈的顺序存储结构也是用数组来实现的。让下标0的一端作为栈底,另一端作为栈顶。若存储栈的长度为StackSize,则栈顶位置top必须小于StackSize。当栈存在一个元素时,top = 0.因此通常把空栈的判定条件定为top = - 1。

2,顺序结构栈的实现

package Stack;

public class ArrayStack<T>{
    private Object[] list;
    private int top;
    private int size;
    private static int DEFAULT_SIZE = 10;

    public ArrayStack(int size){
        list = new Object[size];
        this.size = size;
        top = -1;
    }

    public ArrayStack(){
        this(DEFAULT_SIZE);
    }

    public void push(T data){

        if (!isFull()){
                list[++top] = data;
        }else {
            System.out.println("栈满了");
        }
    }

    public T pop(){
        if (!isEmpty()){
                T obj = (T)list[top];
                list[top] = null;
                top--;
                return obj;

        }else {
            System.out.println("栈是空的");
        }
        return null;
    }

    private boolean isEmpty(){
        return top == -1;
    }

    private boolean isFull() {
        return top >= size;
    }

    public int size(){
        return size;
    }

    public int getTop(){
        return top;
    }
}

 四、共享栈

  1,共享栈是指两栈共享一片空间的栈。如下图所示

 

 

   两个栈共用一块数组,以两头为栈底,中间为栈顶。可以节省空间。判断满的方法是top1 + 1 = top2.

 

  2,共享栈的实现。

package Stack;

public class ShareStack<T> {
    private Object[] list;
    private int top1;
    private int top2;
    private int capacity;
    private static int DEFAULT_SIZE = 10;
    //private boolean isFull = false;

    public ShareStack(int capacity){
        list = new Object[capacity];
        this.capacity = capacity;
        top1 = -1;
        top2 = capacity;
    }

    public ShareStack(){
        this(DEFAULT_SIZE);
    }

    public boolean pushStackOne(T data){
        if (!isFull()){
            list[++top1] = data;
            //isFull = isFull();
            return true;
        }else{
            System.out.print("栈满了!");
            return false;
        }
    }

    public boolean pushStackTwo(T data){
        if (!isFull()){
            list[--top2] = data;
            //isFull = isFull();
            return true;
        }else{
            System.out.print("栈满了!");
            return false;
        }
    }

    public T popStackOne(){
        if (!isEmptyOne()){
            T data = (T)list[top1--];
            return data;
        }else {
            System.out.println("栈一是空的!");
            return null;
        }
    }

    public T popStackTwo(){
        if (!isEmptyTwo()){
            T data = (T)list[top2++];
            return data;
        }else {
            System.out.println("栈二是空的!");
            return null;
        }
    }

    private boolean isEmptyTwo() {
        return top2 == capacity;
    }

    private boolean isFull() {
        return top1 == (top2 - 1);
    }

    private boolean isEmptyOne(){
        return top1 == -1;
    }

}

五、栈的链式存储及实现 

  1,栈的链式存储简称链栈,把栈顶放在单链表的头部。如下图

 

 

 2,链栈的实现

public class LinkedStack<T> {
    private Node<T> top;

    public void push(T data){
        Node<T> newNode = new Node<>(data, null);
        Node<T> t = top;
        top = newNode;
        top.next = t;
    }

    public T pop(){
        Node<T> t = top;
        if (!isEmpty()){
            top = top.next;
            return t.data;
        }else {
            System.out.println("栈为空!");
            return null;
        }
    }

    private boolean isEmpty() {
        return top == null;
    }

    private class Node<T> {
        private T data;
        private Node next;

        public Node(T data, Node<T> next){
            this.data = data;
            this.next = next;
        }
    }

}

以表头为栈顶,降低了弹栈操作的时间复杂度。若以表尾为栈顶则弹栈只能遍历找到top-1位置,或者用双向链表牺牲空间。如下

 public T pop(){
        if (!isEmpty()){
            Node<T> newTop = bottom;
            while (newTop.next != top){
                newTop = newTop.next;
            }
            T data = top.data;
            top = newTop;
            top.next = null;
            return data;
        }else {
            System.out.println("栈是空的!");
            return null;
        }
    }

五、栈的应用 —— 递归

1,斐波那契数列的递归实现

  引例:如果兔子在出生两个月后就有繁殖能力,一对兔子每个月能生出一对小兔子。假设所有兔子都不死,那么一年后有多少对兔子?分析得出兔子数量按天数增加如下表

所经过的月数 1 2 3 4 5 6 7 8 9 10 11 12
兔子对数 1 1 2 3 5 8 13 21 34 55 89 144

表中数列有明显的特点:相邻前两项之和等于后一项。抽象成函数表达如下

 

 

 迭代实现如下:

public class Fibonacci {
public static void main(String[] args) throws Exception {
System.out.println(Fibonacci(12));
}

public static int Fibonacci(int month) throws Exception {
if (month < 0){
throw new Exception();
}
if (month < 2){
return month == 0 ? 0 : 1;
}else {
return (Fibonacci(month - 1) + Fibonacci(month - 2));
}
}
}

代码执行过程如下:

  

 

递归实现法的时间复杂度为O(2n),太高,还可能会引起内存栈溢出,所以应该用别的方法求解。这篇文章主要讲由栈引出递归,所以先挖个坑,在后面的文章中我会单独讨论递归和斐波那契数列的其他解法。

参考:https://blog.csdn.net/sofia_m/article/details/78796084

https://blog.csdn.net/IronWring_Fly/article/details/100050016

https://blog.csdn.net/Bob__yuan/article/details/84956740

2,在前行阶段,对于每一层递归,函数的局部变量、参数值以及返回地址都被压入栈中。在退回阶段,位于栈顶的局部变量、参数值和返回地址被弹出,用于返回调用层次中执行代码的其余部分,也就是恢复了调用的状态。

六、栈的应用 —— 四则运算表达式求值

1,后缀(逆波兰)表示法定义

  对于会计计算器,不能表达复杂的带括号和多种运算符号复合的表达式;而对于科学计算器,我们可以一次将一个复杂的带括号的四则运算输入进去,计算器是怎么做到的呢?

  这就引入了一种不需要括号的后缀表达法 —— 逆波兰表达法。举个例子来看 对于 “ 9 + ( 3 - 1) * 3 + 10 / 2”这个表达式,转换成后缀表达式应该变为 “ 9 3 1 - 3 * + 10 2 / + ”。 叫做后缀的原因就是所有的符号都在被运算的数字后面出现。

2,我们先来看看后缀表达式是如何计算的 

  规则: 从左到右遍历表达式的每个数字和符号,遇到数字就进栈,遇到符号,就把数字栈栈顶的两个数字出栈,栈顶元素放在运算符后面,栈顶下面一个元素放在运算符前面。再将运算结果进栈,如此往复,直到获得最终结果。

  步骤精解:我们以上面的 “ 9 3 1 - 3 * + 10 2 / + ” 为例

  (1)初始化一个空栈,用来对要运算的数字进行进出使用

  (2)后缀表达式中前三个都是数字,所以将9 3 1 依次进栈。

 

 

   (3)接下来是运算符“ - ”,所以将1, 3 出栈,运算3 - 1得到2 ,将2进栈,然后遇到3 ,将3进栈

 

 

   (4)后面遇到“ * ”,将3, 2出栈,计算2 * 3,得到6,将6进栈

 

 

  (5)遇到“ + ”,将6 , 9出栈,计算9 + 6,得到15,将15进栈

 

 

   (6)将10, 2 进栈

 

 

   (7)遇到符号“ / ” 将2, 10出栈,计算10/2得到5,将5压栈

 

   (8)最后一个符号 “ + ”,将15,5出栈,计算15 + 5,得到20,将20压栈

 

   (9)表达式读取完成,将结果20出栈,栈变为空。

这就是通过后缀表达式计算四则运算的结果。那么下面我们再来讨论如何将中缀表达式(也就是我们平时数学课上计算的形式)转换为方便计算机运算的后缀表达式呢?

3,中缀转后缀

  规则:从左到右遍历中缀表达式,如果是数字就存入后缀表达式,如果是符号就判断其与栈顶符号的优先级,如果优先级不高于栈顶符号,则栈顶元素依次出栈并输出,并将当前符号进栈。特殊的,遇到左括号就进栈,左括号的优先级不做判断;当遇到右括号时,将与其匹配的左括号以上的全部符号依次出栈。直到最终输出后缀表达式为止。

  具体步骤:我们还是以上面的 “ 9 + ( 3 - 1) * 3 + 10 / 2”这个表达式为例

  (1)初始化一个空栈。遇到第一个字符是数字9,输出9,遇到符号“ + ”,进栈。

 

   (2)遇到字符“ ( ”进栈,然后遇到了数字3,输出,又遇到了符号“ - ”,进栈。如下图

 

   (3)遇到符号“  ) ”,根据规则,匹配前面的“ ( ”,并将其上的符号依次出栈并输出,直到“ ( ”出栈。

 

   (4)下面遇到了符号“ * ”,比较其与栈顶元素 “ + ”的优先级。* 的优先级更高,所以压栈。 后面遇到了数字3 ,输出。

 

   (5)之后遇到了符号 “ + ”,与栈顶元素“ * ”比较, + 的优先级低,所以将 * 弹栈,再与现在的栈顶 + 比较,与新来的 + 优先级相同,所以将栈顶+也出栈,将新来的 + 弹栈。如下图

 

   (6)紧接着数字10,输出,后面是符号“ / ”,进栈。 最后一个数字2 输出。原表达式读取完成,将栈内剩余的符号都出栈,得到

 

 4,实现逆波兰四则运算(静态方法调用)

package Stack;

import java.util.Stack;
import java.util.regex.Pattern;

public class RPNmethod {
    private static Stack<String> charStack = new Stack<>();
    private static Stack<Integer> intStack = new Stack<>();

    public static int RPN(String exp){
        String behindEXP = convert(exp);
        String[] chars = behindEXP.split(" ");
        for (int i = 0; i < chars.length; i++){
            String thisOne = chars[i];
            if (isNum(thisOne)){
                intStack.push(Integer.parseInt(thisOne));
            }else if (isSymbol(thisOne)){
                int a = intStack.pop();
                int b = intStack.pop();
                int result;
                switch (thisOne){
                    case "+": result = b + a;
                        intStack.push(result);
                        break;
                    case "-": result = b - a;
                        intStack.push(result);
                        break;
                    case "*": result = b * a;
                        intStack.push(result);
                        break;
                    case "/": result = b / a;
                        intStack.push(result);
                        break;
                }
            }
        }
        return intStack.pop();
    }

    /**
     * 将中缀表达式转为后缀表达式
     * @param middle
     * @return
     */
    private static String convert(String middle){
        String rpnEXP = "";
        String[] chars = middle.split(" ");
        for(int i = 0; i < chars.length; i++){
            String thisOne = chars[i];
            if (isNum(thisOne)){
                rpnEXP = rpnEXP + thisOne + " ";
            }else if (isSymbol(thisOne)) {
                /*
                三个分支 : 是左括号,是右括号,不是括号
                 */
                if (isLeftPar(thisOne)) {
                    charStack.push(thisOne);
                } else if (isRightPar(thisOne)) {//Here
                    while (!isLeftPar(thisOne)) {
                        thisOne = charStack.pop();
                        if (!isLeftPar(thisOne)) {
                            rpnEXP = rpnEXP + thisOne + " ";
                        }
                    }
                } else {
                    if (charStack.isEmpty() || !lowerPriority(thisOne, charStack.peek())) {
                        charStack.push(thisOne);
                    } else {
                        do {
                            rpnEXP = rpnEXP + charStack.pop() + " ";
                        }
                        while (!charStack.isEmpty() && lowerPriority(thisOne, charStack.peek()));
                        charStack.push(thisOne);
                    }
                }
            }
        }
        while(!charStack.isEmpty()){
            rpnEXP = rpnEXP + charStack.pop() + " ";
        }
        return rpnEXP;
    }

    private static boolean isLeftPar(String aChar) {
        return aChar.equals("(");
    }

    /**
     * 返回新来的优先级是不是不大于栈顶.aChar > peek 就返回false,peek >= aChar 就返回true
     * @param aChar
     * @param peek
     * @return 返回true就弹栈,返回false就将新来的压栈
     */
    private static boolean lowerPriority(String aChar, String peek) {
        if(peek.equals("(")){
            return false;
        }
        else if (aChar.equals("+") || aChar.equals("-")){
            return true;
        }else {
            if (peek.equals("*") || peek.equals("/")){
              return true;
            }else {
                return false;
            }
        }
    }

    private static boolean isRightPar(String c) {
        return c.equals(")");
    }

    private static boolean isNum(String c){
        Pattern pattern = Pattern.compile("[\\d]*$");
        return pattern.matcher(c).matches();
    }

    private static  boolean isSymbol(String c){
        String pattern = "[-/*+()]";
        return Pattern.matches(pattern,c) ;
    }
}

 


 

 

posted @ 2019-12-01 17:32  Joey777210  阅读(...)  评论(...编辑  收藏