javascript实现数据结构与算法系列：栈 -- 顺序存储表示和链式表示及示例

栈（Stack）是限定仅在表尾进行插入或删除操作的线性表。表尾为栈顶（top），表头为栈底（bottom），不含元素的空表为空栈。

栈又称为后进先出（last in first out）的线性表。

堆栈可以用链表和数组两种方式实现，一般为一个堆栈预先分配一个大小固定且较合适的空间并非难事，所以较流行的做法是 Stack 结构下含一个数组。如果空间实在紧张，也可用链表实现，且去掉表头。

栈的链式表示结构图：

用js数组可以非常简单地实现栈的顺序表示，故这里不赘述。这里主要讲解一下栈的链式表示。

// 找的链式表示
function Stack() {
  this.top = null;
  this.size = 0;
}
module.exports = Stack;
Stack.prototype = {
  constructor: Stack,
  push: function (data) {
    var node = {
      data: data,
      next: null
    };

    node.next = this.top;
    this.top = node;
    this.size++;
  },
  peek: function () {
    return this.top === null ?
      null :
      this.top.data;
  },
  pop: function () {
    if (this.top === null) return null;

    var out = this.top;
    this.top = this.top.next;

    if (this.size > 0) this.size--;

    return out.data;
  },
  clear: function () {
    this.top = null;
    this.size = 0;
  },
  displayAll: function () {
    if (this.top === null) return null;

    var arr = [];
    var current = this.top;

    for (var i = 0, len = this.size; i < len; i++) {
      arr[i] = current.data;
      current = current.next;
    }

    return arr;
  }
};

var stack = new Stack();

stack.push(1);
stack.push('asd');

stack.pop();
stack.push({a: 1});
console.log(stack);

相关单元测试：

describe('stack tests', function(){
  var stack = new Stack();

  it('should push into stack', function(){
    stack.push(1);
    expect(stack.peek()).toBe(1);
    stack.push('asd');
    expect(stack.peek()).toBe('asd');
    expect(stack.size).toBe(2);
  });

  it('should pop from stack', function(){
    stack.pop();
    expect(stack.peek()).toBe(1);
    expect(stack.size).toBe(1);
    stack.push({a: 1});
    expect(stack.peek()).toEqual({a: 1});
    expect(stack.size).toBe(2);
  });

  it('should be an empty stack', function(){
    stack.pop();
    expect(stack.peek()).toBe(1);
    stack.pop();
    expect(stack.peek()).toBe(null);
    expect(stack.size).toBe(0);
  });
});

堆栈的应用

• 回溯
• 递回
• 深度优先搜寻

示例1：数值进制转换

公式： N = (N / d) * d + N % d
N：十进制数值， d：需要转换的进制数

function numTransform(number, rad) {
  var s = new Stack();

  while (number) {
    s.push(number % rad);
    number = parseInt(number / 8, 10);
  }

  var arr = [];
  while (s.top) {
    arr.push(s.pop());
  }
  console.log(arr.join(''));
}

numTransform(1348, 8);
numTransform(1348, 2);

示例2：括号匹配检查

在算法中设置一个栈，每读入一个括号，若是右括号，则或者使置于栈顶的最急迫的期待得以消解，或者是不合法的情况；若是左括号，则作为一个新的更急迫的期待压入栈中，自然使得原有的在栈中的所有未消解的期待的急迫性都降一级。另外，在算法开始和结束时，栈都应该是空的。

function bracketsMatch(str) {
  var stack = new Stack();
  var text = '';

  for (var i = 0, len = str.length; i < len; i++) {
    var c = str[i];
    if (c === '[') {
      stack.push(c);
    } else if (c === ']') {
      if (!stack.top || stack.pop() !== '[') throw new Error('unexpected brackets:' + c);
    } else {
      text += c;
    }
  }
  console.log(text);
}

console.log(bracketsMatch('[asd]'));

function Matcher(left, right) {
  this.left = left;
  this.right = right;
  this.stack = new Stack();
}
Matcher.prototype = {
  match: function (str) {
    var text = '';

    for (var i = 0, len = str.length; i < len; i++) {
      var c = str[i];
      if (c === this.left) {
        this.stack.push(c);
      } else if (c === this.right) {
        if (!this.stack.top || this.stack.pop() !== this.left) {
          throw new Error('unexpected brackets:' + c);
        } else {
          text += ',';
        }
      } else {
        text += c;
      }
    }
    console.log(text);
    return text;
  }
};
var m = new Matcher('{', '}');
m.match('[{123}123');

示例3：行编辑

当用户发现刚刚键入的一个字符是错的时，可补进一个退格符“#”,以表示前一个字符无效；如果发现当前键入的行内差错较多或难以补进，则可以键入一个退行符“@”

，以表示当前行中的字符均无效。

为此，可设这个输入缓冲区为一个栈结构，每当从终端接收了一个字符之后先做如下判断：

如果它既不是"#"也不是"@"，则将字符压入栈；

如果是"#"，则从栈顶删去一个字符；

如果是"@"，则清空栈。

function LineEditor(str) {
  this.stack = new Stack();
  this.str = str || ''
}
LineEditor.prototype = {
  getResult: function () {
    var stack = this.stack;
    var str = this.str;
    for (var i = 0, len = str.length; i < len; i++) {
      var c = str[i];
      switch (c) {
        case '#':
          stack.pop();
          break;
        case '@':
          stack.clear();
          break;
        default:
          stack.push(c);
          break;
      }
    }

    var result = '';
    var current = stack.top;
    while (current) {
      result = current.data + result;
      current = current.next;
    }

    return result;
  }
};

var le = new LineEditor('whli##ilr#e(s#*s)
    
outcha@putchar(*s=#++)');
console.log(le.getResult());

示例4：表达式求值

表达式求值是程序设计语言编译中的一个最基本问题、它的实现是栈应用的又一个典型例子。这里介绍一种简单直观，广为使用的算法，通常称为“运算符优先法”。

// from： http://wuzhiwei.net/ds_app_stack/

var prioty = {
  "+": 1,
  "-": 1,
  "%": 2,
  "*": 2,
  "/": 2,
  "^": 3,
  "(": 0,
  ")": 0,
  "`": -1
};

function doop(op, opn1, opn2) {
  switch (op) {
    case "+":
      return opn1 + opn2;
    case "-":
      return opn1 - opn2;
    case "*":
      return opn1 * opn2;
    case "/":
      return opn1 / opn2;
    case "%":
      return opn1 % opn2;
    case "^":
      return Math.pow(opn1, opn2);
    default:
      return 0;
  }
}

function opcomp(a, b) {
  return prioty[a] - prioty[b];
}

function calInfixExpression(exp) {
  var cs = [];
  var ns = [];
  exp = exp.replace(/s/g, "");
  exp += '`';
  if (exp[0] === '-') {
    exp = "0" + exp;
  }
  var c;
  var op;
  var opn1;
  var opn2;
  for (var i = 0; i < exp.length; ++i) {
    c = exp[i];
    // 如果是操作符
    if (c in prioty) {
      // 如果右边不是左括号且操作符栈的栈顶元素优先权比右边大
      // 循环遍历进行连续运算
      while (c != '(' && cs.length && opcomp(cs[cs.length - 1], c) >= 0) {
        // 出栈的操作符
        op = cs.pop();
        // 如果不是左括号或者右括号，说明是运算符
        if (op != '(' && op != ')') {
          // 出栈保存数字的栈的两个元素
          opn2 = ns.pop();
          opn1 = ns.pop();
          // 将与操作符运算后的结果保存到栈顶
          ns.push(doop(op, opn1, opn2));
        }
      }
      // 如果右边不是右括号，保存到操作符栈中
      if (c != ')') cs.push(c);
    } else {
      // 多位数的数字的情况
      while (!(exp[i] in prioty)) {
        i++;
        c += exp[i];
      }
      ns.push(parseFloat(c));
      i--;
    }
  }
  return ns.length ? ns[0] : NaN;
}

var exp1 = calInfixExpression('5+3*4/2-2^3+5%2');
console.log(exp1);

栈与递归调用的实现：

栈的另一个重要应用是在程序设计语言中实现递归调用。

递归调用：一个函数(或过程)直接或间接地调用自己本身，简称递归(Recursive)。

递归是程序设计中的一个强有力的工具。因为递归函数结构清晰，程序易读，正确性很容易得到证明。

为了使递归调用不至于无终止地进行下去，实际上有效的递归调用函数(或过程)应包括两部分：递推规则(方法)，终止条件。

为保证递归调用正确执行，系统设立一个“递归工作栈”，作为整个递归调用过程期间使用的数据存储区。

每一层递归包含的信息如：参数、局部变量、上一层的返回地址构成一个“工作记录” 。每进入一层递归，就产生一个新的工作记录压入栈顶；每退出一层递归，就从栈顶弹出一个工作记录。

从被调函数返回调用函数的一般步骤：

(1) 若栈为空，则执行正常返回。

⑵ 从栈顶弹出一个工作记录。

⑶ 将“工作记录”中的参数值、局部变量值赋给相应的变量；读取返回地址。

⑷ 将函数值赋给相应的变量。

(5) 转移到返回地址。

相关：

javascript实现数据结构与算法系列