前端学算法（四）：栈的应用

最新推荐文章于 2023-01-03 18:27:27 发布

原创最新推荐文章于 2023-01-03 18:27:27 发布 · 527 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #前端

算法与数据结构专栏收录该内容

4 篇文章

订阅专栏

本文介绍了栈在多种场景中的应用，包括进制转换、回文判断、阶乘计算、中缀表达式转后缀表达式及后缀表达式计算。通过具体示例展示了栈的基本操作和其实现方法。

栈的应用广泛，将最近关于栈的简单应用做一个总结。

1、进制转化：将十进制整数转化为任意正整数进制。

（1）原理：除n取余法。

（2）实现：

function mulBase( num, base ) {
  var s = new Stack();

  // 除n取余
  do {
    s.push(num % base);
    num = Math.floor(num/base);
  } while (num > 0);
  
  // 倒写余数
  var converted = '';
  for (var i = 0, length = s.length(); i < length; i++) {
    converted += s.pop();
  };

  return converted;
};

2、判断单词是否回文：判断单词正序和单词倒序是否相等。

（1）原理：

第一步：倒写单词。将原单词从首字母到尾字母，依次压入栈中，再依次弹出，写入字符串，完成倒写，生成新单词。

第二步：判断是否回文。判断倒写之后的新单词和原单词是否相等。

（2）实现：

function isPalindrome( word ) {
  var s = new Stack();

  for (var i = 0; i < word.length; i++) {
    s.push(word[i]);
  };

  var rword = '';
  for (var i = 0, length = s.length(); i < length; i++) {
    rword += s.pop();
  };

  if ( word === rword ) {
    console.log(word + ' is a palindrome word.');
    return true;
  } else {
    console.log(word + ' is not a palindrome word.');
    return false;
  };
};

3、阶乘的迭代实现

（1）原理：将1到n，一一压入栈中。再将栈顶弹出的数，一一相乘。

（2）实现：

function factorial( n ) {
  var s = new Stack();
  while (n > 1) {
    s.push(n--)
  };

  var result = 1;
  while (s.length() > 0) {
    result *= s.pop();
  };
  return result;
}

4、中缀表达式转化为后缀表达式（逆波兰表达式）：

（1）原理：一个算术表达式（arithmetic），由运算符（operater）和运算数（num）组成。

第一步：自左向右扫描中缀表达式，如果当前是运算数，则压入栈中；如果当前是运算符（左括号，加减乘除），则压入栈；

第二步：如果当前是运算符（右括号），则从栈中弹出，输出到后缀表达式中。直到栈顶不是（加减乘除）。再将左括号弹出。

第三步：重复第一步和第二步，直到算术表达式扫描完毕。

（2）实现：

function reversePolishExpression( arithmetic ) {
  var operater = new Stack();
  var reverseExp = '';

  for (var i = 0; i < arithmetic.length; i++) {
    if ( '0123456789'.indexOf(arithmetic[i]) !== -1 ) {
      reverseExp += arithmetic[i];
    } else if ( '(+-*/'.indexOf(arithmetic[i]) !== -1 ) {
      operater.push(arithmetic[i]);
    } else if ( arithmetic[i] === ')' ) {
      while ( '+-*/'.indexOf(operater.peek()) !== -1 ) {
        reverseExp += operater.pop();
      };
      operater.pop();
    };
  };
  return reverseExp;
};

// test 
// 输入的中缀表达式需有小括号
var exp = reversePolishExpression('((((1+2)*2)/2)-2)')
console.log(exp);

5、后缀表达式的计算：

（1）原理：后缀表达式，不根据运算符的优先级和结合性，仅仅用一个栈来储存运算数，根据实时扫描的运算符，从栈中弹出运算数，来进行运算。

（2）实现：

function countReversePolishExp( reverseExp ) {
  var num = new Stack();

  for (var i = 0; i < reverseExp.length; i++) {
    if ( '0123456789'.indexOf(reverseExp[i]) !== -1 ) {
      num.push(reverseExp[i]);
    } else if ( reverseExp[i] === '+' ) {
      var a = parseInt(num.pop());
      var b = parseInt(num.pop());
      num.push(a+b);
    } else if ( reverseExp[i] === '-' ) {
      var a = parseInt(num.pop());
      var b = parseInt(num.pop());
      num.push(b-a);
    } else if ( reverseExp[i] === '*' ) {
      var a = parseInt(num.pop());
      var b = parseInt(num.pop());
      num.push(a*b);
    } else if ( reverseExp[i] === '/' ) {
      var a = parseInt(num.pop());
      var b = parseInt(num.pop());
      num.push(b/a);
    };
  };
  return num.pop();
};