Leetcode之树

已于 2022-09-09 10:11:20 修改
阅读量367 收藏
点赞数
分类专栏： LeetCode 文章标签： leetcode 树结构
于 2021-12-02 11:59:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38773342/article/details/121671289
版权
本文详细介绍了二叉树的各种遍历方法（前序、中序、后序），包括递归和非递归实现，并展示了如何进行二叉树的镜像、深度计算、寻找第k大节点、最近公共祖先、平衡性和对称性的判断。此外，还涵盖了自上而下的不同层次遍历以及二叉搜索树的后序遍历序列验证。
摘要由CSDN通过智能技术生成

0 二叉树的遍历

前序法：访问根结点→左子树→右子树 口诀：根左右
在这里插入图片描述

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        return [root.val] + self.preorderTraversal(root.left) + self.preorderTraversal(root.right)

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if not root:
            return res
        def dfs(root):
            res.append(root.val)
            if root.left:
                dfs(root.left)
            if root.right:
                dfs(root.right)
        
        dfs(root)
        return res

中序法：访问左子树→根结点→右子树 口诀：左根右
在这里插入图片描述

后序法：访问左子树→右子树→ 根结点 口诀：左右根

在这里插入图片描述

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#

res1,res2,res3 = [],[],[]
class Solution:
    def preorder(self, root: TreeNode):
        if root:
            res1.append(root.val)
            self.preorder(root.left)
            self.preorder(root.right)
        return res1
    
    def midorder(self, root: TreeNode):
        if root:
            self.midorder(root.left)
            res2.append(root.val)
            self.midorder(root.right)
        return res2
    
    def lastorder(self, root: TreeNode):
        if root:
            self.lastorder(root.left)
            self.lastorder(root.right)
            res3.append(root.val)
        return res3
    
    def threeOrders(self , root: TreeNode) -> List[List[int]]:
        ret = []
        ret.append(self.preorder(root))
        ret.append(self.midorder(root))
        ret.append(self.lastorder(root))
        return ret

1 二叉树镜像

在这里插入图片描述

struct TreeNode* mirrorTree(struct TreeNode* root){
    if(root == NULL)
        return root;
    
    struct TreeNode * tmp = root->right;
    root->right = root->left;
    root->left = tmp;

    mirrorTree(root->right);
    mirrorTree(root->left);
    return root;
}

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root: return root
        root.left, root.right = root.right, root.left
        
        self.mirrorTree(root.left)
        self.mirrorTree(root.right)
        return root

栈的思想

class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        if not root: return root
        stack = [root]
        while stack:
            node = stack.pop(0)
            if node.left: stack.append(node.left)
            if node.right: stack.append(node.right)
            node.left, node.right = node.right, node.left  # key operation
        return root

2 二叉树的深度

对于每个根节点来说，寻找其每个子节点的最大深度
先序遍历，递归实现

int maxDepth(struct TreeNode* root){
    if(root == NULL)
        return 0;
    else
        return fmax(maxDepth(root->left), maxDepth(root->right)) + 1;
}

在这里插入图片描述
层序遍历：

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        queue,res = [root], 0
        while queue:
            t = []
            for node in queue:
                if node.left: t.append(node.left)
                if node.right: t.append(node.right)
            queue = t
            res += 1
        return res

3 二叉搜索树中第k大的节点

给定一棵二叉搜索树，请找出其中第k大的节点。

二叉搜索树：左子树不大于根节点、右子树不小于根节点
要点：二叉搜索树的中序遍历为 递增序列
思路：首先申请一个数组空间，保存二叉搜索树的中序遍历，输出第 k-1 位，这里注意我们在中序遍历的时候使用的是先右子树在左子树，这样得到的中序遍历是 递减序列，这样我们直接输出 k-1 即为第 k 大的节点了。

void func(struct TreeNode *root, int *count, int *res)
{
    if(root != NULL) {
        func(root->right, count, res);
        res[(*count)++] = root->val;
        func(root->left, count, res);
    }  
}
int kthLargest(struct TreeNode* root, int k){
    int *res = (int *)malloc(sizeof(int)*10000);
    int count = 0;
    func(root, &count, res);
    return res[k-1];
}

层序遍历，取出所有的元素，排序后输出

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:
        que = [root]
        t = []
        len_que = len(que)
        while que:
            for _ in range(len(que)):
                node = que.pop(0)
                t.append(node.val)
                if node.left: que.append(node.left)
                if node.right: que.append(node.right)
            len_que = len(que) 
        t.sort(reverse=True)  
        return t[k-1]

中序遍历

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:
        def dfs(root):
            if not root: return
            dfs(root.right)
            if self.k == 0: return
            self.k -= 1
            if self.k == 0: self.res = root.val
            dfs(root.left)
        self.k = k
        dfs(root)
        return self.res

4 二叉树的最近公共祖先

最近公共祖先的定义为：对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。

思路：
lowestCommonAncestor(root, p, q) 的功能就是找出以 root 为根节点的两个节点 p q 的最近公共祖先，所以递归体要分三种情况讨论：
如果 p q 分别是 root 的左右节点，那么 root 就是我们要找的最近的公共祖先
如果 p q 都是 root 的右节点，那么返回 lowestCommonAncestor(root->right, p, q)
如果 p q 都是 root 的左节点，那么返回 lowestCommonAncestor(root->left, p, q)

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q){
    if(root == NULL || root == p || root == q)
        return root;
    struct TreeNode * left = lowestCommonAncestor(root->left, p, q);
    struct TreeNode * right = lowestCommonAncestor(root->right, p, q);
    if(left != NULL && right != NULL)
        return root;
    if(left == NULL && right != NULL)
        return right;
    if(left != NULL && right == NULL)
        return left;
    else
        return NULL;
}

5 二叉搜索树的最近公共祖先

此题与第4题类似，但条件不同的是二叉树，此题为二叉搜索树，二叉搜索树有一个性质就是左子树的值小于根节点，右子树的值大于根节点

思路一：同第四题
思路二：
当 p q 都是右子树时，root = root->right
当 p, q 都在左子树时， root = root->left
否则，说明找到了 最近公共祖先 ，跳出

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    while(root != NULL)
    {
        if(root->val < q->val && root->val < p->val){
            root = root->right;
        }
        else if(root->val > q->val && root->val > p->val){
            root = root->left;
        } else {
            break;
        }
    }
    return root;
}

思路三： 递归，原理是一样的

truct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    while(root != NULL)
    {
        if(root->val < q->val && root->val < p->val){
            return lowestCommonAncestor(root->right, p, q);
        }
        else if(root->val > q->val && root->val > p->val){
            return lowestCommonAncestor(root->left, p, q);
        } else {
            break;
        }
    }
    return root;
}

6 平衡二叉树

平衡二叉树的定义是：任意节点的左右子树的深度不超过1
思路1：先序遍历求深度+判断深度

int max_dep(struct TreeNode* root)
{
    if(root == NULL)
        return 0;
    else
        return fmax(max_dep(root->left), max_dep(root->right)) + 1;
}

bool isBalanced(struct TreeNode* root){
    if(root == NULL)
        return true;
    else
        return (fabs(max_dep(root->right)-max_dep(root->left)) <= 1 
        && isBalanced(root->left) && isBalanced(root->right)); 
}

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def depth(root):
            if not root: return 0
            return max(depth(root.left), depth(root.right)) + 1
        if not root: return True
        return abs(depth(root.left)-depth(root.right)) <= 1 and self.isBalanced(root.left) and self.isBalanced(root.right)

思路2：后序遍历 + 剪枝
后续遍历的顺序是 左右根
我们通过判断节点的左右子树的深度差，如果小于等于1，就返回子树的深度，否则直接返回 -1 表示当前二叉树不是平衡二叉树。

int func(struct TreeNode* root)
{
    if(root == NULL)
        return 0;
    int left = func(root->left);
    int right = func(root->right);
    if(left == -1 || right == -1)
        return -1;
    return fabs(left-right) < 2 ? fmax(left, right)+1 :-1;
}

bool isBalanced(struct TreeNode* root){
    if(root == NULL)
        return true;
    else
        return func(root) != -1;
}

7 对称二叉树

在这里插入图片描述

思路：对称二叉树有一个性质，那就是对称节点的值相等，以及
L.left.val = R.right.val
L.right.val = R.left.val

注意递归结束的边界：
左节点和右节点都为空 -> 到底了都长得一样 ->true
左节点为空的时候右节点不为空，或反之 -> 长得不一样-> false
左右节点值不相等 -> 长得不一样 -> false

int func(struct TreeNode* p, struct TreeNode* q)
{
    if(p == NULL && q == NULL)
        return true;
    else if (p == NULL || q == NULL || p->val != q->val)
        return false;
    else
        return func(p->left, q->right) && func(p->right, q->left);
}
bool isSymmetric(struct TreeNode* root){
    if(root == NULL)
        return true;
    else 
        return func(root->left, root->right);
}

层序遍历（注意弹出操作）

def isSymmetric(root):
    if not root: return True
    que=[root]
    len_que=len(que)
    while que:
        temp=[]
        for _ in range(len_que):
            node=que.pop(0) 			# key point
            if node: 
                temp.append(node.val)
                que.append(node.left)
                que.append(node.right)
            else:
                temp.append(None)
        if temp!=temp[::-1]: return False
        len_que=len(que)		# resize the length
    return True

8 自上而下打印二叉树 I

二叉树的 广度优先搜索（BFS）BFS 通常借助 队列 的先入先出特性来实现。
例如:
给定二叉树: [3,9,20,null,null,15,7],
在这里插入图片描述

返回：[3,9,20,15,7]

思路：首先构建一个队列和一个数组，节点依次入队出队，出队的节点的值将会被保存到返回数组中
拿上面的例子来说，先将节点3入队，出队保存到数组，因为节点3的左右子树均不为空，将左右子树9,20入队，9出队，因为9的左右子树为空，20出队，接着将15,7入队…

#define MAX_NUM 2000

int *levelOrder(struct TreeNode *root, int *returnSize)
{
    *returnSize = 0;
    if (root == NULL) {
        return NULL;
    }

    int *ret = (int *)malloc(sizeof(int) * MAX_NUM);
    if (ret == NULL) {
        return NULL;
    }

    struct TreeNode *queue[MAX_NUM];
    int head = 0;
    int tail = 0;
    queue[tail++] = root;

    while (head != tail) {
        int last = tail;
        while (head < last) {
            struct TreeNode *cur = queue[head++];
            ret[(*returnSize)++] = cur->val;
            if (cur->left != NULL) {
                queue[tail++] = cur->left;
            }
            if (cur->right != NULL) {
                queue[tail++] = cur->right;
            }
        }
    }
    return ret;
} 

class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            node = queue.popleft()
            res.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        return res

9 自上而下打印二叉树 II

例如:
给定二叉树: [3,9,20,null,null,15,7],
在这里插入图片描述
返回：
[ [3], [9,20], [15,7] ]

思路：此题的返回数组要求是一个二维数组，思想和上一题是一样的，每次按层输出一个数组，C语言操作起来的确是复杂的很…

#define MAXSIZE 2000
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
{
    if (root == NULL) {
        *returnSize = 0;
        return NULL;
    }

    struct TreeNode *queue[MAXSIZE] = {0};
    int head = 0;
    int tail = 0;
    int **ret = (int**)malloc(sizeof(int*) * MAXSIZE);
    if (ret == NULL) {
        return NULL;
    }
    memset(ret, 0, sizeof(int*) * MAXSIZE);

    *returnColumnSizes = (int*)malloc(sizeof(int*) * MAXSIZE);
    if (*returnColumnSizes == NULL) {
        return NULL;
    }
    memset(*returnColumnSizes, 0, sizeof(int*) * MAXSIZE);

    queue[tail++] = root;   //push
    *returnSize = 0;
    while (head < tail) {
        int size = (tail - head + MAXSIZE) % MAXSIZE;
        (*returnColumnSizes)[*returnSize] = size;
        ret[*returnSize] = (int*)malloc(sizeof(int) * size);
        for (int i = 0; i < size; i++) {
            struct TreeNode *temp = queue[head++];  //pop
            ret[*returnSize][i] = temp->val;
            if (temp->left != NULL) {
                queue[tail++] = temp->left;
            }
            if (temp->right != NULL) {
                queue[tail++] = temp->right;
            }
        }
        (*returnSize)++;
    }
    return ret;
}

class Solution(object):
    def levelOrder(self, root):
        que = [root]
        len_que = len(que)
        res = []
        if not root: return res
        while que:
            tmp = []
            for _ in range(len_que):
                node = que.pop(0)
                tmp.append(node.val)
                if node.left: que.append(node.left) 
                if node.right: que.append(node.right)
            len_que = len(que) 
            res.append(tmp)   
        return res

10 自上而下打印二叉树 III

要求在输出的时候，每偶数行逆序
思路：核心思想和前面两题是一样的，在实现上，只需要在第二题的基础上，判断是否是偶数行，如果是就逆序。

#define MAXSIZE 2000
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
{
    if (root == NULL) {
        *returnSize = 0;
        return NULL;
    }

    struct TreeNode *queue[MAXSIZE] = {0};
    int head = 0;
    int tail = 0;
    int **ret = (int**)malloc(sizeof(int*) * MAXSIZE);
    if (ret == NULL) {
        return NULL;
    }
    memset(ret, 0, sizeof(int*) * MAXSIZE);

    *returnColumnSizes = (int*)malloc(sizeof(int*) * MAXSIZE);
    if (*returnColumnSizes == NULL) {
        return NULL;
    }
    memset(*returnColumnSizes, 0, sizeof(int*) * MAXSIZE);

    queue[tail++] = root;   //push
    *returnSize = 0;
    while (head < tail) {
        int size = (tail - head + MAXSIZE) % MAXSIZE;
        (*returnColumnSizes)[*returnSize] = size;
        ret[*returnSize] = (int*)malloc(sizeof(int) * size);
        for (int i = 0; i < size; i++) {
            struct TreeNode *temp = queue[head++];  //pop
            ret[*returnSize][i] = temp->val;
            if (temp->left != NULL) {
                queue[tail++] = temp->left;
            }
            if (temp->right != NULL) {
                queue[tail++] = temp->right;
            }
        }
        if((*returnSize) % 2 != 0){
            for(int i = 0; i < size/2; i++){
                int temp;
                temp = ret[*returnSize][i];
                ret[*returnSize][i] = ret[*returnSize][size-1-i];
                ret[*returnSize][size-1-i] =  temp;
            }                        
        }
        (*returnSize)++;
    }
    return ret;
}

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        tmp, queue = [], collections.deque()
        if not root: return tmp
        queue.append(root)
        len_que = len(queue)
        k = 2
        while queue:
            res = []
            for _ in range(len_que):
                node = queue.popleft()
                res.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            tmp.append(res) if k%2==0 else tmp.append(res[::-1])
            k += 1
            len_que = len(queue)
        return tmp

11 二叉搜索树的后序遍历序列

判断给定序列是否是二叉搜索树的后续遍历序列
思路：首先题目给的是二叉搜索树的条件，我们知道二叉搜索树的性质是，根节点、左子树、右子树的大小关系为 left < root < right，同时，后续遍历序列是 左右根 那么得到的序列的最后一个元素必然是根节点，那么我们从根节点往前找，前一小搓是左子树，他的值肯定是小于根节点的，我们就从前

bool verifyPostorder(int* postorder, int postorderSize){
    if(postorderSize == 0 || postorderSize == 1)
        return true;
    int i,j;
    for(i = 0; i < postorderSize - 1; i++){
        if(postorder[i] > postorder[postorderSize-1])
            break;
    }
    for(j = i; j < postorderSize - 1; j++){
        if(postorder[j] < postorder[postorderSize-1])
            return false;
    }   
    return verifyPostorder(postorder, i) && verifyPostorder(&postorder[i], postorderSize-1-i);
}

class Solution:
    def verifyPostorder(self, postorder: [int]) -> bool:
        def recur(i, j):
            if i >= j: return True
            p = i
            while postorder[p] < postorder[j]: p += 1
            m = p
            while postorder[p] > postorder[j]: p += 1
            return p == j and recur(i, m - 1) and recur(m, j - 1)

        return recur(0, len(postorder) - 1)

class Solution:
    def verifyPostorder(self, postorder: List[int]) -> bool:
        if not postorder: return True
        index, n = 0, len(postorder)
        while index < n and postorder[index] < postorder[-1]:
            index += 1
        for i in range(index, n-1):
            if postorder[i] < postorder[-1]:
                return False
        return self.verifyPostorder(postorder[:index]) and self.verifyPostorder(postorder[index:n-1])

12 二叉树中和为某一值的路径

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

思路：考虑深度优先遍历，先序遍历按照根、左、右的顺序，遍历所有节点。
定义一个 dfs 函数，主要做如下工作：
路径更新：将当前节点值 root->val 加入路径 path
目标值更新：target - = root-val
路径记录：当 root 为叶节点（无子树）且路径和等于目标值时，将此路径 path 加入 res 中
先序遍历：递归左/右子节点
路径恢复：向上回溯前，需要将当前节点从路径 path 中删除

int** ret;
int retSize;
int* retColSize;
int* path;
int pathSize;

void dfs(struct TreeNode* root, int target) {
    if (root == NULL) {
        return;
    }
    path[pathSize++] = root->val;
    target -= root->val;
    if (root->left == NULL && root->right == NULL && target == 0) {
        int* tmp = malloc(sizeof(int) * pathSize);
        memcpy(tmp, path, sizeof(int) * pathSize);
        ret[retSize] = tmp;
        retColSize[retSize++] = pathSize;
    }
    dfs(root->left, target);
    dfs(root->right, target);
    pathSize--;
}

int** pathSum(struct TreeNode* root, int target, int* returnSize, int** returnColumnSizes) {
    ret = malloc(sizeof(int*) * 2001);
    retColSize = malloc(sizeof(int) * 2001);
    path = malloc(sizeof(int) * 2001);
    retSize = pathSize = 0;
    dfs(root, target);
    *returnColumnSizes = retColSize;
    *returnSize = retSize;
    return ret;
}


class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        res, path = [], []
        def recur(root, tar):
            if not root: return
            path.append(root.val)
            tar -= root.val
            if tar == 0 and not root.left and not root.right:
                res.append(list(path))
            recur(root.left, tar)
            recur(root.right, tar)
            path.pop()

        recur(root, sum)
        return res
Nysun11
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode数据结构之树
qq_43569680的博客
04-07 493
LeetCode数据结构之树 1.树的基本概念 树是一种非线性数据结构。 树结构的基本单位是节点。 节点之间的链接，称为分支（branch）。 节点与分支形成树状，结构的开端，称为根（root），或根结点。 根节点之外的节点，称为子节点（child）。 没有链接到其他子节点的节点，称为叶节点（leaf）。 如下图是一个典型的树结构： 其他重要概念： 树的高度：节点到叶子节点的最大值就是其高度。 树的深度：高度和深度是相反的，高度是从下往上数，深度是从上往下。因此根节点的深度和叶子节点的高度是 0。
leetcode-树
Ritchie_Lin的博客
05-04 394
Tree 模板 问题描述： 解析： 代码实现： 94. 二叉树的中序遍历 问题描述： 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 解析： 代码实现： 递归： class Solution { private: void inOrder(TreeNode* node, vector<int> &iVec) { if (node == nullptr) return; inOrder(n
LeetCode-树
暗焰之珩的博客
03-22 348
写这一系列的笔记，是为了分类整理LeetCode里面的算法题目，以及涉及到的算法的知识点。 树天然就是一种递归结构，所以与树相关的问题，通常都是以下三步：1、明确递归停止的条件(何时return)；2、递归的本质是栈式调用，明确从树的叶子节点到根节点的主要的代码逻辑；3、二叉树分左右两棵子树递归。多叉树for循环递归。在Python中，为了减少参数个数，一般树的递归或者dfs通常会和闭包混合使用...
Leetcode-树
dzysunshine的博客
07-23 216
Leetcode-链表 文章目录Leetcode-链表二叉树的中序遍历（94E）二叉树的层序遍历（102M）二叉树的前序遍历（144E）二叉树的后序遍历（145E） 二叉树的中序遍历（94E） 94. 二叉树的中序遍历 难度：【简单】 方法一：递归 树本身就有递归的特性，因此递归方法最简单，这里直接放上代码，需要说明的是，中序遍历，前序遍历和后序遍历可采用相同的代码模板完成实现。 代码如下： class Solution: def inorderTraversal(self, root: TreeN
Leetcode--树
DXT的博客
08-04 180
236.Lowest Common Ancestor of a Binary Tree Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree. According to thedefinition of LCA on Wikipedia: “The lowest ...
php-leetcode题解之实现前缀树.zip
06-07
这个“php-leetcode题解之实现前缀树.zip”压缩包显然是针对PHP开发者的一个资源，旨在帮助他们理解并解决LeetCode上关于前缀树（也称为 Trie）的题目。 前缀树是一种数据结构，特别适用于存储字符串，它的主要特点...
Tcloser#leetcode-prectice#哈夫曼树1
07-25
① 对于给定的n个权值{W，w2，.. wn}, 构造出具有n棵叉树的森林F={ T, T,, .... T}，其中每棵.1叉树T均只有一个带有权值w的根结点
leetcode思维导图-树
08-13
leetcode思维导图-树
leetcode红黑树-Chitkara-Java:奇卡拉-Java
07-07
leetcode 红黑树奇卡拉-Java 下面是不同 Java Collections 的常用函数的 Big O 性能。 列表 添加 去掉 得到 包含 数据结构 数组列表 O(1) 上） O(1) 上） 大批 链表 O(1) O(1) 上） 上） 链表 放 添加 去掉 包含 ...
php-leetcode题解之实现Trie前缀树.zip
最新发布
06-11
本资源“php_leetcode题解之实现Trie前缀树”聚焦于PHP语言，针对LeetCode中的一道经典问题——Trie（前缀树）的实现进行了解答。 Trie，也被称为字典树或前缀树，是一种用于存储字符串的数据结构，尤其适合进行...
leetCode-树
Tiffany学习的博客
01-03 113
Given a binary tree, find its maximum depth. The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node. 题目： 给定二叉树，找到它的最大深度。 最大深度是从根节点到最远叶节点的...
leetcode: 树
weixin_42376458的博客
02-04 158
文章目录01二叉树的镜像 01二叉树的镜像 请完成一个函数，输入一个二叉树，该函数输出它的镜像。 例如输入： 4 / 2 7 / \ / 1 3 6 9 镜像输出： 4 / 7 2 / \ / 9 6 3 1 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 解题
Leetcode树专题
三笔竹林的博客
02-27 852
树的常识 三种遍历方法 对应的数据结构 Leetcode257.Binary Tree Paths 思路：很典型的深度优先搜索配合栈，宽度优先搜索配合队列。学一个遍历二叉树的方法 Leetcode111. Minimum Depth of Binary Tree（求二叉树的最短深度） 较差的思路：从上题思路套用而来，先求得所有路径的节点数（就是长度），再求最小值 较好的思路：宽度优先搜...
Leetcode 树专题
qq_43557402的博客
06-09 679
写一篇树专题。 树，是一种基本的数据结构，它可以用数组和链表两种方法实现。 一开始学的是二叉树，而二叉树里面有分有很多类型，二叉查找树，AVL树，红黑树…等等（真是怕了红黑树，有太多种情况，虐人… java中的TreeMap的底层就是红黑树，而mysql数据库的索引就是用b+树…（我还没有学数据库，瑟瑟发抖 首先学二叉树的时候会学到遍历方式：前序中序后序遍历，以及层序遍历。 大家可以想象，层序遍历...
leetcode 树总结
李白-2017的博客
12-03 376
下面对leetcode中tree类下面的一些题目进行了总结，其中包括top 100 liked qusetions和top interviewquestions.   1.  二叉树的基本操作 find，insert(递归、非递归方法), create, delete. 删除的节点带有左右孩子，可以用直接前驱(被删除节点最右分支的节点)或是直接后继(被删除节点最左分支的节点)代替被删除节点
leetcode总结——树篇
weixin_45680007的博客
02-17 279
自上而下： 路径和sum 最短路径 镜像树 层次遍历 树化链表 完全二叉树的节点个数： 路径和sum： 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及目标和 sum = 22， 5 / \ 4 8 ...
LeetCode 树
yanyiting666的博客
03-31 129
目录 1.Maximum Depth of Binary Tree 2.Validata Binary Search Tree 3.Symmetric Tree 4.Binary Tree Level Order Tree 5.Covert Sorted Array to Binary Search Tree 1.Maximum Depth of Binary Tree 题目：...
LeetCode——树
qq_43332536的博客
10-26 266
LeetCode二叉树专题
leetcode 线段树
10-03
线段树是一种二叉搜索树，用于处理区间查询的数据结构。它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。线段树是一棵平衡二叉树，最后的子节点数目为N，即为整个线段区间的长度。线段树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值