栈

根据尚硅谷的韩顺平老师的数据结构视频总结的笔记

观看视频的网址

 

栈的实际需求

请输入一个表达式

计算式:[7*2*2-5+1-5+3-3] 点击计算【如下图】

请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算,因为我们看这个算式 7 * 2 * 2 - 5, 但是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，我们讨论的是这个问题。-> 栈

 

一、栈的介绍

1）栈的英文为(stack)

2）栈是一个先入后出(FILO-First In Last Out)的有序列表

3）栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。

4）根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

5）出栈（pop）和 入栈（push） 的概念

 

 

二、栈的应用场景

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

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

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

4）二叉树的遍历。

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

 

三、栈的入门

1、利用数组实现栈

代码实现:

package stack;

import java.util.Scanner;

/**
 * @description:    利用数组来实现栈
 * @auther:田坤
 * @date 2020/10/7 11:09
 **/
public class ArrayStackDemo {
    public static void main(String[] args) {
        //测试
        ArrayStack arrayStack = new ArrayStack(5);
        String key = "";
        int count ;
        boolean flag = true;    //用于控制循环的开关
        Scanner sc = new Scanner(System.in);
        while (flag){
            System.out.println("show:显示栈数据");
            System.out.println("push:向栈中加入数据");
            System.out.println("pop:从栈顶取出数据");
            System.out.println("exit:退出");
            key = sc.next();
            switch (key){
                case "show":
                    arrayStack.list();
                    break;
                case "push":
                    System.out.println("请你输入一个数据:");
                    count = sc.nextInt();
                    arrayStack.push(count);
                    break;
                case "pop":
                    try {
                        int value = arrayStack.pop();
                        System.out.println("从栈中取出的数据为："+value);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    sc.close();
                    flag = false;
                    break;
                    default:
                        break;

            }
        }
        System.out.println("程序结束！");
    }
}

//  定义一个ArrayStack表示栈
class ArrayStack{
    private int maxSize;    //表示栈的大小
    private int[] stack;    //模拟栈的数组
    private int top = -1;   //top表示栈顶，没有数据时(初始化时为 -1)

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

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

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

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

    //出栈 - pop  从栈顶取出数据
    public int pop(){
        if(isEmpty()){
            //异常就表示终止程序，不需要加return
            throw new RuntimeException("栈为空");
        }
        int value = stack[top--];
        return value;
    }

    //遍历打印栈  从栈顶到栈底
    public void list(){
        if(isEmpty()){
            System.out.println("栈为空");
            return;
        }
        for (int i = top; i >= 0 ; i--) {
            System.out.println("stack["+i+"]="+stack[i]);
        }
    }
}

 

2、利用链表来实现

package stack;

import java.util.Scanner;

/**
 * @description:    利用单链表实现栈
 * @auther:田坤
 * @date 2020/10/7 12:20
 **/
public class LinkedStackDemo {
    public static void main(String[] args) {
        //测试
        LinkedStack linkedStack = new LinkedStack();
        String key = "";
        int count ;
        boolean flag = true;    //用于控制循环的开关
        Scanner sc = new Scanner(System.in);
        while (flag){
            System.out.println("show:显示栈数据");
            System.out.println("push:向栈中加入数据");
            System.out.println("pop:从栈顶取出数据");
            System.out.println("exit:退出");
            key = sc.next();
            switch (key){
                case "show":
                    linkedStack.list();
                    break;
                case "push":
                    System.out.println("请你输入一个数据:");
                    count = sc.nextInt();
                    linkedStack.push(count);
                    break;
                case "pop":
                    try {
                        count = linkedStack.pop();
                        System.out.println("从栈中取出的数据为："+count);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    sc.close();
                    flag = false;
                    break;
                default:
                    break;

            }
        }
        System.out.println("程序结束！");
    }
}

//创建链表栈类
class LinkedStack{
    private SingleLinkedStack head = new SingleLinkedStack();   //头结点

    //判断栈是否为空
    public boolean isEmpty(){
        return head.getNext()==null;
    }

    //因为是链表，所以不会存在链表满的情况

    //入栈 push 使用头插法
    public void push(int num){
        SingleLinkedStack temp = head;
        SingleLinkedStack node = new SingleLinkedStack(num);
        node.setNext(temp.getNext());
        temp.setNext(node);
    }

    //出栈 -pop
    public int pop(){
        if(head.getNext() == null){
            throw  new RuntimeException("链表为空，无法出栈");
        }
        SingleLinkedStack temp = head;
        int value = temp.getNext().getNum();
        temp.setNext(temp.getNext().getNext());
        return value;
    }

    //遍历
    public void list(){
        if(head.getNext() == null){
            System.out.println("链表为空！");
            return;
        }
        SingleLinkedStack temp = head.getNext();
        while (true){
            if(temp == null)
                break;
            System.out.println(temp.getNum());
            temp = temp.getNext();
        }
    }
}


//创建一个单链表类
class SingleLinkedStack{
    private int num;
    private SingleLinkedStack next;

    //构造器
    public SingleLinkedStack(){

    }
    public SingleLinkedStack(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public SingleLinkedStack getNext() {
        return next;
    }

    public void setNext(SingleLinkedStack next) {
        this.next = next;
    }
}