第6周数据结构-树

最新推荐文章于 2025-09-25 17:25:28 发布

原创最新推荐文章于 2025-09-25 17:25:28 发布 · 144 阅读

0 ·

CC 4.0 BY-SA版权

leetcode weekly 专栏收录该内容

20 篇文章

订阅专栏

本文介绍了如何非递归地实现二叉树的前序、中序和后序遍历，并探讨了二叉查找树（BST）的相关操作，包括修剪BST、寻找BST的第k个元素、将BST中每个节点值加上比其大的节点值以及求BST的最近公共祖先。这些算法均具有O(n)的时间复杂度和O(n)的空间复杂度，涉及数据结构和算法的重要概念。

文章目录

非递归实现二叉树的前序遍历 144. Binary Tree Preorder Traversal(Easy)
非递归实现二叉树的后序遍历 94. Binary Tree Inorder Traversal(Easy)
非递归实现二叉树的中序遍历145. Binary Tree Postorder Traversal(Easy)
修剪二叉查找树 669. Trim a Binary Search Tree(Medium)
寻找二叉查找树的第 k 个元素 230. Kth Smallest Element in a BST(Medium)
把二叉查找树每个节点的值都加上比它大的节点的值538. Convert BST to Greater Tree (Medium)
二叉查找树的最近公共祖先 \235. Lowest Common Ancestor of a Binary Search Tree(Easy)

前中后序遍历

非递归实现二叉树的前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) { 
        /*
        思路：用栈模拟函数的递归调用，注意栈是先进后出，所以应该先将右子节点压栈再将左子节点压栈
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        stack<TreeNode*> sk;
        vector<int> ans;
        
        if(root == NULL)
            return ans;
        
        sk.push(root);
        
        while(!sk.empty()){
            TreeNode* node = sk.top();
            sk.pop();
            
            ans.push_back(node->val);
            
            if(node->right != NULL)   sk.push(node->right);
            if(node->left != NULL)    sk.push(node->left);
            
        }
        
        return ans;
    }
};

非递归实现二叉树的后序遍历

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        /*
        思路：和后续遍历类似
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        stack<TreeNode*> sk;
        sk.push(root);
        
        vector<int> ans;
        if(root == NULL)
            return ans;
        
        while(!sk.empty()){
            TreeNode* node = sk.top();
            sk.pop();
            
            if(node->left == NULL && node->right == NULL){
                ans.push_back(node->val);
            }
            else{
                if(node->right != NULL){
                    sk.push(node->right);
                    node->right = NULL;
                }
                sk.push(node);
                if(node->left != NULL){
                    sk.push(node->left);
                    node->left = NULL;
                }
            }
        }
        return ans;
    }
};

非递归实现二叉树的中序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        /*
        思路：后续遍历，等左右子树遍历完再遍历根节点，所有一开始不处理根节点，左右子树处理完再处理根节点，为了区分左右子树时候处理完，所有一开始处理根节点时需要做标记，访问了之后就将根节点的子节点指针置为NULL
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        stack <TreeNode*> sk;
        vector<int> ans;
        
        if(root == NULL)
            return ans;
        
        sk.push(root);
        
        while(!sk.empty()){
            TreeNode* node = sk.top();
            // sk.pop();
            
            if(node->left == NULL && node->right == NULL){
                ans.push_back(node->val);
                sk.pop();
            }
            else{
                if(node->right != NULL){
                    sk.push(node->right);
                    node->right = NULL;
                }
                if(node->left != NULL){
                    sk.push(node->left);
                    node->left = NULL;
                }
            }    
        }
        return ans;
        
    }
};

BST

修剪二叉查找树

class Solution {
public:    
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        /*
        思路：先对左右子树进行修剪，再判断根节点是否需要修剪，如果需要则根据左右子树是否为空进行处理，可以推断左右子树不可能同时不为空
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        if(root == NULL)
            return NULL;
        
        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        
        if(root->val >= low && root->val <= high)
            return root;
        
        if(root->left == NULL)
            return root->right;
        else if(root->right == NULL)
            return root->left;
        
        return root;
    }
};

寻找二叉查找树的第 k 个元素

public:
    int count(TreeNode* node){
        if(node == NULL)
            return 0;
        return 1 + count(node->left) + count(node->right);
    }
    int kthSmallest(TreeNode* root, int k) {
        /*
        思路：先得到左子树节点个数，然后根据个数判断第k小的节点在左子树还是右子树
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        int left_num = count(root->left);
        
        if(k == left_num+1)
            return root->val;
        else if(k > left_num+1)
            return kthSmallest(root->right, k-left_num-1);
        else
            return kthSmallest(root->left, k);
        return -1;        
    }
};

把二叉查找树每个节点的值都加上比它大的节点的值

class Solution {
public:
    int sum;
    
    void traverse(TreeNode* node){
        if(node == NULL)
            return ;
        
        traverse(node->right);
        
        node->val += sum;
        sum = node->val;
        
        traverse(node->left);
        
    }
    
    TreeNode* convertBST(TreeNode* root) {
        /*
        思路：在遍历的过程中先遍历右子树，再遍历根，再遍历左子树，这个过程中用一个全局变量sum记录遍历过的节点的值的总和
        思路2（未实现）：中序遍历得到从小到大的序列，用两个vector分别记录节点值和节点指针，通过节点值的vector计算该节点值更新后的值，然后使用节点指针vector修改该节点的值
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        if(root == NULL)
            return root;
        
        sum = 0;
        
        traverse(root);
        
        return root;
        
    }
};

二叉查找树的最近公共祖先

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        /*
        思路：如果根节点的值在[p,q]内，则根节点必为答案，如果根节点的值<p，则答案在根节点的右子树上，如果根节点的值>q，则答案在根节点的左子树上
        */
        if(p->val > q->val)
            swap(p, q);
        
        if(root->val >= p->val && root->val <= q->val)
            return root;
        if(root->val < p->val)
            return lowestCommonAncestor(root->right, p, q);
        if(root->val > q->val)
            return lowestCommonAncestor(root->left, p, q);
        return NULL;
        
    }
};