深入剖析四种经典JS算法：二叉树的镜像、对称的二叉树、顺时针打印矩阵和包含min函数的栈

2024-02-03 09:49:53

征服算法：掌握四种JavaScript经典算法

在计算机科学领域，算法就像魔法咒语，它们将复杂的问题转化为一系列清晰的步骤，指引程序员编写更高效、更健壮的代码。对于JavaScript程序员来说，以下四种经典算法是必不可少的：二叉树的镜像、对称的二叉树、顺时针打印矩阵和包含min函数的栈。

二叉树的镜像：镜像世界中的树木

想象一棵树，就像一幅艺术画，却以相反的方向呈现。二叉树的镜像算法就是这样，它将二叉树中所有节点的左右子节点交换位置，创造一个镜像世界。这种镜像在处理图像、图形和数据结构时非常有用。

// 输入：
//     4
//   /   \
//  2     7
// / \   / \
//1   3 6   9

// 输出：
//     4
//   /   \
//  7     2
// / \   / \
//9   6 3   1
function invertTree(root) {
  // 如果树为空，直接返回
  if (root === null) {
    return null;
  }

  // 交换左右子节点
  const left = invertTree(root.left);
  const right = invertTree(root.right);
  root.left = right;
  root.right = left;

  // 返回根节点
  return root;
}

对称的二叉树：镜子中的完美镜像

对称的二叉树是一幅完美的对称图画，犹如一面镜子，左右两边完全相同。对称的二叉树算法判断一棵二叉树是否具有这种镜子般的对称性，在设计具有平衡和对称特性的数据结构和算法时至关重要。

// 输入：
//     1
//   /   \
//  2     2
// / \   / \
//3   4 4   3

// 输出：true

// 输入：
//     1
//   /   \
//  2     2
//   \   /
//    3 3

// 输出：false
function isSymmetric(root) {
  // 如果树为空，直接返回true
  if (root === null) {
    return true;
  }

  // 判断左右子树是否对称
  const left = isSymmetric(root.left);
  const right = isSymmetric(root.right);

  // 判断根节点左右子节点的值是否相等
  if (root.left !== null && root.right !== null && root.left.val === root.right.val) {
    return left && right;
  } else {
    return false;
  }
}

顺时针打印矩阵：矩阵中的螺旋之旅

想象一个充满数字的矩阵，就像一个螺旋迷宫。顺时针打印矩阵算法以顺时针方向遍历矩阵中的所有元素，就像探索一个神秘的螺旋。这种算法在图像处理、游戏开发和数据分析中广泛应用。

// 输入：
// [
//   [1, 2, 3],
//   [4, 5, 6],
//   [7, 8, 9]
// ]

// 输出：[1, 2, 3, 6, 9, 8, 7, 4, 5]
function printMatrixClockwise(matrix) {
  // 如果矩阵为空，直接返回空数组
  if (matrix === null || matrix.length === 0) {
    return [];
  }

  const result = [];

  // 获取矩阵的行数和列数
  const rows = matrix.length;
  const cols = matrix[0].length;

  // 设置循环变量
  let left = 0;
  let right = cols - 1;
  let top = 0;
  let bottom = rows - 1;

  // 循环打印矩阵元素
  while (left <= right && top <= bottom) {
    // 从左到右打印顶部元素
    for (let i = left; i <= right; i++) {
      result.push(matrix[top][i]);
    }

    // 从上到下打印右侧元素
    for (let i = top + 1; i <= bottom; i++) {
      result.push(matrix[i][right]);
    }

    // 从右到左打印底部元素
    if (top < bottom) {
      for (let i = right; i >= left; i--) {
        result.push(matrix[bottom][i]);
      }
    }

    // 从下到上打印左侧元素
    if (left < right) {
      for (let i = bottom - 1; i > top; i--) {
        result.push(matrix[i][left]);
      }
    }

    // 更新循环变量
    left++;
    right--;
    top++;
    bottom--;
  }

  // 返回结果
  return result;
}

包含min函数的栈：最小值的守护者

包含min函数的栈就像一个超能力栈，它不仅能存储元素，还能记住最小元素。这种算法在跟踪股票价格、天气预测和数据处理中大显身手，确保我们始终掌握最小值。

// 输入：
// [3, 4, 2, 1, 5]

// 输出：[3, 4, 2, 1, 1, 5]
function MinStack() {
  this.stack = [];
  this.minStack = [];
}

MinStack.prototype.push = function(x) {
  this.stack.push(x);

  // 如果当前元素小于或等于minStack栈顶元素，则将当前元素压入minStack
  if (this.minStack.length === 0 || x <= this.minStack[this.minStack.length - 1]) {
    this.minStack.push(x);
  }
};

MinStack.prototype.pop = function() {
  const top = this.stack.pop();

  // 如果当前元素等于minStack栈顶元素，则将minStack栈顶元素弹出
  if (top === this.minStack[this.minStack.length - 1]) {
    this.minStack.pop();
  }

  return top;
};

MinStack.prototype.top = function() {
  return this.stack[this.stack.length - 1];
};

MinStack.prototype.min = function() {
  return this.minStack[this.minStack.length - 1];
};