层层递进，阅尽层层风景--论遍历二叉树的不同方法

前端

2023-11-14 21:07:34

二叉树及其基础知识

在计算机科学领域，二叉树是一种常见的数据结构，用于高效存储和组织数据。二叉树是一种树形结构，其中每个节点最多有两个子节点，通常被称为左子节点和右子节点。根节点是二叉树的起始点，其他节点通过边连接到它。

二叉树的遍历是指从根节点开始，按照一定顺序访问每个节点的过程。遍历二叉树有许多不同的方法，每种方法都有其独特的优点和适用场景。下面，我们将介绍两种最常用的二叉树遍历方法：深度优先搜索和广度优先搜索。

深度优先搜索与广度优先搜索

深度优先搜索

深度优先搜索（DFS）是一种沿着一条路径深度遍历二叉树的方法。它从根节点开始，然后依次访问其所有子节点，直到到达叶节点。当遇到叶节点时，它回溯到最近的一个未访问过的节点，继续进行深度优先搜索。

广度优先搜索

广度优先搜索（BFS）是一种沿着每一层依次遍历二叉树的方法。它从根节点开始，然后访问该层的所有节点，然后再访问下一层的节点，以此类推，直到访问到最后一层的所有节点。

层序遍历与锯齿遍历

层序遍历

层序遍历（又称广度优先遍历）是一种按层访问二叉树节点的遍历方法。它从根节点开始，按层依次访问每个节点。如果二叉树的深度为h，那么层序遍历将访问h+1层节点，第一层为根节点，第二层为根节点的子节点，以此类推，最后一层为最底层的叶节点。

锯齿遍历

锯齿遍历（又称之字形遍历）是一种按层访问二叉树节点的遍历方法，但它与层序遍历不同的是，它以锯齿形的方式访问每个节点。具体来说，它从根节点开始，按层依次访问每个节点，但当访问到奇数层时，它从右到左访问节点，而当访问到偶数层时，它从左到右访问节点。

遍历二叉树的实现

深度优先搜索的实现

以下是用伪代码实现的深度优先搜索算法：

function DFS(node) {
  // 访问当前节点
  visit(node);

  // 递归访问左子节点
  if (node.left != null) {
    DFS(node.left);
  }

  // 递归访问右子节点
  if (node.right != null) {
    DFS(node.right);
  }
}

广度优先搜索的实现

以下是用伪代码实现的广度优先搜索算法：

function BFS(node) {
  // 创建一个队列
  queue = new Queue();

  // 将根节点入队
  queue.enqueue(node);

  // 循环，直到队列为空
  while (!queue.isEmpty()) {
    // 出队一个节点
    node = queue.dequeue();

    // 访问当前节点
    visit(node);

    // 将当前节点的左子节点入队
    if (node.left != null) {
      queue.enqueue(node.left);
    }

    // 将当前节点的右子节点入队
    if (node.right != null) {
      queue.enqueue(node.right);
    }
  }
}

层序遍历的实现

以下是用伪代码实现的层序遍历算法：

function levelOrderTraversal(root) {
  // 创建一个队列
  queue = new Queue();

  // 将根节点入队
  queue.enqueue(root);

  // 循环，直到队列为空
  while (!queue.isEmpty()) {
    // 获取当前队列的大小
    size = queue.size();

    // 循环，访问当前队列中的所有节点
    for (i = 0; i < size; i++) {
      // 出队一个节点
      node = queue.dequeue();

      // 访问当前节点
      visit(node);

      // 将当前节点的左子节点入队
      if (node.left != null) {
        queue.enqueue(node.left);
      }

      // 将当前节点的右子节点入队
      if (node.right != null) {
        queue.enqueue(node.right);
      }
    }
  }
}

锯齿遍历的实现

以下是用伪代码实现的锯齿遍历算法：

function zigzagLevelOrder(root) {
  // 创建一个栈
  stack1 = new Stack();

  // 创建一个队列
  queue = new Queue();

  // 将根节点入栈
  stack1.push(root);

  // 创建一个标志位，用于指示当前层是奇数层还是偶数层
  isOddLevel = true;

  // 循环，直到栈或队列为空
  while (!stack1.isEmpty() || !queue.isEmpty()) {
    // 如果当前层是奇数层
    if (isOddLevel) {
      // 循环，访问栈中的所有节点
      while (!stack1.isEmpty()) {
        // 出栈一个节点
        node = stack1.pop();

        // 访问当前节点
        visit(node);

        // 将当前节点的左子节点入队
        if (node.left != null) {
          queue.enqueue(node.left);
        }

        // 将当前节点的右子节点入队
        if (node.right != null) {
          queue.enqueue(node.right);
        }
      }
    }
    // 否则，当前层是偶数层
    else {
      // 循环，访问队列中的所有节点
      while (!queue.isEmpty()) {
        // 出队一个节点
        node = queue.dequeue();

        // 访问当前节点
        visit(node);

        // 将当前节点的右子节点入栈
        if (node.right != null) {
          stack1.push(node.right);
        }

        // 将当前节点的左子节点入栈
        if (node.left != null) {
          stack1.push(node.left);
        }
      }
    }

    // 将标志位取反，以便在下一层切换访问方式
    isOddLevel = !isOddLevel;
  }
}