「程式碼隨想錄演算法訓練營」第十四天 | 二叉樹 part4

云雀AC了一整天發表於2024-07-18
演算法二叉樹

513. 找樹左下角的值

題目連結：https://leetcode.cn/problems/find-bottom-left-tree-value/
題目難度：中等
文章講解：https://programmercarl.com/0513.找樹左下角的值.html
影片講解：https://www.bilibili.com/video/BV1424y1Z7pn
題目狀態：有點思路，但未透過，最後在ChatGPT的幫助下理清了思路，順利透過

思路：

使用層序遍歷的思想，每次遍歷到一層時，記錄這一層的第一個節點的值，當遍歷完整個樹之後，記錄的就是最後一層的第一個節點的值。

程式碼實現：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode *> que;
        if(root == nullptr) return 0;
        int res = root->val;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; ++i) {
                TreeNode *node = que.front();
                que.pop();
                if(i == 0) res = node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};

遞迴法：遞迴到每一層時，判斷該層是否為最底層，若是，則記錄其層第一個節點的值

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth = INT_MIN;
    int res;
    void traversal(TreeNode *cur, int depth) {
        if(cur->left == nullptr && cur->right == nullptr) {
            if(depth > maxDepth) {
                maxDepth = depth;
                res = cur->val;
            }
            return;
        }
        if(cur->left) {
            depth++;
            traversal(cur->left, depth);
            depth--;
        }
        if(cur->right) {
            depth++;
            traversal(cur->right, depth);
            depth--;
        }
        return;
    }

    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return res;
    }
};

112. 路徑總和

題目連結：https://leetcode.cn/problems/path-sum/
題目難度：簡單
文章講解：https://programmercarl.com/0112.路徑總和.html
影片講解：https://www.bilibili.com/video/BV19t4y1L7CR
題目狀態：沒思路，回溯+遞迴靠自己還是想不起來

思路：

使用遞迴+回溯的方法。

  1. 遞迴引數和返回值：引數是二叉樹節點cur和目標target，目標用來進行--的，每遍歷到一個節點時，用target減去其值，若到葉子節點時，target的值為 0，表示找到了這條路徑是target的總和，返回值是bool。
  2. 終止條件：當該節點為葉子節點且當前target為 0 時，返回true，表示找到了這個路徑；若該節點為葉子節點但target值不為 0，表示沒找到，返回false。
  3. 單個迴圈思路：當遍歷到該節點是，將target減去其值，若其有左孩子，target減去左孩子值，並遞迴到左孩子，其左孩子將會向下遍歷，若找到了一個路徑，將返回true給它的父節點，依次向上迴圈，直到結束遞迴；右孩子的遞迴是和左孩子一樣的。

程式碼實現：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool traversal(TreeNode *cur, int target) {
        if(cur->left == nullptr && cur->right == nullptr && target == 0) return true;
        if(cur->left == nullptr && cur->right == nullptr && target != 0) return false;
        if(cur->left) {
            target -= cur->left->val;
            if(traversal(cur->left, target)) return true;
            target += cur->left->val;
        }
        if(cur->right) {
            target -= cur->right->val;
            if(traversal(cur->right, target)) return true;
            target += cur->right->val;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return false;
        return traversal(root, targetSum - root->val);
    }
};

113. 路徑總和II

題目連結：https://leetcode.cn/problems/path-sum-ii/
題目難度：中等
文章講解：https://programmercarl.com/0112.路徑總和.html#相關題目推薦
題目狀態：誒，還是沒寫出來

思路：

和上題一樣，使用遞迴+回溯，但是自己想還是想不起來，在遞迴中將路徑記錄下來，最後判定終止條件時將路徑壓入到結果中。

程式碼實現：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void traversal(TreeNode *cur, int count) {
        if(!cur->left && !cur->right && count == 0) {
            result.push_back(path);
            return;
        }
        if(!cur->left && !cur->right && count != 0) return;
        if(cur->left) {
            count -= cur->left->val;
            path.push_back(cur->left->val);
            traversal(cur->left, count);
            count += cur->left->val;
            path.pop_back();
        }
        if(cur->right) {
            count -= cur->right->val;
            path.push_back(cur->right->val);
            traversal(cur->right, count);
            count += cur->right->val;
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        result.clear();
        path.clear();
        if(root == nullptr) return result;
        path.push_back(root->val);
        traversal(root, targetSum - root->val);
        return result;
    }
};

106. 從中序與後序遍歷序列構造二叉樹

題目連結：https://leetcode.cn/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
題目難度：中等
文章講解：https://programmercarl.com/0106.從中序與後序遍歷序列構造二叉樹.html
影片講解：https://www.bilibili.com/video/BV1vW4y1i7dn
題目狀態：太難了，沒有思路

思路：

遞迴：

  1. 如果陣列大小為零的話，說明是空節點了。
  2. 如果不為空，那麼取後序陣列最後一個元素作為節點元素。
  3. 找到後序陣列最後一個元素在中序陣列的位置，作為切割點。
  4. 切割中序陣列，切成中序左陣列和中序右陣列（順序別搞反了，一定是先切中序陣列）。
  5. 切割後序陣列，切成後序左陣列和後序右陣列。
  6. 遞迴處理左區間和右區間。

程式碼實現：

class Solution {
private:
    TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) return NULL;

        // 後序遍歷陣列最後一個元素，就是當前的中間節點
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        // 葉子節點
        if (postorder.size() == 1) return root;

        // 找到中序遍歷的切割點
        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

        // 切割中序陣列
        // 左閉右開區間：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        // [delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());

        // postorder 捨棄末尾元素
        postorder.resize(postorder.size() - 1);

        // 切割後序陣列
        // 依然左閉右開，注意這裡使用了左中序陣列大小作為切割點
        // [0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};

105. 從前序與中序遍歷序列構造二叉樹

題目連結：https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
題目難度：中等
文章講解：https://programmercarl.com/0106.從中序與後序遍歷序列構造二叉樹.html#相關題目推薦
題目狀態：獨立搓不出來

思路：

和上一題大同小異。

程式碼實現：

class Solution {
private:
        TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& preorder, int preorderBegin, int preorderEnd) {
        if (preorderBegin == preorderEnd) return NULL;

        int rootValue = preorder[preorderBegin]; // 注意用preorderBegin 不要用0
        TreeNode* root = new TreeNode(rootValue);

        if (preorderEnd - preorderBegin == 1) return root;

        int delimiterIndex;
        for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }
        // 切割中序陣列
        // 中序左區間，左閉右開[leftInorderBegin, leftInorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        // 中序右區間，左閉右開[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        // 切割前序陣列
        // 前序左區間，左閉右開[leftPreorderBegin, leftPreorderEnd)
        int leftPreorderBegin =  preorderBegin + 1;
        int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin; // 終止位置是起始位置加上中序左區間的大小size
        // 前序右區間, 左閉右開[rightPreorderBegin, rightPreorderEnd)
        int rightPreorderBegin = preorderBegin + 1 + (delimiterIndex - inorderBegin);
        int rightPreorderEnd = preorderEnd;

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  preorder, leftPreorderBegin, leftPreorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, preorder, rightPreorderBegin, rightPreorderEnd);

        return root;
    }

public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (inorder.size() == 0 || preorder.size() == 0) return NULL;

        // 引數堅持左閉右開的原則
        return traversal(inorder, 0, inorder.size(), preorder, 0, preorder.size());
    }
};

相關文章