二叉树专题的复习

最新推荐文章于 2024-08-21 18:16:36 发布

小李小于

最新推荐文章于 2024-08-21 18:16:36 发布

阅读量722

点赞数 2

文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/qq_56350439/article/details/121381933

版权

P148(7):输出树中一条路径最长的长度，并输出路径上各个节点的值：

P147(8)输出二叉树中每个叶子结点到根节点的路径：

平时作业：在二叉链表表示的二叉树中查找值为X的结点并输出他的所有祖先非

确定写递归的步骤

确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

举个例子

1：二叉树的前序后序中序递归遍历

//前序遍历：
class Solution {
public:
    void inorder(TreeNode* root, vector<int>& res) {
        if (!root) {
            return;//函数的终止条件当结点为空终止
        }
        res.push_back(root->val);//单层遍利条件中
        inorder(root->left, res);//左
        inorder(root->right, res);//右
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
};
//中序遍历：
class Solution {
public:
    void inorder(TreeNode* root, vector<int>& res) {
        if (!root) {
            return;//函数的终止条件当结点为空终止
        }
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
};
//后序遍历：
class Solution {
public:
    void inorder(TreeNode* root, vector<int>& res) {
        if (!root) {
            return;//函数的终止条件当结点为空终止
        }
        inorder(root->left, res);
        inorder(root->right, res);
        res.push_back(root->val);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
};

2：求二叉树的最大深度：

class solution {
public:
    int getdepth(treenode* node) {
        if (node == null) return 0;//确定终止条件
        int leftdepth = getdepth(node->left);       // 左//确定单层逻辑
        int rightdepth = getdepth(node->right);     // 右
        int depth = 1 + max(leftdepth, rightdepth); // 中
        return depth;
    }
    int maxdepth(treenode* root) {
        return getdepth(root);
    }
};

3：求二叉树的最小深度

class Solution {
public:
    int getdepth(TreeNode *node)
    {
        if(node==NULL)
        {
            return 0;
        }
        int leftdepth=getdepth(node->left);
        int rightdepth=getdepth(node->right);
        if(node->left==NULL&&node->right!=NULL)
        {
            return 1+rightdepth;
        }
         if(node->left!=NULL&&node->right==NULL)
        {
            return 1+leftdepth;
        }
        int depth=1+min(leftdepth,rightdepth);
        return depth;

    }
    int minDepth(TreeNode* root) {
        return getdepth(root);
        

    }
};

理解的不是很深刻，以后接着再更

更新学校的实验为了阶段考试

7074：

我们学校的题都是给个先序遍历的字符串来创建树；

//瑞格上的题一般都是字符串输入一段二叉树的先序序列
#include<iostream>
using namespace std;
#include<algorithm>
typedef struct  BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//二叉树的结构
BiTree Creat_Tree()
{
    char ch;
    cin>>ch;
    if(ch=='@'){
        return NULL ;//递归判断条件
    }
    BiTree T;
    T=new BiTNode;//单层递归执行的操作
    T->data=ch;
    T->lchild=Creat_Tree();
    T->rchild=Creat_Tree();//先序遍历法先给节点赋值再给他的左节点赋值再给他的有节点赋值
    return T;
}
int Depth_Tree(BiTree T)
{
    if(!T){
        return 0;//递归终止条件
    }
    int left_depth=Depth_Tree(T->lchild);//单层递归的操作
    int right_depth=Depth_Tree(T->rchild);
    return max(left_depth,right_depth)+1;

}
int main()
{
    BiTree T;
    int DEpth;
    T=Creat_Tree();
    cout<<Depth_Tree(T)<<endl;
   // preorder(T);
}

7075：

二叉树后续遍历没啥好说啊，就变下后序中序和先序就变下顺序就行了

//瑞格上的题一般都是字符串输入一段二叉树的先序序列
#include<iostream>
using namespace std;
#include<algorithm>
typedef struct  BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//二叉树的结构
BiTree Creat_Tree()
{
    char ch;
    cin>>ch;
    if(ch=='@'){
        return NULL ;//递归判断条件
    }
    BiTree T;
    T=new BiTNode;//单层递归执行的操作
    T->data=ch;
    T->lchild=Creat_Tree();
    T->rchild=Creat_Tree();//先序遍历法先给节点赋值再给他的左节点赋值再给他的有节点赋值
    return T;
}
void order(BiTree T)
{
    if(!T){
        return ;//递归终止条件
    }
    order(T->lchild);
    order(T->rchild);//单层递归语句
    cout<<T->data;
}
int main()
{
    BiTree T;
    int DEpth;
    T=Creat_Tree();
    order(T);
}

7076：

找二叉树的叶子比较常见的一种题型了

//瑞格上的题一般都是字符串输入一段二叉树的先序序列
#include<iostream>
using namespace std;
#include<algorithm>
typedef struct  BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//二叉树的结构
BiTree Creat_Tree()
{
    char ch;
    cin>>ch;
    if(ch=='@'){
        return NULL ;//递归判断条件
    }
    BiTree T;
    T=new BiTNode;//单层递归执行的操作
    T->data=ch;
    T->lchild=Creat_Tree();
    T->rchild=Creat_Tree();//先序遍历法先给节点赋值再给他的左节点赋值再给他的有节点赋值
    return T;
}
int count_leafs(BiTree T)
{
    if(!T){
        return 0;//递归终止条件
    }
    if(!T->lchild&&!T->rchild){
        return 1;//递归终止条件
    }
    int left_leafs=count_leafs(T->lchild);//单层递归语句找左子树的叶子
    int right_leafs=count_leafs(T->rchild);//再找右子树的叶子
    return left_leafs+right_leafs;
}
int main()
{
    BiTree T;
    int DEpth;
    T=Creat_Tree();
    cout<<count_leafs(T);
}

7077：

借助大神写的讲解明白了点感谢大神代码随想录

层序遍历借助的是BFS 广度优先遍历

借助STL中的队列来实现的：

//瑞格上的题一般都是字符串输入一段二叉树的先序序列
#include<iostream>
using namespace std;
#include<algorithm>
#include<queue>
typedef struct  BiTNode{
    char data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//二叉树的结构
BiTree Creat_Tree()
{
    char ch;
    cin>>ch;
    if(ch=='@'){
        return NULL ;//递归判断条件
    }
    BiTree T;
    T=new BiTNode;//单层递归执行的操作
    T->data=ch;
    T->lchild=Creat_Tree();
    T->rchild=Creat_Tree();//先序遍历法先给节点赋值再给他的左节点赋值再给他的有节点赋值
    return T;
}
void BFStree(BiTree T)//层序遍历可以看作是广度遍历算法
{
    queue<BiTree>Q;//定义一个树指针的队列 
    if(T){
    Q.push(T);//首先压进去树根
    }
    while(!Q.empty()){
        BiTree R;
        R=Q.front();
        cout<<R->data;
        Q.pop();//弹出队头；
        if(R->lchild){
            Q.push(R->lchild);
        }
        if(R->rchild){
            Q.push(R->rchild);
        }
    }
}
int main()
{
    BiTree T;
    int DEpth;
    T=Creat_Tree();
    BFStree(T);
}