客栈的运用——用JavaScript形貌数据结构

2019年8月22日 147次阅读来源: leon

栈（stack）别名客栈，它是一种运算受限的线性表。其限定是
仅许可在表的一端举行插进去和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。

一、完成一个栈类Stack

基于客栈的特征，能够用数组做线性表举行存储。
初始化Stack类的构造以下：

function Stack(){
    this.space = [];
}

Stack.prototype = {
    constructor: Stack,
    /* 接口code */
};

接下来，就是在原型上，对入栈、出栈、清空栈、读取栈顶、读取悉数栈数据这几个接口的完成。
Stack类默许以数组头部做栈底，尾部做栈顶。

1.1 入栈 `push`

入栈能够运用js数组的push要领，在数组尾部压入数据。

Stack.prototype = {
    push: function(value){
        return this.space.push(value);
    }
}

1.2 出栈 `pop`

出栈同样是运用js数组的pop要领，在数组尾部推出数据。

Stack.prototype = {
    pop: function(){
        return this.space.pop();
    }
}

1.3 清空栈 `clear`

清空栈相对简朴，将存储数据的数组重置为空数组即可。

Stack.prototype = {
    clear: function(){
        this.space = [];
    }
}

1.4 读取栈顶`readTop`

读取栈顶数据，采纳数组下标的体式格局举行猎取。带来的一个优点就是：下标超越数组有用局限时，返回值为undefined。

Stack.prototype = {
    readTop: function(){
        return this.space[this.space.length - 1];
    }
}

1.4 读取悉数栈`read`

读取悉数栈数据，直接返回当前数组即可。

Stack.prototype = {
    read: function(){
        return this.space;
    }
}

1.5 聚合

末了，将一切功用聚合后，以下所示，一个客栈的数据构造就搞定了。

function Stack(){
    this.space = [];
}

Stack.prototype = {
    constructor: Stack,
    push: function(value){
        return this.space.push(value);
    },
    pop: function(){
        return this.space.pop();
    },
    clear: function(){
        this.space = [];
    },
    readTop: function(){
        return this.space[this.space.length - 1];
    },
    read: function(){
        return this.space;
    }
};

二、实战

学数据构造和算法是为了更好、更高效力地处置惩罚工程题目。
这里学以致用，供应了几个实在的案例，来体会下数据构造和算法的魅力:)

2.1 数组`reverse`的完成

当前案例，将用客栈来完成数组的反转功用。

function reverse(arr){
    var ArrStack = new Stack();

    for(var i = arr.length - 1; i >= 0; i--){
        ArrStack.push(arr[i]);
    }

    return ArrStack.read();
}

如代码所示，可分为以下几个步骤：

实例化一个客栈用于存储数据
将传入的数组举行倒序遍历，并逐一压入客栈
末了运用read接口，输出数据

彷佛很简朴，不必忧郁，庞杂的在背面:)

2.2 十进制转换为二进制

数值转换进制的题目，是客栈的小试牛刀。
解说转换要领前，先来看一个小例子：

将十进制的13转换成二进制

    2 | 13      1
      ￣￣￣
    2 |  6      0
      ￣￣￣
    2 |  3      1
      ￣￣￣￣
         1      1

如上所示：13的二进制码为1101。
将手工换算，变成客栈存储，只需将对2取余的效果顺次压入客栈保留，末了反转输出即可。

function binary(number){
    var tmp = number;
    var ArrStack = new Stack();

    if(number === 0){
        return 0;
    }

    while(tmp){
        ArrStack.push(tmp % 2);
        tmp = parseInt(tmp / 2, 10);
    }

    return reverse(ArrStack.read()).join('');
}

binary(14); // 输出=> "1110"
binary(1024); // 输出=> "10000000000"

2.3 表达式求值

这个案例，实在能够明白为简化版的eval要领。
案例内容是对1+7*(4-2)的求值。

进入主题前，有必要先相识以下的数学理论：

中缀示意法（或中缀记法）是一个通用的算术或逻辑公式示意要领，操纵符是以中缀情势处于操纵数的中心（例：3 + 4）。
逆波兰示意法（Reverse Polish notation，RPN，或逆波兰记法），是一种是由波兰数学家扬·武卡谢维奇1920年引入的数学表达式体式格局，在逆波兰记法中，一切操纵符置于操纵数的背面，因而也被称为后缀示意法。逆波兰记法不需要括号来标识操纵符的优先级。
通例中缀记法的“3 – 4 + 5”在逆波兰记法中写作“3 4 – 5 +”
调理场算法（Shunting Yard Algorithm）是一个用于将中缀表达式转换为后缀表达式的典范算法，由艾兹格·迪杰斯特拉引入，因其操纵类似于火车编组场而得名。
提早申明，这只是简朴版完成。所以划定有两个：
数字请求为整数
不许可表达式中涌现过剩的空格

完成代码以下：

function calculate(exp){
    var valueStack = new Stack(); // 数值栈
    var operatorStack = new Stack(); // 操纵符栈 
    var expArr = exp.split(''); // 切割字符串表达式
    var FIRST_OPERATOR = ['+', '-']; // 加减运算符
    var SECOND_OPERATOR = ['*', '/']; // 乘除运算符
    var SPECIAL_OPERATOR = ['(', ')']; // 括号
    var tmp; // 暂时存储当前处置惩罚的字符
    var tmpOperator; // 暂时存储当前的运算符

    // 遍历表达式
    for(var i = 0, len = expArr.length; i < len; i++){
        tmp = expArr[i];
        switch(tmp){
            case '(':
                operatorStack.push(tmp);
                break;
            case ')':
                // 碰到右括号，先出栈括号内数据
                while( (tmpOperator = operatorStack.pop()) !== '(' && 
                    typeof tmpOperator !== 'undefined' ){
                    valueStack.push(calculator(tmpOperator, valueStack.pop(), valueStack.pop()));
                }
                break;
            case '+':
            case '-':
                while( typeof operatorStack.readTop() !== 'undefined' && 
                    SPECIAL_OPERATOR.indexOf(operatorStack.readTop()) === -1 &&
                    (SECOND_OPERATOR.indexOf(operatorStack.readTop()) !== -1 || tmp != operatorStack.readTop()) ){
                    // 栈顶为乘除或雷同优先级运算，先出栈
                    valueStack.push(calculator(operatorStack.pop(), valueStack.pop(), valueStack.pop()));
                }
                operatorStack.push(tmp);
                break;
            case '*':
            case '/':
                while( typeof operatorStack.readTop() != 'undefined' && 
                    FIRST_OPERATOR.indexOf(operatorStack.readTop()) === -1 && 
                    SPECIAL_OPERATOR.indexOf(operatorStack.readTop()) === -1 && 
                    tmp != operatorStack.readTop()){
                    // 栈顶为雷同优先级运算，先出栈
                    valueStack.push(calculator(operatorStack.pop(), valueStack.pop(), valueStack.pop()));
                }
                operatorStack.push(tmp);
                break;
            default:
                valueStack.push(tmp);
        }
    }

    // 处置惩罚栈内数据
    while( typeof (tmpOperator = operatorStack.pop()) !== 'undefined' ){
        valueStack.push(calculator(tmpOperator, valueStack.pop(), valueStack.pop()));
    }

    return valueStack.pop(); // 将盘算效果推出

    /*
        @param operator 操纵符
        @param initiativeNum 主动值
        @param passivityNum 被动值
    */
    function calculator(operator, passivityNum, initiativeNum){
        var result = 0;

        initiativeNum = typeof initiativeNum === 'undefined' ? 0 : parseInt(initiativeNum, 10);
        passivityNum = typeof passivityNum === 'undefined' ? 0 : parseInt(passivityNum, 10);

        switch(operator){
            case '+':
                result = initiativeNum + passivityNum;
                console.log(`${initiativeNum} + ${passivityNum} = ${result}`);
                break;
            case '-':
                result = initiativeNum - passivityNum;
                console.log(`${initiativeNum} - ${passivityNum} = ${result}`);
                break;
            case '*':
                result = initiativeNum * passivityNum;
                console.log(`${initiativeNum} * ${passivityNum} = ${result}`);
                break;
            case '/':
                result = initiativeNum / passivityNum;
                console.log(`${initiativeNum} / ${passivityNum} = ${result}`);
                break;
            default:;
        }

        return result;
    }
}

完成思绪：

采纳调理场算法，对中缀表达式举行读取，对效果举行合理运算。
临界点采纳operatorStack.readTop() !== 'undefined'举行剖断。有些书采纳#做完毕标志，个人以为有点累坠。
将字符串表达式用split举行拆分，然后举行遍历读取，压入客栈。有提早要盘算效果的，举行对应的出栈处置惩罚。
将盘算部份效果的要领，封装为自力的要领calculator。因为乘除运算符前后的数字，在运算上有区分，所以不能随便换取位置。

2.4 中缀表达式转换为后缀表达式（逆波兰示意法）

逆波兰示意法，是一种对盘算机友爱的示意法，不需要运用括号。
下面案例，是对上一个案例的变通，也是用调理场算法，将中缀表达式转换为后缀表达式。

function rpn(exp){
    var valueStack = new Stack(); // 数值栈
    var operatorStack = new Stack(); // 操纵符栈 
    var expArr = exp.split('');
    var FIRST_OPERATOR = ['+', '-'];
    var SECOND_OPERATOR = ['*', '/'];
    var SPECIAL_OPERATOR = ['(', ')'];
    var tmp;
    var tmpOperator;

    for(var i = 0, len = expArr.length; i < len; i++){
        tmp = expArr[i];
        switch(tmp){
            case '(':
                operatorStack.push(tmp);
                break;
            case ')':
                // 碰到右括号，先出栈括号内数据
                while( (tmpOperator = operatorStack.pop()) !== '(' && 
                    typeof tmpOperator !== 'undefined' ){
                    valueStack.push(translate(tmpOperator, valueStack.pop(), valueStack.pop()));
                }
                break;
            case '+':
            case '-':
                while( typeof operatorStack.readTop() !== 'undefined' && 
                    SPECIAL_OPERATOR.indexOf(operatorStack.readTop()) === -1 &&
                    (SECOND_OPERATOR.indexOf(operatorStack.readTop()) !== -1 || tmp != operatorStack.readTop()) ){
                    // 栈顶为乘除或雷同优先级运算，先出栈
                    valueStack.push(translate(operatorStack.pop(), valueStack.pop(), valueStack.pop()));
                }
                operatorStack.push(tmp);
                break;
            case '*':
            case '/':
                while( typeof operatorStack.readTop() != 'undefined' && 
                    FIRST_OPERATOR.indexOf(operatorStack.readTop()) === -1 && 
                    SPECIAL_OPERATOR.indexOf(operatorStack.readTop()) === -1 && 
                    tmp != operatorStack.readTop()){
                    // 栈顶为雷同优先级运算，先出栈
                    valueStack.push(translate(operatorStack.pop(), valueStack.pop(), valueStack.pop()));
                }
                operatorStack.push(tmp);
                break;
            default:
                valueStack.push(tmp);
        }
    }

    while( typeof (tmpOperator = operatorStack.pop()) !== 'undefined' ){
        valueStack.push(translate(tmpOperator, valueStack.pop(), valueStack.pop()));
    }

    return valueStack.pop(); // 将盘算效果推出

    /*
        @param operator 操纵符
        @param initiativeNum 主动值
        @param passivityNum 被动值
    */
    function translate(operator, passivityNum, initiativeNum){
        var result = '';

        switch(operator){
            case '+':
                result = `${initiativeNum} ${passivityNum} +`;
                console.log(`${initiativeNum} + ${passivityNum} = ${result}`);
                break;
            case '-':
                result = `${initiativeNum} ${passivityNum} -`;
                console.log(`${initiativeNum} - ${passivityNum} = ${result}`);
                break;
            case '*':
                result = `${initiativeNum} ${passivityNum} *`;
                console.log(`${initiativeNum} * ${passivityNum} = ${result}`);
                break;
            case '/':
                result = `${initiativeNum} ${passivityNum} /`;
                console.log(`${initiativeNum} / ${passivityNum} = ${result}`);
                break;
            default:;
        }

        return result;
    }
}

rpn('1+7*(4-2)'); // 输出=> "1 7 4 2 - * +"

2.5 汉诺塔

《客栈的运用——用JavaScript形貌数据结构》

汉诺塔（港台：河内塔）是依据一个传说构成的数学题目：
有三根杆子A，B，C。A杆上有 N 个 (N>1) 穿孔圆盘，盘的尺寸由下到上顺次变小。请求按以下规则将一切圆盘移至 C 杆：
每次只能挪动一个圆盘；
大盘不能叠在小盘上面。

《客栈的运用——用JavaScript形貌数据结构》

客栈的典范算法运用，首推就是汉诺塔。

明白该算法，要注意以下几点：

不要穷究每次的挪动，要笼统明白
第一步：一切不相符请求的盘，从A塔一致移到B塔缓存
第二步：将相符的盘挪动到C塔
第三步：把B塔缓存的盘悉数挪动到C塔

以下是代码完成：

var ATower = new Stack(); // A塔
var BTower = new Stack(); // B塔
var CTower = new Stack(); // C塔 (目的塔)
var TIER = 4; // 层数

for(var i = TIER; i > 0; i--){
    ATower.push(i);
}

function Hanoi(n, from, to, buffer){
    if(n > 0){
        Hanoi(n - 1, from, buffer, to);  // 一切不相符请求的盘（n-1），从A塔一致移到B塔缓存
        to.push(from.pop()); // 将相符的盘（n）挪动到C塔
        Hanoi(n - 1, buffer, to, from); // 把B塔缓存的盘悉数挪动到C塔
    }
}

Hanoi(ATower.read().length, ATower, CTower, BTower);

汉诺塔的重点，照样靠递回去完成。把一个大题目，经由过程递归，不停分拆为更小的题目。然后，集中精力处置惩罚小题目即可。

三、小结

不知不觉，写得有点多ORZ。
背面章节的参考链接，照样引荐看看。或许合营本文，你会有更深的明白。

参考

[1] 中缀示意法
[2] 后缀示意法
[3] 调理场算法
[4] 汉诺塔

喜欢我文章的朋侪，能够经由过程以下体式格局关注我：

「star」 或 「watch」 我的GitHub blog
RSS定阅我的个人博客：王先生的基地

《客栈的运用——用JavaScript形貌数据结构》

    原文作者：leon
    原文地址: https://segmentfault.com/a/1190000015951795
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。

一、完成一个栈类Stack

1.1 入栈 push

1.2 出栈 pop

1.3 清空栈 clear

1.4 读取栈顶readTop

1.4 读取悉数栈read

1.5 聚合

二、实战

2.1 数组reverse的完成

2.2 十进制转换为二进制

2.3 表达式求值

2.4 中缀表达式转换为后缀表达式（逆波兰示意法）

2.5 汉诺塔

三、小结

参考

1.1 入栈 `push`

1.2 出栈 `pop`

1.3 清空栈 `clear`

1.4 读取栈顶`readTop`

1.4 读取悉数栈`read`

2.1 数组`reverse`的完成