【算法专题训练】29、树的深度优先遍历

1、树的基础知识

• 二叉树中每个节点最多只有两个子节点，分别称为左子节点和右子节点。
• 二叉树的根节点没有父节点，一棵非空二叉树只有一个父节点
• 二叉树的叶子节点没有子节点

二叉树节点数据类型：

struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
}

2、中序遍历

• 中序遍历的顺序，是先遍历二叉树的左子树，然后遍历二叉树的根节点，最后遍历二叉树的右子树。
• 中序遍历是相对于根节点来说的，中序是说根节点在中间顺序遍历，相对于他的左右子树来说。
  代码实现方式有两种，递归与迭代实现方式

递归代码实现：

void inorderTraversal1(TreeNode *node)
{
  if (node == nullptr)
  {
    return;
  }
  inorderTraversal1(node->left);
  std::cout << node->val << " ," << std::endl;
  inorderTraversal1(node->right);
}

迭代代码实现

• 中序遍历：迭代法
• 使用栈保存遍历的结点，从根节点开始遍历
• 遍历顺序为先遍历左子树，接着遍历根节点，最后遍历右子树
• 所以如果有有左子树节点，则需要不断遍历其左子节点，并放到栈中保存
  • 当遍历到最左侧的叶子结点时，已经没有左子结点，则需要遍历当前根节点，对栈顶元素出栈
• 此时，对于这棵子树来说，已经遍历完了左子树和根节点，接下来需要遍历右子树了，所以当前遍历根节点转换到右子节点上来
• 如果右子节点为空，则继续从栈中取出栈顶元素来处理，
• 所以要实现不断遍历到最左侧的左子结点，需要使用while循环不断遍历到做左子结点并保存到栈中
• 如何左子结点遍历到叶子结点，则遍历当前的根节点，接着遍历他的右子节点，
• 如果右子节点为空，则从栈中取出之前遍历的左子节点，他是更上一层的父节点
• 如果右子节点和栈都为空了，则说明整棵树都遍历完了。

void inorderTraversal2(TreeNode *node)
{
  std::stack<TreeNode *> stack;
  TreeNode *curr = node;
  while (curr != nullptr || !stack.empty())
  {
    while (curr != nullptr) // 不断深入遍历左子节点，知道最左侧的叶子结点
    {
      stack.push(curr);
      curr = curr->left;
    }

    // 当前curr为叶子结点的左子节点，为空，需要从栈中取出栈顶元素来遍历
    curr = stack.top();
    stack.pop();
    // 打印
    std::cout << curr->val << " ," << std::endl;
    /**
     * 遍历他的右子节点
     * - 如果右子节点不为空，则以右子节点为根节点，继续遍历他的左子结点
     * - 如果右子节点为空，则当前这棵子树遍历完了，需要从栈中取出他对应的父节点进行遍历
     */
    curr = curr->right;
  }
}

3、前序遍历

• 前序遍历：先遍历根节点，再遍历左子树，最后是右子树

递归代码实现：

void preorderTraversal1(TreeNode *node)
{
  if (node == nullptr)
  {
    return;
  }
  std::cout << node->val << " ," << std::endl;
  preorderTraversal1(node->left);
  preorderTraversal1(node->right);
}

迭代代码实现：

• 前序遍历：迭代实现
• 使用栈保存遍历到的结点数据，先遍历根节点，再遍历左子树，最后遍历右子树

void preorderTraversal2(TreeNode *node)
{
  std::stack<TreeNode *> stack;
  while (node != nullptr || !stack.empty())
  {
    // 节点不为空，则不断获取他的左子节点，并放入到栈中
    while (node != nullptr)
    {
      std::cout << node->val << " ," << std::endl;
      stack.push(node);
      node = node->left;
    }

    /**
     * 当左子树都遍历完了（node为空），则取出栈中的元素（一定有数据），
     * 栈顶元素为当前node节点的父节点，取出来遍历他的右子树
     */
    TreeNode *topNode = stack.top();
    stack.pop();
    node = topNode->right;
  }
}

4、后续遍历

• 后序遍历：
• 先遍历左子树，再遍历右子树，最后是根节点

递归代码实现：

void postorderTraversal1(TreeNode *node)
{
  if (node == nullptr)
  {
    return;
  }
  postorderTraversal1(node->left);
  postorderTraversal1(node->right);
  std::cout << node->val << " ," << std::endl;
}

迭代代码实现：

• 后续遍历：迭代实现
• 后续遍历的顺序是，先遍历左子树，接着遍历右子树，最后才是根节点
• 同样先使用while循环不断遍历左子节点，并将遍历到的结点放到栈中
• 当遍历到左侧的叶子结点时，取出栈顶节点，但是该结点现在还不做出栈操作，而是先判断他的右子节点之前是否遍历过
• 如果之前没有遍历过，则继续以他的右子节点为根节点进行遍历，如果之前遍历过，则遍历遍历当前结点，并且栈顶元素出栈
• 此时说明这棵左子树全部遍历完成，需要将curr的遍历结点设置为空，以便从栈中取出他的父节点，继续遍历他的右子树
  • 现在的问题是如何判断他的右子节点之前是否遍历过，通过设置一个prev属性，继续当前遍历的结点

void postorderTraversal2(TreeNode *node)
{
  std::stack<TreeNode *> stack;
  TreeNode *curr = node;
  TreeNode *prev = nullptr;
  while (curr != nullptr || !stack.empty())
  {
    // 不断遍历查找他的左子节点
    while (curr != nullptr)
    {
      stack.push(curr);
      curr = curr->left;
    }

    // 左子树遍历完了，需要从获取出栈顶元素
    TreeNode *topNode = stack.top();
    // 判断之前是否遍历过他的右子节点,有左子节点，且之前没有遍历过-》继续遍历他的左子节点
    if (topNode->right != nullptr && prev != topNode->right)
    {
      curr = topNode->right;
    }
    else
    {
      // 出栈，
      stack.pop();
      std::cout << topNode->val << " ," << std::endl;
      prev = topNode;
      curr = nullptr; // 设置为空，让下一步从栈中取出父节点进行遍历
    }
  }
}

5、总结

• 树的深度优先遍历
• 一棵二叉树，可以继续分为根节点和左子树与右子树，所以一共有三种深度优先遍历顺序，分别是前序遍历，中序遍历和后续遍历，这三种遍历顺序都是相对于根节点来表示的。
• 树的深度优先遍历的递归实现方式，代码简单，就是有点太抽象了
• 转换成迭代方式，使用栈数据结构来保存遍历的结点，更易于理解，树的深度优先遍历，都是先找到他的最左侧子节点，所以需要通过while循环不断遍历树的左子结点并放入到栈中保存。而后再从栈中取出来使用。