【LeetCode-简单】二叉树笔记（C++）

二叉树笔记（C++）

二叉树笔记（C++）

1 普通二叉树

递归，每到一个新的节点就进行相应的处理。

每到一个新的节点，交换它的左右孩子的指向，之后继续递归。

class Solution {
public:
    void traversal(TreeNode *root) {
        if (root != NULL) {
            TreeNode *temp = root->right;
            root->right = root->left;
            root->left = temp;
            traversal(root->left);
            traversal(root->right);
        }
    }
    TreeNode* mirrorTree(TreeNode* root) {
        traversal(root);
        return root;
    }
};

剑指 Offer 55 - I. 二叉树的深度

求最大深度

class Solution {
public:
    int max;
    void traversal(TreeNode *root, int depth) {
        if (root != NULL) {
            if (max < depth) {
                max = depth;
            }
            traversal(root->left, depth + 1);
            traversal(root->right, depth + 1);
        }
    }

    int maxDepth(TreeNode* root) {
        traversal(root, 1);

        return max;
    }
};

617. 合并二叉树

每递归到一个节点，如果 root1 或 root2 存在，就先创建新节点 root3。

之后根据每个节点的情况，给 root3->val 赋值，并对其左孩子和右孩子进行递归。

class Solution {
public:
    TreeNode *traversal(TreeNode *root1, TreeNode *root2) {
        if (root1 == nullptr && root2 == nullptr) {
            return nullptr;
        }

        TreeNode *root3 = new TreeNode();

        if (root1 == nullptr) {
            root3->val = root2->val;
            root3->left = traversal(nullptr, root2->left);
            root3->right = traversal(nullptr, root2->right);
        } else if (root2 == nullptr) {
            root3->val = root1->val;
            root3->left = traversal(root1->left, nullptr);
            root3->right = traversal(root1->right, nullptr);
        } else {
            root3->val = root1->val + root2->val;
            root3->left = traversal(root1->left, root2->left);
            root3->right = traversal(root1->right, root2->right);
        }

        return root3;
    }
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        TreeNode *root3 = traversal(root1, root2);
        return root3;
    }
};

面试题 04.02. 最小高度树

利用有序的数组构建最小高度树。二分，递归。

class Solution {
public:
    TreeNode *buildTree(vector<int> &ans, int low, int high) {
        if (low > high) {
            return NULL;
        }
        int mid = (low + high) / 2;
        TreeNode *node = new TreeNode(ans[mid]);
        node->left = buildTree(ans, low, mid - 1);
        node->right = buildTree(ans, mid + 1, high);

        return node;
    }

    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode *root = buildTree(nums, 0, nums.size() - 1);

        return root;
    }
};

2 二叉搜索树

特点：当前节点的值比左子树大，比右子树小。

剑指 Offer 54. 二叉搜索树的第k大节点

700. 二叉搜索树中的搜索

二叉搜索树的中序遍历序列是一个升序序列。

通过中序遍历，用 inOrder 数组来保存中序结果的序列。

前一题要求返回数值，后一题要求返回节点。

// 剑指 Offer 54. 二叉搜索树的第k大节点
class Solution {
public:
    void traversal(TreeNode *root, vector<int> &inOrder) {
        if (root != NULL) {
            traversal(root->left, inOrder);
            inOrder.push_back(root->val);
            traversal(root->right, inOrder);
        }
    }
    int kthLargest(TreeNode* root, int k) {
        vector<int> inOrder;
        traversal(root, inOrder);

        return inOrder[inOrder.size() - k];
    }
};

// 700. 二叉搜索树中的搜索
class Solution {
public:
    TreeNode *search(TreeNode *root, int val) {
        if (root != nullptr) {
            if (root->val > val) {
                return search(root->left, val);
            } else if (root->val < val) {
                return search(root->right, val);
            } else { // root->val == val
                return root;
            }
        }
        return nullptr;
    }
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode *res = search(root, val);

        return res;
    }
};

108. 将有序数组转换为二叉搜索树

序列已经给定，使用二分法建树。

class Solution {
public:
    TreeNode *traversal(vector<int> &nums, int low, int high) {
        if (low <= high) {
            int mid = (low + high) / 2;
            TreeNode *node = new TreeNode(nums[mid]);
            node->left = traversal(nums, low, mid - 1);
            node->right = traversal(nums, mid + 1, high);
            return node;
        }
        return nullptr;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode *root = traversal(nums, 0, nums.size() - 1);

        return root;
    }
};

938. 二叉搜索树的范围和

每遍历到一个节点，判断它的值是否在规定的范围（[low, high]）内，
如果是，则范围递归左右子树节点之和；
如果 < low，则对当前节点的右子树进行递归；
如果 > high，则对当前节点的左子树进行递归。

class Solution {
public:
    int rangeSumBST(TreeNode* root, int low, int high) {
        if (root == nullptr) {
            return 0;
        }
        
        if (root->val >= low && root->val <= high) {
            return root->val + rangeSumBST(root->left, low, high) + rangeSumBST(root->right, low, high);
        } else if (root->val > high) {
            return rangeSumBST(root->left, low, high);
        } else { // root->val < low
            return rangeSumBST(root->right, low, high);
        }
    }
};

3 N 叉树（普通树）

N 叉树的每一个节点的子节点数目不确定。

N 叉树的遍历

N 叉树的前序遍历对应于二叉树的前序遍历：先根节点，后子节点。

后序遍历对应于二叉树的后序遍历：先子节点，后根节点。

题目链接：

589. N 叉树的前序遍历

590. N 叉树的后序遍历

前序遍历

class Solution {
public:
    void postOrderTraversal(Node *root, vector<int> &ans) {
        if (root != nullptr) {
            int size = root->children.size();
            for (int i = 0; i < size; i++) {
                postOrderTraversal(root->children[i], ans);
            }
            ans.push_back(root->val);
        } 
    }
    vector<int> postorder(Node* root) {
        vector<int> ans;
        postOrderTraversal(root, ans);

        return ans;
    }
};

后序遍历

class Solution {
public:
    void postOrderTraversal(Node *root, vector<int> &ans) {
        if (root != nullptr) {
            int size = root->children.size();
            for (int i = 0; i < size; i++) {
                postOrderTraversal(root->children[i], ans);
            }
            ans.push_back(root->val);
        } 
    }
    vector<int> postorder(Node* root) {
        vector<int> ans;
        postOrderTraversal(root, ans);

        return ans;
    }
};

posted @ 2022-03-29 13:31 JKL27 阅读(65) 评论(0) 收藏举报

刷新页面返回顶部

JKL27

【LeetCode-简单】二叉树笔记（C++）

二叉树笔记（C++）

1 普通二叉树

2 二叉搜索树

3 N 叉树（普通树）

公告