二叉树探索篇

ch_ah

已于 2024-08-05 16:28:15 修改

阅读量1k

点赞数 27

文章标签：算法数据结构 c++ b树 visual studio

于 2024-08-04 16:11:24 首次发布

本文链接：https://blog.csdn.net/ch_ah/article/details/140886469

版权

leetcode199——二叉树的右视图

题目描述：

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

算法思想：

题目所求可转化成求每一层最右边节点是啥？可利用层序遍历的方法，每次操作将队列的队尾加入要返回的数组中，即为所求。

算法实现：

   vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        queue<TreeNode*> q;
        if(root==NULL) return res;
        TreeNode* node;
        q.push(root);
        while(!q.empty()){
            res.push_back(q.back()->val);
            int size=q.size();
            for(int i=0;i<size;i++){
                node=q.front();
                q.pop();
                if(node->left!=NULL) q.push(node->left);
                if(node->right!=NULL) q.push(node->right);
            }
        }
        return res;
    }

Leetcode117——填充每个字节的下一个右侧结点指针Ⅱ

题目描述：

给定一个二叉树：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

初始状态下，所有 next 指针都被设置为 NULL 。

示例 1：

输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。

示例 2：

输入：root = []
输出：[]

算法思想：

依然是利用层序遍历的思想，将每层的节点加入队列中，在遍历时除了最后一个节点都将当前节点的next指针赋给当前节点的后面一个节点（队列中）。

算法实现：

Node* connect(Node* root) {
        queue<Node*> q;
        if(root==NULL) return root;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                Node* node=q.front();
                q.pop();
                if(i!=size-1)node->next=q.front();
                if(node->left!=NULL) q.push(node->left);
                if(node->right!=NULL) q.push(node->right);
            }
        }
        return root;
    }

Leetcode104——二叉树的最大深度

题目描述：

给定一个二叉树 root ，返回其最大深度。

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

示例 1：

输入：root = [3,9,20,null,null,15,7] 输出：3

示例 2：

输入：root = [1,null,2]
输出：2

算法思想：

利用层序遍历，每遍历一层，树的深度+1。

算法实现：

int maxDepth(TreeNode* root) {
        if(root==NULL) return 0;
        queue<TreeNode*> q;
        q.push(root);
        int depth=0;
        while(!q.empty()){
            depth++;
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
        }
        return depth;
    }

Leetcode111——二叉树的最小深度

题目描述：

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

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

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

算法思想：

利用层序遍历的思想再找到第一个叶子节点时直接返回其树的最小深度。

算法实现：

int minDepth(TreeNode* root) {
        if(root==NULL) return 0;
        queue<TreeNode*> q;
        q.push(root);
        int depth=0;
        while(!q.empty()){
            depth++;
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
                if(node->left==NULL && node->right==NULL) return depth;
            }
        }
        return depth;
    }

Leetcode226——翻转二叉树

题目描述：

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

算法思想：

可利用先序遍历每遍历一个非根节点时，交换其左右子树。也可通过层序遍历，在将当前出队的节点的左右孩子节点入队后，再交换其左右孩子节点。

算法实现：

TreeNode* invertTree(TreeNode* root) {
        /*先序遍历
        if(root==NULL) return root;
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
        */
        //层序遍历
        if(root==NULL) return root;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode* node=q.front();
                q.pop();
                if(node->left){
                    q.push(node->left);
                }
                if(node->right){
                    q.push(node->right);
                }
                swap(node->left,node->right);
            }
        }
        return root;
    }

Leetcode572——另一棵树的子树

题目描述：

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

示例 1：

输入：root = [3,4,5,1,2], subRoot = [4,1,2]
输出：true

示例 2：

输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
输出：false

算法思想：

利用先序遍历的思想，当当前遍历的节点与子树的根节点值相同时检查以该节点为根节点的子树与参照子树是否为相同树，是返回true，不是继续遍历其他节点直至遍历完所有节点。

//判断是否为相同树
bool sametree(TreeNode* p,TreeNode* q){
        if(p==NULL && q==NULL){
            return true;
        }else if(p==NULL || q==NULL){
            return false;
        }else if(p->val!=q->val){
            return false;
        }
        return sametree(p->left,q->left)&&sametree(p->right,q->right);
    }
//判断是否为子树
bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        if(subRoot==NULL) return true;
        else if(root==NULL) return false;
        bool res=false;
        if(root->val==subRoot->val) res=res||sametree(root,subRoot);
        res=res || isSubtree(root->left,subRoot);
        res=res || isSubtree(root->right,subRoot);
        return res;
}