经典二叉树遍历问题的总结(LeetCode 105 和 106)

最新推荐文章于 2023-04-12 22:26:02 发布
最新推荐文章于 2023-04-12 22:26:02 发布
阅读量286 收藏 1
点赞数
分类专栏： 数据结构与算法 LeetCode 文章标签： 二叉树 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37477009/article/details/109542759
版权

经典二叉树遍历问题_仅指我个人的定义

1.第1类(给遍历，构造树)

(1)从中序与前序遍历构造二叉树

LeetCode 105. 从前序与中序遍历序列构造二叉树

①代码少，但性能一般

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0) return NULL;
        TreeNode *root = new TreeNode(preorder[0]);
        //左右子树的前序遍历和中序遍历；
        auto mid = find(inorder.begin(), inorder.end(), preorder[0]);
        vector<int> leftPreorder, leftInorder, rightPreorder, rightInorder; 
        //左子树的中序遍历
        leftInorder.assign(inorder.begin(), mid);
        //左子树的前序遍历
        leftPreorder.assign(preorder.begin() + 1, preorder.begin() + 1 + leftInorder.size());
        //右子树的前序遍历
        rightPreorder.assign(preorder.begin() + 1 + leftInorder.size(), preorder.end());
        //右子树的中序遍历
        rightInorder.assign(mid + 1, inorder.end());
        root->left = buildTree(leftPreorder, leftInorder);
        root->right = buildTree(rightPreorder, rightInorder);
        return root;
    }
};

在这里插入图片描述
②性能稍好，更常规的写法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* myBuildTree(const vector<int>& preorder, int headP, int tailP, const vector<int> &inorder, int headI, int tailI) {
        if(headP > tailP) return NULL;
        TreeNode *root = new TreeNode(preorder[headP]);
        //中序遍历中，根节点的下标
        int mid;
        for(int i = headI; i <= tailI; i++) {
            if(inorder[i] == preorder[headP]) {
                mid = i;
                break;
            }
        }
        //左子树
        root->left = myBuildTree(preorder, headP + 1, headP + mid - headI, inorder, headI, mid - 1);
        //右子树
        root->right = myBuildTree(preorder, headP + mid - headI + 1, tailP, inorder, mid + 1, tailI);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0) return NULL;
        TreeNode *root = myBuildTree(preorder, 0, preorder.size() - 1, inorder, 0, inorder.size() - 1);
        return root;
    }
};

在这里插入图片描述

(2)从中序与后序遍历构造二叉树

LeetCode 106. 从中序与后序遍历序列构造二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* myBuildTree(const vector<int>& inorder, int headI, int tailI, const vector<int>& postorder, int headP, int tailP) {
        //递归边界
        if(headI > tailI) return NULL;
        //递归式
        TreeNode *root = new TreeNode(postorder[tailP]);
        int mid; //中序遍历中，根节点的下标
        for(int i = headI; i<= tailI; i++) {
            if(inorder[i] == postorder[tailP]) {
                mid = i;
                break;
            }
        }
        int leftTreeNodeNumber = mid - headI;
        //左子树 中序遍历 后序遍历
        root->left = myBuildTree(inorder, headI, mid - 1, postorder, headP, headP + leftTreeNodeNumber - 1);
        root->right = myBuildTree(inorder, mid + 1, tailI, postorder, headP + leftTreeNodeNumber, tailP - 1);
        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0) return NULL;
        TreeNode *root = myBuildTree(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
        return root;
    }
};

(3)从中序与层序遍历构造二叉树

//从中序与层序遍历构造二叉树

#include<cstdio>
#include <vector>
using namespace std;
typedef unsigned int UL;
//Definition for a binary tree node.
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* myBuildTree(const vector<int>& inorder, int headI, int tailI, const vector<int> &levelorder, int headL, int tailL) {
    if(headI> tailI) return NULL;
    TreeNode *root = new TreeNode(levelorder[headL]);
    //中序遍历中，根节点的下标
    int mid = -1;
    for(int i = headI; i <= tailI; i++) {
        if(inorder[i] == levelorder[headL]) {
            mid = i;
            break;
        }
    }
    UL leftTreeNodeNUmber = mid - headI;
    UL rightTreeNodeNumber = inorder.size() - leftTreeNodeNUmber - 1;
    //构建左子树的层序遍历
    vector<int> leftLevelOrder;
    bool flag = false; //还未找全;
    for (int i = headL; i <= tailL; i++) {
        for (int j = headI; j <= mid - 1; j++) {
            if(levelorder[i] == inorder[j]) {      //既然左子树的层序遍历是分散的，根据左子树的中序遍历，可以把分散的收集到vector中；
                leftLevelOrder.push_back(levelorder[i]);
                if(leftLevelOrder.size() == (leftTreeNodeNUmber))
                    flag = true; //找全了
                break;
            }
        }
        if(flag)
            break;
    }
    //构建右子树的层序遍历
    vector<int> rightLevelOrder;
    flag = false; //还未找全;
    for (int i = headL; i <= tailL; i++) {
        for (int j = mid + 1; j <= tailI; j++) {
            if(levelorder[i] == inorder[j]) {
                rightLevelOrder.push_back(levelorder[i]);
                if(rightLevelOrder.size() == rightTreeNodeNumber) {
                    flag = true; //找全了
                    break;
                }
            }
        }
        if(flag)
            break;
    }

    //左子树
    root->left = myBuildTree(inorder, headI, mid - 1, leftLevelOrder, 0, leftTreeNodeNUmber - 1);
    //右子树
    root->right = myBuildTree(inorder, mid + 1, tailI, rightLevelOrder, 0, rightTreeNodeNumber - 1);
    return root;
}

TreeNode* buildTree(vector<int>& inorder, vector<int>& levelorder) {
    if(inorder.size() == 0) return NULL;
    TreeNode *root = myBuildTree(inorder, 0, inorder.size() - 1, levelorder, 0, levelorder.size() - 1);
    return root;
}

void preOrder(TreeNode *root) {
    if(root == NULL)
        return;
    printf("%d ", root->val);
    preOrder(root->left);
    preOrder(root->right);
}

int main() {
    //测试
    //input
    vector<int> inorder = {7, 5, 4, 2, 8, 6, 9}, levelorder = {4, 5, 6, 7, 8, 9, 2};
    TreeNode *root = buildTree(inorder, levelorder);
    //前序遍历验证
    preOrder(root);
    return 0;
}

在这里插入图片描述

总结：(1)~(2)思路一致(注释已说明)，(3)多了一个步骤：根据子树的中序遍历和树的层序遍历求子树的层序遍历(求法见代码)。
(1)~(2)难度相当，(3)较难点

2.第2类(给遍历，求遍历)

(1)中序遍历 + 前序遍历 -> 后序遍历 || 层序遍历

①求后序遍历

void postOrder(vector<int>& postorder, const vector<int>& inorder, int headI, int tailI, const vector<int>& preorder, int headP, int tailP) {
    //递归边界；
    if(headI > tailI)
        return;
    //找中序遍历中根节点的下标
    int mid;
    for (int i = headI; i <= tailI; i++) {
        if(inorder[i] == preorder[headP]) {
            mid = i;
            break;
        }
    }

    int leftTreeNodeNumber = mid - headI;
    //后序遍历
    //左子树
    postOrder(postorder, inorder, headI, mid - 1, preorder, headP + 1, headP + leftTreeNodeNumber);
    //右子树
    postOrder(postorder, inorder, mid + 1, tailI, preorder, headP + leftTreeNodeNumber + 1, tailP);
    postorder.push_back(preorder[headP]);
}

②求层序遍历(本文：先建树(见上文[1.(1)])后层序遍历)

(2)中序遍历 + 后序遍历 -> 前序遍历 || 层序遍历

①前序遍历

void preOrder(vector<int>& preorder, const vector<int>& inorder, int headI, int tailI, const vector<int>& postorder, int headP, int tailP) {
    //递归边界；
    if(headI > tailI)
        return;
    //找中序遍历中根节点的下标
    int mid = -1;
    for (int i = headI; i <= tailI; i++) {
        if(inorder[i] == postorder[tailP]) {
            mid = i;
            break;
        }
    }
    int leftTreeNodeNumber = mid - headI;
    //前序遍历
    preorder.push_back(postorder[tailP]);
    //左子树
    preOrder(preorder, inorder, headI, mid - 1, postorder, headP, headP + leftTreeNodeNumber - 1);
    //右子树
    preOrder(preorder, inorder, mid + 1, tailI, postorder, headP + leftTreeNodeNumber, tailP - 1);
}

②求层序遍历(本文：先建树(见上文[1.(2)])后层序遍历)

(3)中序遍历 + 层序遍历 -> 前序遍历 || 后序遍历

①求前序遍历

//前序遍历
void preOrder(vector<int>& preorder, const vector<int>& inorder, int headI, int tailI, const vector<int> &levelorder, int headL, int tailL) {
    if(headI> tailI) return;
    //中序遍历中，根节点的下标
    int mid = -1;
    for(int i = headI; i <= tailI; i++) {
        if(inorder[i] == levelorder[headL]) {
            mid = i;
            break;
        }
    }
    UL leftTreeNodeNumber = mid - headI;
    UL rightTreeNodeNumber = inorder.size() - leftTreeNodeNumber - 1;
    //构建左子树的层序遍历
    vector<int> leftLevelOrder;
    bool flag = false; //还未找全;
    for (int i = headL; i <= tailL; i++) {
        for (int j = headI; j <= mid - 1; j++) {
            if(levelorder[i] == inorder[j]) {      //既然左子树的层序遍历是分散的，根据左子树的中序遍历，可以把分散的收集到vector中；
                leftLevelOrder.push_back(levelorder[i]);
                if(leftLevelOrder.size() == (leftTreeNodeNumber))
                    flag = true; //找全了
                break;
            }
        }
        if(flag)
            break;
    }
    //构建右子树的层序遍历
    vector<int> rightLevelOrder;
    flag = false; //还未找全;
    for (int i = headL; i <= tailL; i++) {
        for (int j = mid + 1; j <= tailI; j++) {
            if(levelorder[i] == inorder[j]) {
                rightLevelOrder.push_back(levelorder[i]);
                if(rightLevelOrder.size() == rightTreeNodeNumber) {
                    flag = true; //找全了
                    break;
                }
            }
        }
        if(flag)
            break;
    }

    //前序遍历
    preorder.push_back(levelorder[headL]);
    preOrder(preorder, inorder, headI, mid - 1, leftLevelOrder, 0, leftTreeNodeNumber - 1);
    preOrder(preorder, inorder, mid + 1, tailI, rightLevelOrder, 0, rightTreeNodeNumber - 1);
}

②后序遍历

和上面①前序遍历代码几乎一致，最大的差别仅在最后三行，即：①是前序遍历，②是后序遍历)

//后序遍历
void postOrder(vector<int>& postorder, const vector<int>& inorder, int headI, int tailI, const vector<int> &levelorder, int headL, int tailL) {
    if(headI> tailI) return;
    //中序遍历中，根节点的下标
    int mid = -1;
    for(int i = headI; i <= tailI; i++) {
        if(inorder[i] == levelorder[headL]) {
            mid = i;
            break;
        }
    }
    UL leftTreeNodeNumber = mid - headI;
    UL rightTreeNodeNumber = inorder.size() - leftTreeNodeNumber - 1;
    //构建左子树的层序遍历
    vector<int> leftLevelOrder;
    bool flag = false; //还未找全;
    for (int i = headL; i <= tailL; i++) {
        for (int j = headI; j <= mid - 1; j++) {
            if(levelorder[i] == inorder[j]) {      //既然左子树的层序遍历是分散的，根据左子树的中序遍历，可以把分散的收集到vector中；
                leftLevelOrder.push_back(levelorder[i]);
                if(leftLevelOrder.size() == (leftTreeNodeNumber))
                    flag = true; //找全了
                break;
            }
        }
        if(flag)
            break;
    }
    //构建右子树的层序遍历
    vector<int> rightLevelOrder;
    flag = false; //还未找全;
    for (int i = headL; i <= tailL; i++) {
        for (int j = mid + 1; j <= tailI; j++) {
            if(levelorder[i] == inorder[j]) {
                rightLevelOrder.push_back(levelorder[i]);
                if(rightLevelOrder.size() == rightTreeNodeNumber) {
                    flag = true; //找全了
                    break;
                }
            }
        }
        if(flag)
            break;
    }

    //后序遍历
    postOrder(postorder, inorder, headI, mid - 1, leftLevelOrder, 0, leftTreeNodeNumber - 1);
    postOrder(postorder, inorder, mid + 1, tailI, rightLevelOrder, 0, rightTreeNodeNumber - 1);
    postorder.push_back(levelorder[headL]);

}

总结：思路和1.(3)几乎一致，只不过需求不同，一个是建树，一个仅需把遍历结果存储在vector中。

3.总结

在这里插入图片描述
①第1类，会(1)便会(2)，反而(3)需要留心一下；
②第2类，同样是会(1)便会(2)，而且思路和第1类是一致的，只是需求不同，第1类是建树，第2类是仅需把遍历结果存储在vector中即可。反而求层序遍历需要留心一下，本文采用先构建树再层序遍历的方式，不建树的方式见给定二叉树的中序遍历和后序遍历，不建树求其层序遍历(PAT A1020)。
③对于(3)，思路和第1类的(3)相同，也只是需求不同。

南七行者
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树前序、中序、后序遍历非递归写法的透彻解析
CCPP Blog
07-06 13万+
前言 在前两篇文章二叉树和二叉搜索树中已经涉及到了二叉树的三种遍历。递归写法，只要理解思想，几行代码。可是非递归写法却很不容易。这里特地总结下，透彻解析它们的非递归写法。其中，中序遍历的非递归写法最简单，后序遍历最难。我们的讨论基础是这样的：
二叉树的遍历汇总，刷题必备
qq_40692109的博客
05-16 1779
1.简介 二叉树的遍历主要分为深度优先遍历和广度优先遍历两大类，其中深度优先遍历又分为前序遍历、中序遍历、后序遍历。我们以下面这棵树来具体说明这些遍历之间的区别。 广度优先遍历：从左到右依次遍历每一层，即按1 2 3 4 5 6顺序遍历。 前序遍历：先遍历父节点，再遍历左子树，最后遍历右...
数据结构——二叉树遍历和常见问题
weixin_57133901的博客
04-22 3195
二叉树遍历 二叉树常见问题
二叉树的遍历+基础练习
weixin_53316121的博客
04-14 7929
前面完全二叉树适合存放数据，又因为它在内存中连续存储，因此用顺序表来实现它，并介绍了堆排序及TOP-K问题。 今天我们了解一下二叉树的遍历问题，并完成几道二叉树基础OJ题目。 二叉树的遍历 二叉树的遍历有：前序/中序/后序的递归结构遍历： 1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。 2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之间。 3. 后序遍历(Postorder Trave
二叉树的常见问题及其解决程序
yangcs2009的专栏
09-29 3471
二叉树的常见问题有如下几个，如果解决好了，就跟链表一样轻松：唯一不一样的是，二叉树是非线性结构。常见的问题如下： 二叉树的问题 1.二叉树三种周游（traversal）方式： [cpp] view plaincopy 二叉树的问题  1.二叉树三种周游（traversal）方式：  2.怎样从顶部开始逐层打印二叉树结点数据  3.如何判断一棵二叉树是否是平衡二叉树 
二叉树的遍历以及笔试题
qq_34896730的博客
08-17 9059
本篇介绍二叉树最常见的三种遍历方式：先序、中序和后序遍历方式。 1、定义       二叉树是由3个基本单元组成：根节点、左子树和右子树。因此，若能依次遍历这三部分，便是遍历了整个二叉树。例如从L、D、R分别表示遍历左子树、访问根节点和遍历右子树，则可有DLR、LDR、LRD、DRL、RDL、RLD这6种遍历二叉树的方案。若限定先左后右，则只有前3种情况，分别称为先(根)序遍历、中(根)序遍历和后(根)序遍历。基于二叉树的递归定义，可得下述遍历二叉
leetcode107. 二叉树的层次遍历 II
12-23
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历） 例如： 给定二叉树 [3,9,20,null,null,15,7],  3  / \  9 20  / \  15 7 返回其自底向上的...
leetcode102. 二叉树的层次遍历
01-06
leetcode 102. 二叉树的层次遍历 ...想法和思路来源于leetcode104二叉树的最大深度。记录下每一层有几个节点。 public List<List> levelOrder(TreeNode root) { if(root==null)return new ArrayList
【leetcode】二叉树的锯齿形层次遍历
12-21
给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。 例如： 给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回锯齿...
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所说的中序遍历，就是按照这个顺序：左子树—> 根结点 —> 右子树的顺序来遍历的。那么递归就很好写了，我还是...
力扣二叉树专题（二）-二叉树的层序遍历的10道题集 迭代和递归C++实现 思路 详细注释
UUUUU22的博客
04-12 858
力扣二叉树专题（二下）-二叉树的层序遍历的10道题集 题102、107、199、637、429、515、116、117、101、111 迭代 递归 C++实现 思路 详细注释
二叉树的遍历以及遇到的一些问题
给永远比拿愉快
10-22 5928
今天在学习二叉树的遍历，
二叉树常见问题整理
yy254117440的博客
11-22 4643
做leetcode二叉树的题目做了不少，觉得有必要总结一下。因为题型多归多，但其实无非就是dfs和bfs，总结一些常见的解法，对于加深这两周算法的理解很有帮助。 在做dfs的时候，主要思路是可以从上到下也可以从下到上，也就是分析每一个子树的根节点，然后分析该子树的内部子树或者外部子树的根节点，以此得出递归关系，也即是分治的思想。同时，对于每个节点的处理尝试利用前序、后序、中序遍历三种方法。 做b
关于二叉树遍历的小问题
weixin_45970688的博客
04-26 196
1、求二叉树的节点个数 1）. 遍历二叉树，遇到每个节点加一； private static int treeSize = 0; private static void size(Node root) { if (root == null) { return; } treeSize++; size(root.left); size(root.right); } 2...
二叉树的三种遍历问题
su_bao的博客
07-06 1795
1、先序遍历：【根左右】            所谓【根左右】是指先遍历根节点，然后左孩子节点，最后右孩子节点。      所以，上图的遍历顺序是：ABCDEF2、中序遍历：【左根右】      先左孩子节点，然后根节点，最后遍历右孩子。     上图的遍历顺序是：CBDAEF3、后序遍历：【左右根】      先左孩子节点，然后右孩子节点，最后根节点。     上图的遍历顺序是：CDBFEA...
二叉树层序遍历与获取二叉树深度的应用
Allen_Xu17
11-13 476
不同于中序、前序、和后续遍历使用栈，层序遍历使用的是队列！ 代码如下： void level_order(tree_pointer ptr){ int front = rear = 0; tree_pointer queue[MAX_QUEUE_SIZE]; if(!ptr) return ; /* empty tree*/ addq(front...
二叉树的重难点问题总结
jinyu_mobao的博客
04-29 2163
一.二叉树的删除 删除二叉树的一个结点要分为三种情况去处理： （1）该结点是一个叶子结点 处理办法：其双亲结点的相应指针域的值改为null （2）该结点只有左子树或者右子树 处理办法：其双亲结点指针域的值改为“指向被删除结点的左子树或右子树” （3）该结点既有左子树又有右子树 处理办法：用这个结点的前驱替换这个结点，然后删去前驱结点 二.二叉树的重要性质...
LeetCode_二叉树实用知识库分享
最新发布
11-10
通过这些LeetCode的二叉树题目，我们可以深入学习和实践二叉树的创建、遍历、操作和查找等核心概念，从而提升算法能力，更好地解决实际问题。同时，这些题目也提供了丰富的练习机会，帮助开发者提高编程技巧和解决...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值