Loading

数据结构与算法(五):栈

前面几篇文章主要是数据结构相关内容,我们介绍了数组、链表、树和二叉树等常用数据结构,本章我们再介绍一个常用数据结构 栈

数据结构与算法(一):复杂度分析

数据结构与算法(二):数组

数据结构与算法(三):链表

数据结构与算法(三):链表经典面试题

数据结构与算法(四):树和二叉树

什么是栈?

栈的定义

堆栈(stack)又称为堆叠,是计算机科学里最重要且最基础的数据结构之一,它按照FILO(First In Last Out,后进先出)的原则存储数据。

关于“栈”,有一个非常贴切的例子,就是一摞叠在一起的盘子。我们平时放盘子的时候,都是从下往上一个一个放;取的时候,我们也是从上往下一个一个地依次取,不能从中间任意抽出。后进者先出,先进者后出,这就是典型的“栈”结构

栈

栈的相关概念

栈和栈帧
  • 栈顶栈底:允许元素插入与删除的一端称为栈顶,另一端称为栈底
  • 压栈:栈的插入操作,叫做进栈,也称压栈、入栈
  • 弹栈:栈的删除操作,也叫做出栈

为什么需要栈?

  • 栈是一种“操作受限”的线性表,只允许在一端插入和删除数据,其操作特性用数组和链表均可实现。

  • 任何数据结构都是对特定应用场景的抽象,数组和链表虽然使用起来更加灵活,但却暴露了几乎所有的操作,难免会引发错误操作的风险。

  • 当某个数据集合只涉及在某端插入和删除数据,且满足后进者先出,先进者后出的操作特性时,我们应该首选栈这种数据结构。

如何实现栈?

1、栈的API

从刚才栈的定义里,我们可以看出,栈主要包含两个操作,入栈和出栈,也就是在栈顶插入一个数据和从栈顶删除一个数据。理解了栈的定义之后,我们看看栈主要有哪些API调用:

public class Stack<T> {
    
    //压栈T
    public void push(T t){}
    
    //弹栈
    public T pop(){}
    
    //是否为空
    public boolean isEmpty(){}
    
    //栈中数据的数量
    public int size(){}
    
    //返回栈中最近添加的元素而不删除它
    public T peek(){}
}

2、数组实现顺序栈

代码

public class Stack {
    private int size = 0;
    private int[] array;
    public Stack() {
        this(10);
    }
    public Stack(int init) {
        if (init <= 0) {
            init = 10;
        }
        array = new int[init];
    }
    /**
      * 入栈
      * @param item 入栈元素的值
    */
    public void push(int item) {
        if (size == array.length) {
            array = Arrays.copyOf(array, size * 2);
        }
        array[size++] = item;
    }
    /**
      * 获取栈顶元素,但是没有出栈
      * @return
      */
    public int peek() {
        if (size == 0) {
            throw new IndexOutOfBoundsException("栈里已经空啦");
        }
        return array[size - 1];
    }
    /**
      * 出栈,同时获取栈顶元素
      * @return
      */
    public int pop() {
        int item = peek();
        size --; // 直接使元素个数减1,不需要真的清除元素,下次入栈会覆盖旧元素值
        return item;
    }
    /**
      * 栈是否满了
      * @return
      */
    public boolean isFull() {
        return size == array.length;
    }
    /**
      * 栈是否为空栈
      * @return
      */
    public boolean isEmpty() {
        return size == 0;
    }
    public int size() {
        return size;
    }
}

了解了定义和基本操作,那它的操作的时间、空间复杂度是多少呢?

不管是顺序栈还是链式栈,我们存储数据只需要一个大小为 n 的数组就够了。在入栈和出栈过程中,只需要一两个临时变量存储空间,所以空间复杂度是 O(1)。

注意,这里存储数据需要一个大小为 n 的数组,并不是说空间复杂度就是 O(n)。因为,这 n 个空间是必须的,无法省掉。所以我们说空间复杂度的时候,是指除了原本的数据存储空间外,算法运行还需要额外的存储空间

3、链表实现链式栈

链表实现栈

public class LinkStack {

    /**
     * 定义链栈的结点
     * Object类型的数据域
     * Node类型的指针域
     *
     */
    private class Node {
        Object data;
        Node next;

        public Node() {
        }

        public Node(Object data, Node next) {
            this.data = data;
            this.next = next;
        }
    }

    private Node top;   //栈顶元素
    private int size;   //当前栈的大小

    /**
     * 创建空链栈
     */
    public LinkStack() {
        top = null;
    }

    /**
     * 以data数据元素创建链式栈
     *
     * @param data
     */
    public LinkStack(Object data) {
        top = new Node(data, null);
        size++;
    }

    /**
     * 判断链栈是否为空栈
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0 ? true : false;
    }

    /**
     * 返回链栈的长度
     *
     * @return
     */
    public int length() {
        return size;
    }

    /**
     * 压栈(入栈)
     *
     * @param data
     */
    public void push(Object data) {
        // 让top指向新创建的元素,新元素的next引用指向原来的栈顶元素
        top = new Node(data, top);
        size++;
    }

    /**
     * 出栈
     *
     * @return
     */
    public Object pop() {

        if (isEmpty()) {
            System.out.println("目前是空栈,无法进行出栈!");
            return "error!";
        }
        Node temp = top;
        // 更新头结点
        top = top.next;
        // 释放原栈顶元素的next引用,删除指针指向
        temp.next = null;
        size--;
        return temp.data;
    }

    /**
     * 访问栈顶元素
     *
     * @return
     */
    public Object peek() {
        if (top != null) {
            return top.data;
        }
        return "空栈,无栈顶元素!";
    }

    /**
     * 遍历栈并打印栈内元素
     */
    public void displayStack() {
        while (top != null) {
            System.out.println(top.data + "\t");
            top = top.next;
        }
    }

    /**
     * 清空栈
     */
    public void clear() {
        top = null;
        size = 0;
    }
}

栈的应用

1、栈在函数调用中的应用

栈作为一个比较基础的数据结构,应用场景还是蛮多的。其中,比较经典的一个应用场景就是函数调用栈

我们知道,操作系统给每个线程分配了一块独立的内存空间,这块内存被组织成“栈”这种结构, 用来存储函数调用时的临时变量。每进入一个函数,就会将临时变量作为一个栈帧入栈,当被调用函数执行完成,返回之后,将这个函数对应的栈帧出栈。为了让你更好地理解,我们一块来看下这段代码的执行过程。

int main() {
   int a = 1; 
   int ret = 0;
   int res = 0;
   ret = add(3, 5);
   res = a + ret;
   printf("%d", res);
   reuturn 0;
}

int add(int x, int y) {
   int sum = 0;
   sum = x + y;
   return sum;
}

从代码中我们可以看出,main() 函数调用了 add() 函数,获取计算结果,并且与临时变量 a 相加,最后打印 res 的值。为了让你清晰地看到这个过程对应的函数栈里出栈、入栈的操作,我画了一张图。图中显示的是,在执行到 add() 函数时,函数调用栈的情况。

栈帧

2、栈在表达式求值中的应用

再来看栈的另一个常见的应用场景,编译器如何利用栈来实现表达式求值

为了方便解释,我将算术表达式简化为只包含加减乘除四则运算,比如:34+13*9+44-12/3。对于这个四则运算,我们人脑可以很快求解出答案,但是对于计算机来说,理解这个表达式本身就是个挺难的事儿。如果换作你,让你来实现这样一个表达式求值的功能,你会怎么做呢?

实际上,编译器就是通过两个栈来实现的。其中一个保存操作数的栈,另一个是保存运算符的栈。我们从左向右遍历表达式,当遇到数字,我们就直接压入操作数栈当遇到运算符,就与运算符栈的栈顶元素进行比较

如果比运算符栈顶元素的优先级高,就将当前运算符压入栈;如果比运算符栈顶元素的优先级低或者相同,从运算符栈中取栈顶运算符,从操作数栈的栈顶取 2 个操作数,然后进行计算,再把计算完的结果压入操作数栈,继续比较。

将 3+5*8-6 这个表达式的计算过程画成了一张图,你可以结合图来理解计算过程。

栈辅助运算

代码


3、检测代码中括号匹配问题

题目

给定一个只包括 '(',')','{','}','[',']' 的字符串,判断字符串是否有效。

有效字符串需满足:
	1、左括号必须用相同类型的右括号闭合。
	2、左括号必须以正确的顺序闭合。
	
注意空字符串可被认为是有效字符串。

解题分析

这是一个使用栈解决的经典的问题:思路就是创建一个栈,遇到左括号时就入栈,遇到右括号时就弹出栈顶元素,看当前的括号是否与弹出的匹配,只要有一次不匹配,就返回false,最后检查该栈是否为空即可。

img

代码

class Solution {
    public boolean isValid(String s) {

        HashMap<Character,Character> map = new HashMap<Character, Character>();
        map.put('}','{');
        map.put(']','[');
        map.put(')','(');

        Stack<Character> stack = new Stack<Character>();
        for (char c : s.toCharArray()) {
            if (map.containsKey(c)){
                if (stack.isEmpty() || !stack.pop().equals(map.get(c))){
                    return false;
                }
            }else {
                stack.push(c);
            }
        }

        if (!stack.isEmpty()){
            return false;
        }

        return true;
    }
}

总结

  • 栈是一种常用数据结构,遵循先进后出的原则
  • 与数组相比,栈的操作是受限的,只能从头部入栈和出栈
  • 栈可以由数组实现顺序栈,栈可以由链表实现链式栈
  • 栈这种数据结构只需要知道其大概特性和常用API,至于对栈的深入理解和运用最好还是通过相关题目
  • 记住百闻不如一见,百看不如一练

参考文章

posted @ 2020-11-13 19:46  PinGoo  阅读(420)  评论(0编辑  收藏  举报