c++逆天改命进阶--二叉树练习题

逃跑的机械工

于 2022-05-19 12:05:11 发布

阅读量285

点赞数 2

分类专栏： c++逆天改命文章标签： c++ leetcode 算法

本文链接：https://blog.csdn.net/btzxlin/article/details/124860552

版权

c++逆天改命专栏收录该内容

18 篇文章 1 订阅

订阅专栏

1.根据二叉树创建字符串

606. 根据二叉树创建字符串 - 力扣（LeetCode）

class Solution {
public:
    void _tree2str(TreeNode* root, string& str)
    {
        if(root==nullptr)//为空直接返回
        {
            return;
        }
        if(root->left&& root->right)//左右子树均不为空 
        {
            str += to_string(root->val);
            str += "(";
            _tree2str(root->left, str);
            str += ")";
            str += "(";
            _tree2str(root->right, str);
            str += ")";
        }
        else if(root->left == nullptr)
        {
            if(root->right)//左子树为空，右子树不空
            {
                str += to_string(root->val);
                str += "()";
                str += "(";
                _tree2str(root->right, str);
                str += ")";
            }
            else//左右子树都空
            {
                str += to_string(root->val);
            }

        }
        else//左子树不为空，右子树为空
        {
            str += to_string(root->val);
            str += "(";
            _tree2str(root->left, str);
            str += ")";
        }



    }
    string tree2str(TreeNode* root) 
    {
        string s;
        _tree2str(root, s);//调用子函数
        return s;
    }
};

2.二叉树的层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> vv;
        queue<TreeNode*> q;
        if(root == nullptr)//空树直接返回
        {
            return vv;
        }
        q.push(root);//不为空 队列q用来存放每一层的节点指针
        int levelSize = 1;//每层的节点个数，最开始肯定是1
        while(!q.empty())//队列不为空就继续
        {
            vector<int> v;
            while(levelSize--)//节点个数是几，v就插入几次
            {
                TreeNode* front = q.front();//先把第一个节点指针保存下来，然后将该节点从队列删除
                v.push_back(front->val);
                q.pop();
                //接下来判断刚刚删除的节点的左右孩子是否为空，不为空就插入到队列
                if(front->left)
                {
                    q.push(front->left);
                }
                if(front->right)
                {
                    q.push(front->right);
                }
            }
            levelSize = q.size();//更新下一层要插入的次数
            vv.push_back(v);
        }
        return vv;
    }
};

3.二叉树的层序遍历（自底向上）

107. 二叉树的层序遍历 II - 力扣（LeetCode）

该题和上题类似，只需要逆置一下vv里面的vector v,我们直接上代码

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> vv;
        queue<TreeNode*> q;
        if(root == nullptr)
        {
            return vv;
        }
        q.push(root);
        int levelSize = 1;
        while(!q.empty())
        {
            vector<int> v;
            while(levelSize--)
            {
                TreeNode* front = q.front();
                v.push_back(front->val);
                q.pop();
                if(front->left)
                {
                    q.push(front->left);
                }
                if(front->right)
                {
                    q.push(front->right);
                }
            }
            levelSize = q.size();
            vv.push_back(v);
        }
        reverse(vv.begin(), vv.end());
        return vv;

    }
};

4.二叉树的最近公共祖先

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

class Solution {
public:
    bool FindNode(TreeNode* root, TreeNode* x, stack<TreeNode*>& st)
    {
        if(root == nullptr)//root为空返回false
        {
            return false;
        }
        st.push(root);//不为空先把当前节点插入栈中，或许这个节点是目标节点的一个祖先，也有可能不是，那就需要我们在后面再将其pop掉
        if(root == x)//找到了返回true
        {
            return true;
        }
        if(FindNode(root->left, x, st))//在左子树找到了返回true
        {
            return true;
        }
        if(FindNode(root->right, x, st))//在右子树找到了返回true
        {
            return true;
        }
        //到这里，说明我们插入的root不是目标节点的祖先，将其pop掉
        st.pop();
        return false;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        stack<TreeNode*> st1, st2;//定义两个栈用于保存查找目标节点过程中所有祖先节点
        //查找目标节点
        FindNode(root, p, st1);  
        FindNode(root, q, st2);
        //此时st1里面都是p的祖先，st2里面都是q的祖先。
        //我们假定st1.size()更大，如果不是这样在将其长短交换
        stack<TreeNode*> longSt = st1;
        stack<TreeNode*> shortSt = st2;
        if(longSt.size()<shortSt.size())
        {
            swap(longSt, shortSt);
        }
        //先让长的栈走差距步
        while(longSt.size()>shortSt.size())
        {
            longSt.pop();
        }
        //此时两个栈一样长，从顶部开始依次比较，直到第一次相等，此时找到了最近的公共祖先
        while(longSt.top() != shortSt.top())
        {
            longSt.pop();
            shortSt.pop();
        }
        return longSt.top();
    }
};

5.二插搜索树与双向链表

二叉搜索树与双向链表_牛客题霸_牛客网 (nowcoder.com)

class Solution {//该题显然是用到了中序遍历
public:
    void InOrder(TreeNode* root, TreeNode*& prev)
    {
        if(root==nullptr)//root为空直接返回
        {
            return;
        }
        InOrder(root->left, prev);//不为空先对左子树遍历
        root->left = prev;//左子树遍历之后，将prev赋给left
        if(prev)//如果prev不为空，说明他是上一次的root，上面的那行代码只解决了前驱指针，而在这里我们解决了上一次的root的后继指针的问题。
        {
            prev->right = root;
        }
        
        prev = root;//更新prev
        InOrder(root->right, prev);//中序遍历右子树
    }
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if(pRootOfTree == nullptr)
        {
            return nullptr;
        }
        TreeNode* prev = nullptr;//前驱指针 初识为空，也就是图上4的left为空
        InOrder(pRootOfTree, prev);//中序遍历
        TreeNode* head = pRootOfTree;//找头，找到最左面的节点
        while(head->left)
        {
            head = head->left;
        }
        return head;
        
    }

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

105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

class Solution {
public:
    TreeNode* _buildTree(vector<int>& preorder, vector<int>& inorder, int& pi, int inbegin, int inend)
    {
        if(inbegin>inend)//说明该树为空直接return
        {
            return nullptr;
        }
        TreeNode* root = new TreeNode(preorder[pi]);//不为空建树 ，通过前序建树，通过中序找区间
        pi++;
        int rooti = inbegin;
        while(rooti<=inend)
        {
            if(root->val == inorder[rooti])//在中序找到值与root->val相等的下标
            {
                break;
            }
            else
            {
                rooti++;
            }
        }
        //[inbegin, rooti-1][rooti][rooti+1, inend]
        root->left = _buildTree(preorder, inorder, pi, inbegin, rooti-1);
        root->right = _buildTree(preorder, inorder, pi, rooti+1, inend);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int i = 0;
        return _buildTree(preorder, inorder, i, 0, inorder.size()-1);
    }
};
//注意pi必须用& 保证全局只有一个pi  否则会出错

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

106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

该题与上题类似，思路大体相同，不同之处在于这道题需要后序来确定根，因为后序是左右根，所以我们从后序的最后一个值开始建树，并且建好根之后先建右子树，再建左子树。

class Solution {
public:
    TreeNode* _buildTree(vector<int>& inorder, vector<int>& postorder, int& pi, int inBegin, int inEnd)
    {
        if(inBegin > inEnd)
        {
            return nullptr;
        }
        TreeNode* root = new TreeNode(postorder[pi]);
        pi--;
        int rooti = inBegin;
        while(rooti <= inEnd)
        {
            if(root->val == inorder[rooti])
            {
                break;
            }
            else
            {
                rooti++;
            }
        }
        //[inBegin,rooti-1][rooti][rooti+1, inEnd]
        
        root->right = _buildTree(inorder, postorder, pi, rooti+1, inEnd);
        root->left = _buildTree(inorder, postorder, pi, inBegin, rooti-1);
        return root;

    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int i = postorder.size()-1;
        return _buildTree(inorder, postorder, i, 0, inorder.size()-1);

    }
};

8.二叉树的前序遍历（非递归）

144. 二叉树的前序遍历 - 力扣（LeetCode）

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
       TreeNode* cur = root;
       stack<TreeNode*> st;
       vector<int> ret;
       while(cur || !st.empty())//循环条件可以先空着我们之后在分析
       {
           while(cur)//先访问左路节点，并将左路节点入栈
           {
               ret.push_back(cur->val);
               st.push(cur);
               cur = cur->left;
           }
           TreeNode* top = st.top();//top取栈顶元素，然后删除栈顶
           st.pop();
           cur = top->right;//此时左路节点已经访问晚了， 去访问他的右子树。cur指向谁，就表示开始前序遍历哪个树
           //现在我们可以控制循环的条件 ：1.cur不为空，说明此时cur指的树的左路节点没有访问完
           //                          2.st不为空，说明左路节点的右子树还没有访问完
       }
       return ret;
    }
};

9.二叉树的中序遍历（非递归）

94. 二叉树的中序遍历 - 力扣（LeetCode）

//该题和上题类似我们直接上代码
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> ret;
        TreeNode* cur = root;
        while(cur || !st.empty())
        {
            while(cur)//cur不为空左路节点入栈
            {
                st.push(cur);
                cur = cur->left;
            }
            TreeNode* top = st.top();//取出栈顶，并pop掉
            st.pop();
            ret.push_back(top->val);
            cur = top->right;//cur指向top节点的右子树
        }
        return ret;
    }
};

10.二叉树的后序遍历（非递归）

145. 二叉树的后序遍历 - 力扣（LeetCode）

//该题也和前面两题类似
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* prev = nullptr;//用来记录上一次插入的节点
        while(cur || !st.empty())
        {
            while(cur)//左路节点入栈
            {
                st.push(cur);
                cur = cur->left;
            }
            TreeNode* top = st.top();//去栈顶元素
            if(top->right == nullptr || top->right == prev)//如果top->right为空或者top->right为上一次插入的节点，就说明可以插入当前值
            {
                st.pop();
                ret.push_back(top->val);
                prev = top;
            }
            else//否则，访问右子树
            {
                cur = top->right;
            }
        }
        return ret;
    }
};

逃跑的机械工

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
c++逆天改命进阶--二叉树练习题

1.根据二叉树创建字符串606. 根据二叉树创建字符串 - 力扣（LeetCode）class Solution {public: void _tree2str(TreeNode* root, string& str) { if(root==nullptr)//为空直接返回 { return; } if(root->left&& root->right)//左右
复制链接

扫一扫