javascript数据结构与算法-栈结构

JavaScript 数据结构与算法（三）栈结构

1. 栈结构概述

数组是一个线性结构，并且可以在数组的任意位置插入和删除元素, 没有任何限制。
但是有时候，我们为了实现某些功能，必须对这种任意性加以限制。
栈和队列就是比较常见的受限的线性结构。

栈（stack）是一种运算受限的线性表，后进先出LIFO：

• LIFO（last in first out）表示就是后进入的元素，第一个弹出栈空间。
• 其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
• 向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；
• 从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈的特点：先进后出，后进先出。

实现栈结构有两种常见的方式: 基于数组实现 / 基于链表实现
javascript没有自带链表结构, 后续会自己实现链表结构并做对比.

如下图所示：

2. 栈常见的操作

• push() 添加一个新元素到栈顶位置。
• pop() 移除栈顶的元素，同时返回被移除的元素。
• peek() 返回栈顶的元素，不对栈做任何修改（该方法不会移除栈顶的元素，仅仅返回它）。
• isEmpty() 如果栈里没有任何元素就返回 true，否则返回 false。
• size() 返回栈里的元素个数。这个方法和数组的 length 属性类似。
• toString() 将栈结构的内容以字符串的形式返回。

3. 程序中的栈结构

• 函数调用栈：A(B(C(D())))：
  即 A 函数中调用 B，B 调用 C，C 调用 D；
  在 A 执行的过程中会将 A 压入栈，随后 B 执行时 B 也被压入栈，函数 C 和 D 执行时也会被压入栈。所以当前栈的顺序为：A->B->C->D（栈顶）；
  函数 D 执行完之后，会弹出栈被释放，弹出栈的顺序为 D->C->B->A;

• 递归：
  为什么没有停止条件的递归会造成栈溢出？
  比如函数 A 为递归函数，不断地调用自己（因为函数还没有执行完，不会把函数弹出栈），不停地把相同的函数 A 压入栈，最后造成栈溢出（Queue Overfloat）。

4. 练习-出栈顺序判断

题目：有 6 个元素 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 （√）

题目所说的按顺序进栈指的不是一次性全部进栈，而是有进有出，整个的进栈顺序为 6 -> 5 -> 4 -> 3 -> 2 -> 1。

解析：

• A 答案：65 进栈，5 出栈，4 进栈出栈，3 进栈出栈，6 出栈，21 进栈，1 出栈，2 出栈（整体入栈顺序符合 654321）。
• B 答案：654 进栈，4 出栈，5 出栈，3 进栈出栈，2 进栈出栈，1 进栈出栈，6 出栈（整体的入栈顺序符合 654321）。
• C 答案：6543 进栈，3 出栈，4 出栈，之后应该 5 出栈而不是 6，所以错误。
• D 答案：65432 进栈，2 出栈，3 出栈，4 出栈，1 进栈出栈，5 出栈，6 出栈。符合入栈顺序。

5. 基于数组实现栈结构

使用数组结构[]来保存栈里的元素
封装栈的类

// 栈结构的封装

class StackArray {
  constructor() {
    this.items = [];
  }
  // push(item) 压栈操作，往栈里面添加元素
  push(element) {
    this.items.push(element);
  }
  // pop() 出栈操作，从栈中取出元素，并返回取出的那个元素
  pop() {
    return this.items.pop();
  }
  // peek() 查看栈顶元素
  peek() {
    return this.items[this.items.length - 1];
  }
  // isEmpty() 判断栈是否为空
  isEmpty() {
    return this.items.length === 0;
  }
  // size() 获取栈中元素个数
  size() {
    return this.items.length;
  }
  // clear() 清空栈元素
  clear() {
    this.items = [];
  }
  // toArray() 返回以数组形式的栈内元素数据
  toArray() {
    return this.items;
  }
  // toString() 返回以字符串形式的栈内元素数据
  // 使用数组本身的toString()方法
  toString() {
    return this.items.toString();
  }
  // 或者下面这种自己写的字符串拼接方法
  toString() {
    let result = '';
    for (let item of this.items) {
      result += item + ' ';
    }
    return result;
  }
}

栈结构的简单应用-十进制转为二进制

要把十进制转化成二进制，可以将该十进制数除以 2（二进制是满二进一）并对商(被除数 / 除数 = 商)取整，直到结果是 0 为止。"除二取余,倒着写"

利用栈结构的特点封装实现十进制转换为二进制的方法。
代码实现

function dec2bin(dec) {
  // new 一个 Stack，保存余数
  const stack = new Stack();

  // 当不确定循环次数时，使用 while 循环
  while (dec > 0) {
    // 除二取余法
    stack.push(dec % 2); // 获取余数，放入栈中
    dec = Math.floor(dec / 2); // 除数除以二，向下取整
  }

  let binaryString = '';
  // 不断地从栈中取出元素（0 或 1），并拼接到一起。
  while (!stack.isEmpty()) {
    binaryString += stack.pop();
  }

  return binaryString;
}

测试

// dec2bin() 测试
console.log(dec2bin(100)); //--> 1100100
console.log(dec2bin(88)); //--> 1011000

6. 基于对象实现栈结构

使用javascript对象存储所有的栈元素,保证他们的顺序并且遵循LIFO原则.
基于对象实现需要我们自己创建一些方法.

class Stack {
  // 使用count属性来记录栈的大小, 即长度属性
  // 使用items对象来存储栈元素
  constructor() {
    this.count = 0;
    this.items = {};
  }
  // 在javascript中,对象是一系列键值对的集合
  // 要向栈中添加元素, 可以使用count变量作为items对象的键名, element即为插入的元素值
  push(element) {
    this.items[this.count] = element;
    this.count++;
  }
  // 弹出栈顶元素
  pop() {
    // 首先判断栈是否为空,为空则返回undefined
    if (this.isEmpty()) {
      return undefined;
    }
    // 栈不为空,则将计数属性count减一,并保存栈顶的值存储为result,用于返回
    // count计数值比对象下标值多1, count计数从1开始,对象下标从0开始
    this.count--;
    const result = this.items[this.count];
    // 通过delete运算符删除栈顶的值
    delete this.items[this.count];
    return result;
  }
  // 访问栈顶元素, 即访问count属性减一所对应的下标位置
  peek() {
    if (this.isEmpty()) {
      return undefined;
    }
    return this.items[this.count - 1];
  }
  // 验证栈是否为空
  // count属性表示栈的大小
  isEmpty() {
    return this.count === 0;
  }
  // 获取栈的大小
  size() {
    return this.count;
  }
  // 清空该栈, 可以将值直接复原为构造函数中使用的原始值{}, 0
  // 或者遵循LIFO原则,移除栈中所有的元素
  clear() {
    /* while (!this.isEmpty()) {
        this.pop();
      } */
    this.items = {};
    this.count = 0;
  }
  // 打印栈的内容
  toString() {
    // 栈为空则只需返回一个字符串
    if (this.isEmpty()) {
      return '';
    }
    // 栈不为空,则用底部的第一个元素作为字符串初始值,依次迭代整个栈的键直到栈顶
    // 每次添加一个,以及下一个元素
    let objString = `${this.items[0]}`;
    for (let i = 1; i < this.count; i++) {
      objString = `${objString},${this.items[i]}`;
    }
    return objString;
  }
}

7. 保护数据结构内部元素

7.1 使用ES2015的限定作用域Symbol实现类

const _items = Symbol('stackItems');

class Stack {
  constructor() {
    this[_items] = [];
  }

  push(element) {
    this[_items].push(element);
  }

  pop() {
    return this[_items].pop();
  }

  peek() {
    return this[_items][this[_items].length - 1];
  }

  isEmpty() {
    return this[_items].length === 0;
  }

  size() {
    return this[_items].length;
  }

  clear() {
    this[_items] = [];
  }

  print() {
    console.log(this.toString());
  }

  toString() {
    return this[_items].toString();
  }
}

const stack = new Stack();
stack.push(5);
stack.push(8);
const objectSymbols = Object.getOwnPropertySymbols(stack);
console.log(objectSymbols.length); // 1
console.log(objectSymbols); // [Symbol()]
console.log(objectSymbols[0]); // Symbol()
stack[objectSymbols[0]].push(1);
stack.print(); // 5, 8, 1

7.2 使用ES2015的WeakMap实现类

WeakMap数据类型可以确保属性是私有的。
WeakMap 可以存储键值对，其中键是对象，值可以是任意数据类型。