栈

栈

基本概念：

栈是一种受限的只允许在栈顶进行插入和删除操作的数据结构，符合先进后出的特性。js中并没有栈，但是可以使用Array模拟实现栈的所有功能。

面试题

有六个元素6,5,4,3,2,1的顺序进栈，问下列哪一个不是合法的出栈序列？（）

A：5 4 3 6 1 2 B：4 5 3 2 1 6 C：3 4 6 5 2 1 D：2 3 4 1 5 6

模拟实现栈：

首先需要知道栈的常用操作：

（1）push。

（2）pop。

（3）peek：返回栈顶的元素，但是与pop不同的是它不会删除栈顶的元素，仅仅只是返回它。

（4）isEmpty：如果栈里没有任何元素就返回true，否则返回false。

（5）size：与数组的length属性类似。

（6）toString：将栈结构的内容以字符串形式返回。

function Stack() {
    this.items = [];
    //栈的常用操作
    //1，push
    Stack.prototype.push = function (element) {
        this.items.push(element);
    };

    //2，pop
    Stack.prototype.pop = function () {
        return this.items.pop();
    };

    //3，peek
    Stack.prototype.peek = function () {
        return this.items[this.items.length - 1];
    };

    //4，isEmpty
    Stack.prototype.isEmpty = function () {
        return this.items.length === 0;
    };

    //5，size
    Stack.prototype.size = function () {
        return this.items.length;
    };

    //6，toString
    Stack.prototype.toString = function () {
        let resultString = "";
        for (let i = 0; i < this.items.length; i++) {
            resultString += this.items[i] + " ";
        }
        return resultString;
    };
}

let stack = new Stack();
//下面我们来测试一下
stack.push(10);
stack.push(20);
console.log(stack); //[10, 20]

stack.pop();
console.log(stack); //[10]

console.log(stack.peek()); //[10]

console.log(stack.isEmpty()); //false

console.log(stack.size()); //1

console.log(stack.toString()); //'10'

练习一：十进制转二进制

function dec2bin(decNumber) {
    //1，新建一个栈用于存储每次获得的余数
    let stack = [];

    //2，循环操作
    while (decNumber > 0) {
        //3，将每次获得的余数push进栈中
        stack.push(decNumber % 2);

        //4，获取每次整除后的结果并将其作为下一次运行的数字
        decNumber = Math.floor(decNumber / 2);
    }

    //5，最后将栈中的所有元素倒序输出
    let result = "";
    while (stack.length) {
        result += stack.pop() + "";
    }
    return result;
}

//测试一下
console.log(dec2bin(100)); //1100100

练习二：leetcode 20 有效的括号

解题思路：新建一个栈，扫描字符串，将遇到的左括号入栈，遇到和栈顶括号类型匹配的右括号就出栈，类型不匹配直接判定为不合法。

function isValid(s) {
    //s的长度如果是奇数，那么直接返回false
    if (s.length % 2 === 1) {
        return false;
    }
    //新建一个栈
    let stack = [];
    //遍历s并将所有左括号入栈
    for (let item of s) {
        if (item === "(" || item === "{" || item === "[") {
            stack.push(item);
        } else {
            //获取到栈顶的元素
            let stackPeek = stack[stack.length - 1];
            //如果栈顶的元素与右括号相匹配，则将该左括号出栈
            if (
                (stackPeek === "(" && item === ")") ||
                (stackPeek === "{" && item === "}") ||
                (stackPeek === "[" && item === "]")
            ) {
                stack.pop();
            } else {
                return false;
            }
        }
    }
    //最后判断栈是否为空
    return stack.length === 0 ? true : false;
}

//测试一下
console.log(isValid("({}")); //false

前端与栈：js中的函数调用栈

function test1() {
    test2()
}

function test2() {
    test3()
}

function test3() {
    console.log('test')
}

test1()

上面我们模拟实现了js中函数调用栈，可以看到最先被调用的但是却最后才被执行，这就完全符合了栈的先进后出特性。