补稿二——二叉树最后一天

今日内容：

• 669. 修剪二叉搜索树

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

• 538.把二叉搜索树转换为累加树

• 总结篇

本来自己挺忙的拖了一天稿，发现一下子到了day25，要不是群里有消息还以为自己失忆了（狗头）

一、修建二叉树

力扣题目链接

class Solution {
public:
    
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(root==NULL) return root;
        if(root->val<low){
            TreeNode* right= trimBST(root->right,low,high);
            return right;
        }
        if(root->val>high){
            TreeNode* left= trimBST(root->left,low,high);
            return left;
        }
        root->left =trimBST(root->left,low,high);
        root->right =trimBST(root->right,low,high);
        return root;

    }
};

先给了整体代码，先提前看了一遍，

递归三部曲：

1、确定递归函数的参数以及返回值

通过返回值进行修剪（大致思路是将节点加入到递归当中，返回的节点，就是我们需要的符合条件的节点，或者为空节点）

TreeNode* trimBST(TreeNode* root, int low, int high)

2、确定终止条件

修建操作并不是在终止条件下进行，所以遇到空姐点直接返回

if (root == nullptr ) return nullptr;

3、单层递归逻辑

当前节点的值小于左边界，应该去找右边的节点（由于是二叉搜索树），如果大于右边界，应该去找左边的子节点，具体实现方式是像创建一个节点去应该去的方向寻找，并返回节点；

如果符合条件，在区间内，就将下一层的结果给到左子树和右子树，最后返回根节点。

if (root->val < low) {
            TreeNode* right = trimBST(root->right, low, high); // 寻找符合区间[low, high]的节点
            return right;
        }
        if (root->val > high) {
            TreeNode* left = trimBST(root->left, low, high); // 寻找符合区间[low, high]的节点
            return left;
        }
        root->left = trimBST(root->left, low, high); // root->left接入符合条件的左孩子
        root->right = trimBST(root->right, low, high); // root->right接入符合条件的右孩子
        return root;

确实如果单看代码是看不出来是如何移除的节点

迭代：

/**
 * 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:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(!root) return nullptr;

        while(root!=nullptr&&(root->val<low||root->val>high)){
            if(root->val<low) root=root->right;
            if(root->val>high) root=root->left;
        }
        TreeNode* cur =root;
        while(cur!=nullptr){
            while(cur->left&&cur->left->val<low){
                cur->left=cur->left->right;
            }
            cur=cur->left;
        }
        cur=root;
        while(cur!=nullptr){
            while(cur->right&&cur->right->val>high){
                cur->right=cur->right->left;
            }
            cur =cur->right;
        }
        return root;

    }
};

迭代法照着写了一遍，逻辑是看懂了，第一段是如果为空则返回空，第二段是使头节点在区间内，具体方式是，如果在区间左侧则往右子树移动，反之则往左子树移动。在区间中的时候分别处理左孩子元素小于low和右孩子子树大于high的情况方法和递归的逻辑一样。

代码随想录 (programmercarl.com)

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

力扣题目链接 (opens new window)

这题看标题很简单，但描述中要注意的是需要构建的是高度平衡的二叉树，不能以第一个元素为头节点向右排列。

/**
 * 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:
    TreeNode* traversal(vector<int>& nums,int l,int r){
        if(l>r){
            return nullptr;
        }
        int mid =l+((r-l)/2);
        TreeNode* node =new TreeNode(nums[mid]);
        if(mid>=l){
            node->left =traversal(nums,l,mid-1);
        }
        if(mid<=r){
            node->right =traversal(nums,mid+1,r);
        }
        return node;
        
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        
        int l =0;
        int r =nums.size()-1;
        TreeNode* root =traversal(nums,l,r);
        return root;

    }
};

先自己写了一遍，跟题解思路差不多，差了一个终止条件，看来三部曲还是不熟练

三部曲：

1、确定函数返回值及参数，依然是通过返回值来完成构造，然后需要数组和左下标和右下标。

TreeNode* traversal(vector<int>& nums, int left, int right)

2、确定递归的终止条件

if (left > right) return nullptr;

此时，整个数组的元素已全部遍历完毕

3、单层递归逻辑

先取中间元素，再用这个下标切割数组，将两边元素分到左右子树中，左右子树节点也是通过函数确定并连到该节点上。

int mid = left + ((right - left) / 2);
TreeNode* root = new TreeNode(nums[mid]);
root->left = traversal(nums, left, mid - 1);
root->right = traversal(nums, mid + 1, right);
return root;

迭代法：

其逻辑是和递归法是差不多的,只是用队列实现

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.size()==0) return nullptr;
        TreeNode* root =new TreeNode(0);
        queue<TreeNode*> nodeQue;
        queue<int> leftQ;
        queue<int> rightQ;
        nodeQue.push(root);
        leftQ.push(0);
        rightQ.push(nums.size()-1);

        while(!nodeQue.empty()){
            TreeNode* curnode =nodeQue.front();
            nodeQue.pop();
            int left =leftQ.front();leftQ.pop();
            int right =rightQ.front();rightQ.pop();
            int mid =left+((right-left)/2);

            curnode->val =nums[mid];
            if(left<=mid-1){
                curnode->left =new TreeNode(0);
                nodeQue.push(curnode->left);
                leftQ.push(left);
                rightQ.push(mid-1);
            }  
            if(right>=mid+1){
                curnode->right =new TreeNode(0);
                nodeQue.push(curnode->right);
                leftQ.push(mid+1);
                rightQ.push(right);
            }
       }
       return root;

    }
};

3、把二叉搜索树转换为累加树

力扣题目链接 (opens new window)

累加树的顺序是右中左也就是反中序遍历

递归三部曲：

1、递归函数的参数以及返回值

需要一个全局变量记录pre来记录之前的累加值，参数为节点，且不需要有返回值

int pre = 0; // 记录前一个节点的数值
void traversal(TreeNode* cur)

2、确定终止条件，遇到空就停止

if (cur == NULL) return;

3、三层递归逻辑

traversal(cur->right);  // 右
cur->val += pre;        // 中
pre = cur->val;
traversal(cur->left);   // 左

整体：

/**
 * 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 pre =0;
    void traversal(TreeNode* cur){
        if(cur==NULL) return;
        traversal(cur->right);
        cur->val+=pre;
        pre =cur->val;
        traversal(cur->left);
    }
    TreeNode* convertBST(TreeNode* root) {
        pre =0;
        traversal(root);
        return root;

    }
};

迭代法：

class Solution {
public:
int pre =0;
    void traversal(TreeNode* root){
        stack<TreeNode*> st;
        TreeNode* cur =root;
        while(cur!=NULL||!st.empty()){
            if(cur!=NULL){
                st.push(cur);
                cur=cur->right;
            }
            else{
                cur =st.top();
                st.pop();
                cur->val +=pre;
                pre =cur->val;
                cur=cur->left;
            }

        }
    }
    TreeNode* convertBST(TreeNode* root) {
        pre =0;
        traversal(root);
        return root;


    }
};

总结是提醒我要去复习了（乐）