可以根据栈的特性， 先进后出，后进先出。 可以对进制的转换，对栈的应用

进制的转换

栈的应用， 进制的转换

在JS 中使用 进制转换方法parseInt, 和Number.prototype.toString方法

console.log((123).toString(2));

在不使用这两个api 的情况下，使用栈进行进制的转换

二进制

简单的二进制转换分析
// 10 / 2 = 5 0
// 5 / 2 = 2 1
// 2 / 2 = 1 0
// 1 / 2 = 0 1

  1.     // 1010 从栈低到栈顶

代码： 

  1. // ES6 定义的栈
  2. var Stack = (function() {
  3.   var _items = new WeakMap();
  4.   return class Stack {
  5.     constructor() {
  6.       // 定义初始化数据
  7.       _items.set(this, []);
  8.     };
  9.     // 定义方法
  10.     push(elem) {
  11.       // 读取this, 通过 push 添加
  12.       _items.get(this).push(elem);
  13.     }
  15.     pop() {
  16.       return _items.get(this).pop();
  17.     }
  19.     // 返回栈顶元素
  20.     peek() {
  21.       return _items.get(this)[_items.get(this).length - 1];
  22.     }
  24.     // 判断栈是否为空
  25.     isEmpty() {
  26.       return _items.get(this).length === 0 ? true : false;
  27.     }
  29.     clear() {
  30.       _items.get(this).length = 0;
  31.     }
  33.     size() {
  34.       return _items.get(this).length;
  35.     }
  37.     toString() {
  38.       // 获取toString 方法
  39.       return _items.get(this).toString();
  40.     }
  41.   };
  42. })()
  46. // 栈的应用， 进制的转换  
  47. // 在JS 中使用 进制转换方法parseInt,  和 Number.prototype.toString 方法
  48. // console.log((123).toString(2));
  49. // 在不使用这两个api 的情况下，使用栈进行进制的转换
  51. // 10 / 2  = 5    0
  52. // 5 / 2  = 2     1
  53. // 2 / 2  = 1     0
  54. // 1 / 2  =  0    1
  56. // 1010 从栈低到栈顶
  60. function divdeBy2(num) {
  61.     // 实例化栈
  62.   var remStack = new Stack(),
  63.       rem, // 余数
  64.       res = ''; // 结果返回的数
  66.   while (num > 0) {
  67.       rem = num % 2;  // 取余
  68.     // 将余数放入栈
  69.     remStack.push(rem);
  70.     num = Math.floor(num / 2); // num 重新赋值
  71.   }
  73.     // console.log(remStack.toString()) // 0,1,0,1
  75.   // 对结果进行处理，拼接字符串， 然后返回出去
  76.   // 如果栈不为空
  77.   while(!remStack.isEmpty()) {
  78.       // 通过数组方法 pop 取栈顶数据
  79.     res = res + remStack.pop().toString();
  80.   }
  82.   return res;
  83. }
  85. console.log(divdeBy2(1000)) // 1111101000

查看输出
image.png

八进制

对八进制， 在原有方法上改 2 为 8 

function divdeBy8(num) {
    // 实例化栈
  var remStack = new Stack(),
      rem, // 余数
      res = ''; // 结果返回的数

  while (num > 0) {
      rem = num % 8;  // 取余
    // 将余数放入栈
    remStack.push(rem);
    num = Math.floor(num / 8); // num 重新赋值
  }

    // console.log(remStack.toString()) // 0,1,0,1

  // 对结果进行处理，拼接字符串， 然后返回出去
  // 如果栈不为空
  while(!remStack.isEmpty()) {
      // 通过数组方法 pop 取栈顶数据
    res = res + remStack.pop().toString();
  }

  return res;
}

console.log(divdeBy8(1000)) // 1750

输出结果
image.png

十六进制

因为使用原来的改变进制的值， 十六进制会出现 a b c d e f 等表示值

image.png
结果会输出 3148 ，达不到预期结果。

代码优化

function divdeBy(num, base) {
  // 定义栈
  var remStack = new Stack(),
      rem, // 余数
      res = '',
      digits = '0123456789abcdef'; // digits 字符串表示十六进制的数值
  while (num > 0) {
    // 取num的余数
    rem = num % base;
    // 将余数放入栈中
    remStack.push(rem);
    // 让num重新赋值
    num = Math.floor(num / base);
  }
  // console.log(remStack.toString()) // 0,1,0,1

  // 处理栈的数据, 拼接字符串， 然后返回出去
  while (!remStack.isEmpty()) { // 判断栈是否为空
    // console.log(remStack.pop().toString()); // 取栈顶的数据
    res = res + digits[remStack.pop()];  // 这里直接去字符串的下标赋值
    // digits[remStack.pop()] 处理16进制是
  }
  return res;
}

console.log(divdeBy(1000, 16));

输出结果
image.png