LeetCode分类刷题：二叉树(Tree)——（二叉树之前序、中序、后序、层次遍历、深度相关、侧视图相关）

最新推荐文章于 2022-08-18 10:56:02 发布
最新推荐文章于 2022-08-18 10:56:02 发布
阅读量355 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JMW1407/article/details/108486487
版权

二叉树 Tree

二叉树(Tree)

1、定义

树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树是递归定义的，因此，与二叉树有关的题目基本都可以用递归思想解决，当然有些题目非递归解法也应该掌握，如非递归遍历节点等等。

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

2、二叉树之前序、中序、后序遍历

2.1、前序遍历

1、题目分析：用到stack来辅助运算。由于先序遍历的顺序是"根-左-右", 算法为：1. 把根节点push到栈中；2. 循环检测栈是否为空，若不空，则取出栈顶元素，保存其值，然后看其右子节点是否存在，若存在则push到栈中。再看其左子节点，若存在，则push到栈中。

class Solution {
public:
    vector<int>preorderTraversal(TreeNode *root)
		{
		     vector<int> path;
		     if(root == NULL)
		     	return path;
		    stack<TreeNode *> s;
		    TreeNode *p = root;
		    while(p != NULL || !s.empty())
		    {
		        while(p != NULL)
		        {
		            path.push_back(p->val);
		            s.push(p);
		            p = p->left;
		        }
		        if(!s.empty())
		        {
		            p = s.top();
		            s.pop();
		            p = p->right;
		        }
		    }
		    return path;
	}
};


vector<int>preorderTraversal(TreeNode *root)
		{
		    vector<int> path;
		     if(root == NULL)
		     	return path;
		    stack<TreeNode *> s;
		    s.push(root);
		    TreeNode *p = NULL;
		    while( !s.empty())
		    {
		         p = s.top();
		         s.pop():
		         path.push_back(p->val);

		        if(p->right != NULL)
		        {
		             s.push(p->right);
		        }
		        if(p->left != NULL)
		        {
		             s.push(p->left);
		        }
		    }
		    return path;
	}

2.2、中序遍历

void inorderTraversal(TreeNode *root, vector<int> &path)
{
    stack<TreeNode *> s;
    TreeNode *p = root;
    while(p != NULL || !s.empty())
    {
        while(p != NULL)
        {
            s.push(p); 
            p = p->left;
        }
        if(!s.empty())
        {
            p = s.top();
            path.push_back(p->val);
            s.pop();
            p = p->right;
        }
    }
}

2.3、后序遍历

vector<int> posOrderUnRecur1(TreeNode* root) {
 		vector<int> path;
		 if(root == NULL)
		    return path;
		if (root != NULL) {
			stack<TreeNode*> s1 ;
			stack<TreeNode*> s2 ;
			s1.push(root);
			while (!s1.empty()) {
				root = s1.top();
				s1.pop();
				s2.push(root);
				if (root->left != NULL) {
					s1.push(root->left);
				}
				if (root->right != NULL) {
					s1.push(root->right);
				}
			}
			while (!s2.empty()) {
				TreeNode* tmp = s2.top();
				s2.pop();
				path.push_back(tmp->val);
			}
		}

3、二叉树之层遍历

层次遍历

void breadthFirstSearch(TreeNode* root){
    queue<TreeNode*> nodeQueue;
    nodeQueue.push(root);
    while (!nodeQueue.empty()) {
        root = nodeQueue.front();
        cout << root->data;
        nodeQueue.pop();
        if (root->lchild) {
            nodeQueue.push(root->lchild);     // 先把左子树入队
        }
        if (root->rchild) {
            nodeQueue.push(root->rchild);     // 再把右子树入队
        }
    }
}

把二叉树打印成多行

从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
这里不就是层序遍历？可以采用上一题的解题策略，不过简单起见，将栈换成队列，并且没有方向之分，都是从左到右。

class Solution {
public:
        vector<vector<int> > Print(TreeNode* pRoot) {
            vector<vector<int> >result;
            if(pRoot == NULL)
                return result;
            queue<TreeNode*> q;
            q.push(pRoot);
            TreeNode* pHead;
            while(! q.empty())
            {
                vector<int>temp;
                int count = 0;
                int length = q.size();
                while((count++) < length)
                {
                     pHead = q.front();
                     temp.push_back(pHead->val);
                     q.pop();
                    if(pHead->left != NULL)
                        q.push(pHead->left);
                    if(pHead->right != NULL)
                        q.push(pHead->right);
                }
                result.push_back(temp);
            }
            return result;
        }
    
};

之字形打印二叉树

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
在这里插入图片描述

本题使用两个栈作为辅助容器。打印某一层全部节点时，把下一层的子节点保存到另一个栈内。如果当前打印的是奇数层，则先保存左子树节点再保存右子树节点到奇数栈内；如果当前打印的是偶数层，则先保存右子树在保存左子树节点到偶数栈内。
在这里插入图片描述

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int> > result;
        if(pRoot == NULL)
            return result;
        stack<TreeNode*>odd_s;
        stack<TreeNode*>even_s;
        odd_s.push(pRoot);
        TreeNode* pHead;
        while(!odd_s.empty() || !even_s.empty())
        {
            vector<int>temp;
            if(!odd_s.empty())
            {
                while(!odd_s.empty())
                {
                    pHead = odd_s.top();
                    temp.push_back(pHead->val);
                    odd_s.pop();
                    if(pHead->left != NULL)
                        even_s.push(pHead->left);
                    if(pHead->right != NULL)
                        even_s.push(pHead->right);
                }
                result.push_back(temp);
            }
            else
            {
                while(!even_s.empty())
                {
                    pHead = even_s.top();
                    temp.push_back(pHead->val);
                    even_s.pop();
                    if(pHead->right != NULL)
                        odd_s.push(pHead->right);
                    if(pHead->left != NULL)
                        odd_s.push(pHead->left);
                }
                result.push_back(temp);
            }
        }
        return result;
    }
};

4、二叉树之深度相关

4.1、二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。


题目要求：给定一个二叉树，找出它的最大深度。 最大深度是指的从根节点一直到最远的叶节点中所有的节点数目。

题目分析：求二叉树的最大深度问题用到深度优先搜索DFS，递归的完美应用。

题目解答：

==递归==
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        if(root->left == nullptr && root->right == nullptr) return 1;
        int maxleft = maxDepth(root->left);
        int maxright = maxDepth(root->right);
        return max(maxleft, maxright) + 1;
    }
};


==非递归==

```cpp
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == NULL)
            return  0;
        int maxDeep = 0;
        queue <TreeNode*>q;
        //根节点入队
        q.push(root);
        while (!q.empty()) {
            int width = q.size();
            //每遍历一层深度+1
            maxDeep += 1;
            //注意这里循环的次数是width,出队的仅仅是每一层的元素
            for (int i = 0; i < width; i++) {
                TreeNode* nodeTemp = q.front();
                q.pop();
                if (nodeTemp->left != NULL) {
                    q.push(nodeTemp->left);
                }
                if(nodeTemp->right != NULL) {
                    q.push(nodeTemp->right);
                }
            }
        }
        return maxDeep;
    }
    
};

4.2、平衡二叉树

原题链接

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4
返回 false 。


题目要求：求二叉树是否平衡，根据题目中的定义，高度平衡二叉树是每一个结点的两个子树的深度差不能超过1。

题目分析：我们肯定需要一个求各个点深度的函数，然后对每个节点的两个子树来比较深度差，时间复杂度为O(NlgN)。

题目解答：

class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if(root == NULL)
           return true;
        int left = TreeDepth(root->left);
        int right = TreeDepth(root->right);
        return abs(left -right) <= 1 &&
                isBalanced(root->left) &&
                isBalanced(root->right);
    }
    int TreeDepth(TreeNode* root)
    {
        if(root == NULL)
            return 0;
        return 1 + max(TreeDepth(root->left),TreeDepth(root->right));
    }
};

4.3、二叉树的直径


给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

 

示例 :
给定二叉树

          1
         / \
        2   3
       / \     
      4   5    
返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。

 

注意：两结点之间的路径长度是以它们之间边的数目表示。

题目要求：求二叉树的直径，并告诉了我们直径就是两点之间的最远距离。

题目分析：我们只要对每一个结点求出其左右子树深度之和，这个值作为一个候选值，然后再对左右子结点分别调用求直径对递归函数，这三个值相互比较，取最大的值更新结果res，因为直径不一定会经过根结点，所以才要对左右子结点再分别算一次。

题目解答：

class Solution {
public:
    int res = 0;
    int diameterOfBinaryTree(TreeNode* root) {
        diameterTree(root);
        return res;
    }
    int diameterTree(TreeNode* root) {
        if(root == NULL)
           return 0;
        int left = diameterTree(root->left);
        int right = diameterTree(root->right);
        res = max(res,left + right);
        return max(left,right) +1;
    }
};

4.4、二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回它的最小深度  2.



非递归做法

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == NULL)
            return  0;
        int minDeep = 0;
        queue <TreeNode*>q;
        //根节点入队
        q.push(root);
        while (!q.empty()) {
            int width = q.size();
            //每遍历一层深度+1
            minDeep += 1;
            //注意这里循环的次数是width,出队的仅仅是每一层的元素
            for (int i = 0; i < width; i++) {
                TreeNode* nodeTemp = q.front();
                q.pop();
                if(nodeTemp->left == NULL && nodeTemp->right == NULL)
                    return minDeep;
                if (nodeTemp->left != NULL) {
                    q.push(nodeTemp->left);
                }
                if(nodeTemp->right != NULL) {
                    q.push(nodeTemp->right);
                }
                
            }
        }
        return minDeep;

    }
};


递归做法

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        if(root->left == nullptr && root->right == nullptr) return 1;
        int minleft = minDepth(root->left);
        int minright = minDepth(root->right);
        if(minleft == 0 || minright == 0) return minleft + minright + 1;
        else return 1 + min(minDepth(root->left), minDepth(root->right));
    }
};

4.5、二叉树的坡度

给定一个二叉树，计算整个树的坡度。

一个树的节点的坡度定义即为，该节点左子树的结点之和和右子树结点之和的差的绝对值。空结点的的坡度是0。

整个树的坡度就是其所有节点的坡度之和。

 

示例：

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

解释：
结点 2 的坡度: 0
结点 3 的坡度: 0
结点 1 的坡度: |2-3| = 1
树的坡度 : 0 + 0 + 1 = 1
 

提示：

任何子树的结点的和不会超过 32 位整数的范围。
坡度的值不会超过 32 位整数的范围。



class Solution {
public:
    int res = 0;
    int findTilt(TreeNode* root) {
       
       TreeSum(root) ;
       return res;

    }
    int TreeSum(TreeNode* root)//,int& res
    {
        if(root == NULL)
           return 0;
        int left = TreeSum(root->left);
        int right = TreeSum(root->right);
        res += abs(left - right);
        return (left + right + root->val);
    }
};

5、二叉树之侧视图相关

5.1、二叉树每一行最右边的一个数字

题目要求：这道题要求我们打印出二叉树每一行最右边的一个数字。

题目分析：实际上是求二叉树层序遍历的一种变形，我们只需要保存每一层最右边的数字即可，这道题只要在之前层遍历那道题上稍加修改即可得到结果，还是需要用到数据结构队列queue，遍历每层的节点时，把下一层的节点都存入到queue中，每当开始新一层节点的遍历之前，先把新一层最后一个节点值存到结果中。

题目解答：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        if(root == nullptr) return res;
        queue<TreeNode*> que;
        que.push(root);
        while(que.size()){
            res.push_back(que.back()->val);
            int len = que.size();
            for(int i = 0; i < len; i++){
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};

6、二叉树之递归应用

6.1、判断两棵树是否相同

题目要求：判断两棵树是否相同。

题目分析：利用深度优先搜索DFS来递归。

题目解答：

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p == nullptr && q == nullptr) return true;
        if(p == nullptr || q == nullptr) return false;
        if(p->val != q->val) return false;
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

6.2、判断一棵树是否对称

题目要求：判断一棵树是否对称。
题目分析：利用深度优先搜索DFS来递归。
题目解答：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
       return root == nullptr || isSymmetricTree(root->left, root->right);
    }
    bool isSymmetricTree(TreeNode* p, TreeNode* q) {
        if(p == nullptr && q == nullptr) return true;
        if(p == nullptr || q == nullptr) return false;
        if(p->val != q->val) return false;
        return isSymmetricTree(p->left, q->right) && isSymmetricTree(p->right, q->left);
    }
};

6.3、翻转二叉树

题目要求：这道题让我们翻转二叉树。
题目分析：利用三种方法求解问题。
题目解答：

class Solution {
public:
    TreeNode* invertTree1(TreeNode* root) {
        if(root  == NULL)
           return root;
        TreeNode* temp = root->left;
        root->left = root->right;
        root->right = temp;
        root->left = invertTree(root->left);
        root->right = invertTree(root->right);
        return root;
    }
};


TreeNode* invertTree2(TreeNode* root){
        stack<TreeNode*> stk;
        stk.push(root);
        TreeNode *cur = root;
        while(stk.size()){
            cur = stk.top();
            stk.pop();
            if(cur){
                stk.push(cur->left);
                stk.push(cur->right);
                swap(cur->left, cur->right);
            }
        }
        return root;
    }


    TreeNode* invertTree3(TreeNode* root){
        queue<TreeNode*> que;
        que.push(root);
        TreeNode *cur;
        while(que.size()){
            cur = que.front();
            que.pop();
            if(cur){
                que.push(cur->left);
                que.push(cur->right);
                swap(cur->left, cur->right);
            }
        }
        return root;
    }
};

6.4、一个数是否是另一个树的子树

题目要求：这道题让我们求一个数是否是另一个树的子树。

题目分析：子树必须是从叶结点开始的，中间某个部分的不能算是子树，那么我们转换一下思路，是不是从s的某个结点开始，跟t的所有结构都一样，那么问题就转换成了判断两棵树是否相同，也就是两棵树是否相同的问题了，用递归来写十分的简洁，我们先从s的根结点开始，跟t比较，如果两棵树完全相同，那么返回true，否则就分别对s的左子结点和右子结点调用递归再次来判断是否相同，只要有一个返回true了，就表示可以找得到。

题目解答：

class Solution {
public:
    bool isSubtree(TreeNode* s, TreeNode* t) {
        if(s == nullptr) return false;
        if(isSameTree(s, t)) return true;
        return isSubtree(s->left, t) || isSubtree(s->right, t);
    }
    
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p == nullptr && q == nullptr) return true;
        if(p == nullptr || q == nullptr) return false;
        if(p->val != q->val) return false;
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

参考

1、https://blog.csdn.net/pushup8/article/details/86014556

JMW1407
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode篇（二叉树的前序、中序、后序遍历详解）
weixin_44638376的博客
02-18 256
LeetCode篇（二叉树的前序、中序、后序遍历详解） 1. 先附上LeetCode题链接 144. 二叉树的前序遍历 94. 二叉树的中序遍历 145. 二叉树的后序遍历 2. 采用递归 和 迭代两种方式进行遍历 2.1 前序遍历 2.1.1 递归方法 /********************** 递归 ***********************/ public List<Integer> preorderTraversal(TreeNode root) { if
树状数组学习+题集
FlyingJack
03-04 2225
lowbit函数：x&amp;-x 思想：lowbit函数找的是二进制最右边的1。计算机机器语言中，-x实际上是x的补码，补码是x取反加1。 举个例子 x = 00001100, -x = 11110011 + 1 = 11110100。通过按位取余这样就可以愉快的找到最右边的1了。思想和巧妙，看看例子应该好理解。 找到最右边的1有什么用？x+lowbit(x)可以使最后一位1向前进。还是...
力扣题---二叉树前、中、后序遍历
weixin_57535054的博客
05-01 917
二叉树前序遍历 我们先来了解题目。 输入：root = [1,null,2,3] 输出：[1,2,3] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输出：[1] 从示例不难看出，题目给定树的根结点，用前序遍历的方式，把二叉树的值放入数组中（若不知二叉树前、中、后序的顺序是什么，可以看这篇，里面有二叉树的详细解读 数据结构-二叉树-更新完整版 那么题目要求得知，这里思路则是： 1.首先我们需要一个数组，数组大小多大 2.我们需要去计...
树的序列化、反序列化【前序、后序、层序】及常见树的题目
weixin_45565886的博客
08-18 762
树的序列化、反序列化【前序、后序、层序】及常见树的题目
tree 先序遍历 叶子结点_6-11 先序输出叶结点 (15 分) 数据结构与算法题目集（中文）...
weixin_31826879的博客
01-30 154
本题要求按照先序遍历的顺序输出给定二叉树的叶结点。函数接口定义：void PreorderPrintLeaves( BinTree BT );其中BinTree结构定义如下：typedef struct TNode *Position;typedef Position BinTree;struct TNode{ElementType Data;BinTree Left;BinTree Right;...
python实现二叉树的俯视图
小猪观察家
01-20 2443
概要： 给一个二叉树，代码实现输出俯视图，如： 代码实现： #coding=utf8 #构造树节点 ''' 基本思想： 对于每个节点输出关于根节点的层级和左右距离 树从0层开始计数 左距离：左子树上节点对于跟节点为1 右距离：右字数上节点对于跟节点为-1 相当于以树的根节点为坐标原点，每个树中的节点对应一个坐标轴 横轴表示距离，纵轴表示树的深度 树的俯视图即输出：这些点映射到横轴上，
LeetCode 算法题库【94】——二叉树的中序遍历
12-21
二叉树的中序遍历 题目描述： 解题思路： 第一种：递归。又是递归，可以发现很多题都可以用到递归的思路…。二叉树的中序遍历，这里不太了解的可以看看这个博客：二叉树遍历，总结了二叉树的所有遍历情况。这道题所...
php-leetcode题解之从中序与后序遍历序列构造二叉树.zip
最新发布
06-07
这个压缩包"php-leetcode题解之从中序与后序遍历序列构造二叉树.zip"显然是针对LeetCode上的一道经典问题——根据中序和后序遍历序列构造二叉树的PHP解决方案。这个问题涉及到数据结构，特别是二叉树，以及递归算法...
【LeetCode】【树】106. 从中序与后序遍历序列构造二叉树
12-20
106题是LeetCode上的一道经典二叉树问题，要求根据给定的中序遍历（inorder）和后序遍历（postorder）序列来构造二叉树。二叉树的遍历有三种基本方式：前序遍历（root -> left -> right），中序遍历（left -> root -...
python-leetcode面试题解之第106题从中序与后序遍历序列构造二叉树-题解.zip
04-29
本题解是针对LeetCode中的第106题，该题要求从给定的中序遍历和后序遍历序列构建一棵二叉树。这里我们将详细探讨这个问题及其解决方案。 二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和...
pyplot显示二叉树
12-08
利用pyplot将二叉树打印出来便于直观观察 详情看 https://blog.csdn.net/Steven_L1994/article/details/84897961
【Java刷题】04_二叉树的左右视图
07-12 714
本题采用非递归的方式进行层序遍历。使用队列来实现。先判断根节点是否为空，如果不为空就入队，接着再把根节点的左右子树入队，然后都出队， 一、二叉树的右视图 题目》》》》》》》》》》》 2、方法二：深度优先搜索 按照根节点-》右子树-》左子树的顺序访问，可以保证每层都是最先访问最右边的节点。 二、二叉树的左视图..................
二叉树3. 层次遍历之二：3道变形题目
纵横千里 捭阖四方 的专栏
07-26 364
​我们继续看几个典型的层次遍历的题目 515.在每个树行中找最大值 637.二叉树的层平均值 199.二叉树的右视图 这三道题，515和637的思路基本一致，就是先要确定每层的元素，之后再求最大、最小、平均，都不在话下。 1.LeetCode 515. 在每个树行中找最大值 给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。 这里其实就是在得到一层之后使用一个变量来记录当前得到的最大值： class Solution { public List<I..
二叉树总结点睛
linping_的博客
04-27 534
一、二叉树 1、常见名词 DFS (depth first search ) 深度优先遍历 BFS （breadth first search ) 广度优先遍历 AVL（Adelson-Velsky and Landis） 平衡二叉搜索树 2、常见分类 满二叉树：是一种特殊的完全二叉树。只有度为0的节点和度为1的节点，且度为0的节点在同一层 完全二叉树：除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。 二叉搜索树：前面两种
二叉树遍历的几种方式
weixin_43132106的博客
03-09 207
一. 依据完整中序创建二叉树 先创建二叉树，才方便验证下面的遍历方法是否正确。思想就是采用队列先进先出的方式，每个节点离开队列的同时，将其左右子节点加入队列中，直至队列中无节点。直接给出代码： 数据结构如下： public class TreeNode { int val; TreeNode left; TreeNode right; public TreeNode(int val) { this.val = val; } } 创建方法如下：输入格式
J2SE_4_数据结构与算法（2）之树与二叉树
chuoyingzao4930的博客
04-27 73
上篇博文主要介绍的是数据结构的线性结构，我们这篇博文介绍非线性结构—树与二叉树，我先介绍树的一些基本概念，树的遍历，再介绍二叉树相关概念和特性，以及二叉树的遍历，最后再树与二叉树的对比，总结。 树为了描述现实世界的层次结构，树结构中一个数据元素可以有两个或两个以上...
码农小汪剑指Offer之36-二叉树的深度 层次遍历 分而冶之
汪小哥
04-05 627
题目描述输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。解题思路我已看到这个题目的时候，就想到了利用分冶的方法，利用递归的思路。我们只要找到出口，分了之后就要合并啊。和我们的归并排序有点意思哦，昨天晚上做的那个类似的思路。 当前结点的Length=max(left,right)+1; 这个就是我的解题思路！其实还有思路。比如
【力扣算法】105-从前序与中序遍历序列构造二叉树
ZeromaXHe的博客
06-20 435
题目 根据一棵树的前序遍历与中序遍历构造二叉树。 注意: 你可以假设树中没有重复的元素。 例如，给出 前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7] 返回如下的二叉树： 3 / \ 9 20 / \ 15 7 来源：力扣（LeetCode） 链接：https://leetcode-cn...
多叉树应用（多叉树创建， 遍历）
11-03 9665
多叉树创建， 遍历...
树的相关编程.docx
03-23
在本文档中，主要探讨了在编程中如何实现二叉树的三种基本遍历方式：先序遍历、中序遍历和后序遍历。这些遍历方法是数据结构和算法中常见的操作，对于理解二叉树的结构和处理树形数据具有重要意义。 1. **先序遍历*...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值