标签：right TreeNode cur nullptr 代码 随想录 二叉树 root left

#include <iostream>
#include <vector>
#include <stack>
#include <queue>
#include <algorithm>
#include <unordered_map>

using namespace std;

struct TreeNode
{
    int val = 0;
    TreeNode* left = nullptr;
    TreeNode* right = nullptr;
    TreeNode* next = nullptr;
    TreeNode(int val_):val(val_),left(nullptr),right(nullptr),next(nullptr) 
    {
        ;
    }
};

void print(const vector<vector<int>>& nums)
{
    for(auto vs:nums)
    {
        for(auto num : vs)
        {
            cout << num << " ";
        }
        cout << endl;
    }
}

template<typename T>
void print(const vector<T>nums)
{
    for(T num : nums)
    {
        cout << num << " "; 
    }
    cout << endl;
}

void pre(TreeNode* node, vector<int>& vec)
{
    if(nullptr == node)return;
    vec.push_back(node->val);
    pre(node->left,vec);
    pre(node->right,vec);
}

void in(TreeNode* node, vector<int>& vec)
{
    if(nullptr == node)return;    
    in(node->left,vec);
    vec.push_back(node->val);
    in(node->right,vec);
}

void post(TreeNode* node, vector<int>& vec)
{
    if(nullptr == node)return;    
    post(node->left,vec);
    post(node->right,vec);
    vec.push_back(node->val);
}

vector<int>pre(TreeNode* node)
{
    vector<int>res;
    if(nullptr == node)return res;
    stack<TreeNode*>st;
    st.push(node);
    while(!st.empty())
    {
        TreeNode* cur = st.top();
        st.pop();
        res.push_back(cur->val);
        if(cur->right)st.push(cur->right);
        if(cur->left)st.push(cur->left);
    }
    return res;
}

vector<int>in(TreeNode* node)
{
    vector<int>res;
    stack<TreeNode*>st;
    TreeNode* cur = node;
    while(cur != nullptr || !st.empty())
    {
        if(cur != nullptr)
        {
            st.push(cur);
            cur = cur->left;
        }
        else
        {
            cur = st.top();
            st.pop();
            res.push_back(cur->val);
            cur = cur->right;
        }
    }
    return res;

}

vector<int>post(TreeNode* node)
{
    vector<int>res;
    if(nullptr == node)return res;
    stack<TreeNode*>st;
    st.push(node);
    while(!st.empty())
    {
        TreeNode* cur = st.top();
        st.pop();
        res.push_back(cur->val);
        if(cur->left != nullptr)st.push(cur->left);
        if(cur->right != nullptr)st.push(cur->right);
    }
    reverse(res.begin(),res.end());
    return res;    
}

vector<int>visit(TreeNode* node)
{
    vector<int>res;
    pre(node,res);
    // res = pre(node);
    
    // in(node,res);
    // res = in(node);
    
    // post(node,res);
    // res = post(node);
    return res;
}

vector<vector<int>> levelOrder(TreeNode* node)
{
    vector<vector<int>>res;
    if(nullptr == node)return res;
    queue<TreeNode*>q;
    q.push(node);
    while (!q.empty())
    {
        int size = q.size();
        vector<int>v;
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur = q.front();
            q.pop();            
            v.push_back(cur->val);
            if(cur->left != nullptr)q.push(cur->left);
            if(cur->right != nullptr)q.push(cur->right);
        }
        res.push_back(v);
    }
    return res;
    
}

vector<vector<int>>levelOrderII(TreeNode* node)
{
    vector<vector<int>>res;
    if(nullptr == node)return res;
    queue<TreeNode*>q;
    q.push(node);
    while(!q.empty())
    {
        int size = q.size();
        vector<int>v;
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur = q.front();
            q.pop();
            v.push_back(cur->val);
            if(cur->left != nullptr)q.push(cur->left);
            if(cur->right != nullptr)q.push(cur->right);
        }
        res.push_back(v);
    }
    reverse(res.begin(),res.end());
    return res;
}

vector<int>rightSideView(TreeNode* node)
{
    vector<int>res;
    if(nullptr == node)return res;
    queue<TreeNode*>q;
    q.push(node);
    while(!q.empty())
    {
        int size = q.size();
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur = q.front();
            q.pop();
            if(i == size - 1)
            {
                res.push_back(cur->val);
            }
            if(cur->left != nullptr)q.push(cur->left);
            if(cur->right != nullptr)q.push(cur->right);
        }            
    }
    return res;
}

vector<double> averageofLevels(TreeNode* node)
{
    vector<double>res;
    if(nullptr == node)return res;
    queue<TreeNode*>q;
    q.push(node);
    while(!q.empty())
    {
        int size = q.size();
        double sum = 0.;
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur = q.front();
            q.pop();
            sum += cur->val;
            if(cur->left != nullptr)q.push(cur->left);
            if(cur->right != nullptr)q.push(cur->right);
        }        
        res.push_back(sum / size);
    }    
    return res;
}

vector<int>largestVals(TreeNode* node)
{
    vector<int>res;
    if(nullptr == node)
    return res;
    queue<TreeNode*>q;
    q.push(node);
    while(!q.empty())
    {
        int size = q.size();
        int maxVal = INT_MIN;
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur = q.front();
            q.pop();
            maxVal = max(maxVal,cur->val);
            if(cur->left)q.push(cur->left);
            if(cur->right)q.push(cur->right);            
        }
        res.push_back(maxVal);
    }
    return res;
}

TreeNode* connect(TreeNode* node)
{
    if(node == nullptr)return nullptr;
    queue<TreeNode*>q;    
    q.push(node);
    while(!q.empty()){
        TreeNode* cur,*preNode;
        int size = q.size();
        for(int i = 0; i < size; ++i)
        {
            if(0 == i)
            {
                preNode = q.front();
                q.pop();
                cur = preNode;
            }
            else
            {
                cur = q.front();
                q.pop();
                preNode->next = cur;
                preNode = preNode->next;
            }
            if(cur->left != nullptr)q.push(cur->left);
            if(cur->right != nullptr)q.push(cur->right);
        }
        cur->next=nullptr;
    }
    return node;
}

TreeNode* invertTree(TreeNode* node)
{
    if(nullptr == node)return nullptr;
    swap(node->left,node->right);
    invertTree(node->left);
    invertTree(node->right);
    return node;
}

TreeNode* dfs_invertTree(TreeNode* node)
{
    if(nullptr == node)return nullptr;
    stack<TreeNode*>st;
    st.push(node);
    while(!st.empty())
    {
        TreeNode* cur = st.top();
        st.pop();
        swap(cur->left,cur->right);
        if(cur->right != nullptr)st.push(cur->right);
        if(cur->left != nullptr)st.push(cur->left);
    } 
    return node;
}

TreeNode* bfs_invertTree(TreeNode* node)
{
    if(nullptr == node)return nullptr;
    queue<TreeNode*>q;
    q.push(node);
    while (!q.empty())
    {
        int size = q.size();
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur = q.front();
            q.pop();
            swap(cur->left,cur->right);
            if(cur->left != nullptr)q.push(cur->left);
            if(cur->right != nullptr)q.push(cur->right);
        }
    }
    return node;
    
}

bool compare(TreeNode* left, TreeNode* right)
{
    if(nullptr == left && nullptr != right)return false;
    else if(nullptr == right && nullptr != left)return false;
    else if(nullptr == left && nullptr == right)return true;
    else if(left->val != right->val)return false;
    bool outside = compare(left->left,right->right);
    bool inside = compare(left->right,right->left);
    return inside && outside;
    
}

bool isSymmetric(TreeNode* root)
{
    if(root == nullptr)return true;
    return compare(root->left,root->right);
}

bool isSymmetric_queue(TreeNode* root)
{
    if(root == nullptr)return true;
    queue<TreeNode*>q;
    q.push(root->left);
    q.push(root->right);
    while(!q.empty())
    {
        TreeNode* leftNode = q.front();q.pop();
        TreeNode* rightNode = q.front();q.pop();
        if(!leftNode && !rightNode)continue;
        if(!leftNode || !rightNode || (leftNode->val != rightNode->val))
        return false;
        q.push(leftNode->left);
        q.push(rightNode->right);
        q.push(leftNode->right);
        q.push(rightNode->left);
    }
    return true;
}

bool isSymmetric_stack(TreeNode* root)
{
    if(nullptr == root)return true;
    stack<TreeNode*>st;
    st.push(root->left);
    st.push(root->right);
    while(!st.empty())
    {
        TreeNode* leftNode = st.top();st.pop();
        TreeNode* rightNode = st.top();st.pop();
        if(!leftNode && !rightNode)continue;
        if(!leftNode || !rightNode || leftNode->val != rightNode->val)return false;
        st.push(leftNode->left);
        st.push(rightNode->right);
        st.push(leftNode->right);
        st.push(rightNode->left);
    }
    return true;
}

int getDepth(TreeNode* root)
{
    if(nullptr == root)
    return 0;
    int leftDepth = getDepth(root->left);
    int rightDepth = getDepth(root->right);
    return 1 + max(leftDepth,rightDepth);
}

int getDepth_q(TreeNode* root)
{
    if(nullptr == root)return 0;
    queue<TreeNode*>q;
    q.push(root);
    int depth = 0;
    while(!q.empty())
    {
        int size = q.size();
        ++depth;
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur = q.front();
            q.pop();
            if(cur->left != nullptr)q.push(cur->left);
            if(cur->right != nullptr)q.push(cur->right);
        }
        
    }
    return depth;
}

int getMinDepth(TreeNode* root)
{
    if(nullptr == root)return 0;
    int leftDepth = getMinDepth(root->left);
    int rightDepth = getMinDepth(root->right);
    if(root->left == nullptr && root->right!=nullptr)
    {
        return 1 + rightDepth;
    }
    if(root->right == nullptr && root->left != nullptr)
    {
        return 1 + leftDepth;
    }
    return 1 + min(leftDepth,rightDepth);
}

int getMinDepth_q(TreeNode* root)
{
    if(nullptr == root)return 0;
    queue<TreeNode*>q;
    q.push(root);
    int depth = 0;
    while(!q.empty())
    {
        int size = q.size();
        ++depth;
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur = q.front();q.pop();
            if(cur->left != nullptr)q.push(cur->left);
            if(cur->right != nullptr)q.push(cur->right);
            if(cur->left == nullptr && cur->right == nullptr)
            {
                return depth;
            }
        }
    }
    return depth;
}

int getCountNums(TreeNode* root)
{
    if(nullptr == root)return 0;
    int leftNums = getCountNums(root->left);
    int rightNums = getCountNums(root->right);
    return 1 + leftNums + rightNums;
}

int getCountNums_q(TreeNode* root)
{
    if(nullptr == root)return 0;
    queue<TreeNode*>q;
    q.push(root);
    int res = 0;
    while(!q.empty())
    {
        int size = q.size();
        for(int i = 0; i < size; ++i)
        {
            TreeNode* cur  = q.front();q.pop();
            ++res;
            if(cur->left)q.push(cur->left);
            if(cur->right)q.push(cur->right);            
        }
    }
    return res;
}

int getDepth_help(TreeNode* root)
{
    if(nullptr == root)return 0;
    int left = getDepth_help(root->left);
    if(left == -1)return -1;
    int right = getDepth_help(root->right);
    if(right == -1)return -1;
    return abs(left-right) > 1 ? -1 : 1 + max(left,right);
}

bool isBalance(TreeNode* root)
{
    return getDepth_help(root) == -1 ? false : true;
}

void travelsal(TreeNode* node,vector<int>& path,vector<string>& res)
{
    path.push_back(node->val);
    if(node->left==nullptr && node->right==nullptr)
    {
        string sPath = "";
        for(int i = 0; i < path.size() - 1; ++i)
        {
            sPath += to_string(path[i]);
            sPath += "->";
        }
        sPath += to_string(path[path.size() - 1]);
        res.emplace_back(sPath);
        return;
    }
    if(node->left)
    {
        travelsal(node->left,path,res);
        path.pop_back();
    }
    if(node->right)
    {
        travelsal(node->right,path,res);
        path.pop_back();
    }    
}

vector<string>binaryTreePath(TreeNode* root)
{
    vector<string>res;
    vector<int>path;
    travelsal(root,path,res);
    return res;

}

vector<string>binaryTreePaths(TreeNode* root)
{
    vector<string>res;
    if(root == nullptr)return res;
    stack<TreeNode*>st;
    stack<string>paths;
    st.push(root);
    paths.push(to_string(root->val));
    while(!st.empty())
    {
        TreeNode* cur = st.top();st.pop();
        string path = paths.top();paths.pop();
        if(cur->left == nullptr && cur->right == nullptr)res.emplace_back(path);
        if(cur->right)
        {
            st.push(cur->right);
            paths.push(path + "->" +to_string(cur->right->val));
        }
        if(cur->left)
        {
            st.push(cur->left);
            paths.push(path + "->"+to_string(cur->left->val));
        }
    }
    return res;
}

int sumOfLeftLeaves(TreeNode* root)
{
    if(nullptr == root)return 0;
    int leftSum = sumOfLeftLeaves(root->left);
    int rightSum = sumOfLeftLeaves(root->right);
    int midVal = 0;
    if(root->left != nullptr && root->left->left == nullptr && root->left->right == nullptr)
    midVal = root->left->val;
    return midVal + leftSum + rightSum;
}

int sumOfLeftLeaves_st(TreeNode* root)
{
    if(nullptr == root)return 0;
    stack<TreeNode*>st;
    st.push(root);
    int res = 0;
    while(!st.empty())
    {
        TreeNode* cur = st.top();st.pop();
        if(cur->left != nullptr && cur->left->left == nullptr && cur->left->right == nullptr)
        {
            res += cur->left->val;
        }        
        if(cur->right)
        {
            st.push(cur->right);
        }
        if(cur->left)
        {
            st.push(cur->left);            
        }
    }
    return res;
}

int findBottomLeftVal(TreeNode* root)
{
    if(nullptr == root)return 0;
    queue<TreeNode*>q;
    int res = 0;
    q.push(root);
    while (!q.empty())
    {
        int size = q.size();
        for(int i = 0 ; i < size; ++i)
        {
            TreeNode* cur = q.front();q.pop();
            if(0 == i)res = cur->val;
            if(cur->left)q.push(cur->left);
            if(cur->right)q.push(cur->right);
        }
    }
    return res;
    
}

bool traversal(TreeNode* root, int target)
{
    if(root->left == nullptr && root->right == nullptr && target == 0)return true;
    if(root->left == nullptr && root->right == nullptr)return false;
    if(root->left)
    {
        target -= root->left->val;
        if(traversal(root->left,target))return true;
        target += root->left->val;
    }
    if(root->right)
    {
        target -= root->right->val;
        if(traversal(root->right,target))return true;
        target += root->right->val;
    }
    return false;
}

bool hasPathSum(TreeNode* root,int target)
{
    if(nullptr == root)
    return false;
    return traversal(root,target - root->val);
}

bool hasPathSum_st(TreeNode* root, int target)
{
    if(nullptr == root)return false;
    stack<pair<TreeNode*,int>>st;
    st.push({root,root->val});
    while(!st.empty())
    {
        auto node = st.top();st.pop();
        if(!node.first->left && !node.first->right && node.second == target)return true;
        if(node.first->right != nullptr)
        {
            st.push({node.first->right,node.second + node.first->right->val});
        }
        if(node.first->left != nullptr)
        {
            st.push({node.first->left,node.second + node.first->left->val});
        }
    }
    return false;
}

void travelsal(TreeNode* root,vector<int>& path,vector<vector<int>>& res,int target)
{    
    if(root->left == nullptr && root->right == nullptr && target == 0)
    {
        res.push_back(path);        
        return;
    }
    if(root->left == nullptr && root->right == nullptr)
    {
        return ;
    }
    if(root->left)
    {
        path.push_back(root->left->val);
        target -= root->left->val;
        travelsal(root->left,path,res,target);
        target += root->left->val;
        path.pop_back();
    }
    if(root->right)
    {
        path.push_back(root->right->val);
        target -= root->right->val;
        travelsal(root->right,path,res,target);
        target += root->right->val;
        path.pop_back();
    }    
    return ;
}

vector<vector<int>>pathSum(TreeNode* root,int target)
{
    vector<vector<int>>res;
    if(nullptr == root)return res;
    vector<int>path;
    path.push_back(root->val);
    travelsal(root,path,res,target - root->val);        
    return res;
}

TreeNode* build(vector<int>&inorder,vector<int>&postorder)
{
    if(postorder.size() == 0)return nullptr;
    int rootVal = postorder[postorder.size() - 1];
    TreeNode* root = new TreeNode(rootVal);
    if(postorder.size() == 1)return root;
    int index = 0;
    for(; index < inorder.size(); ++index)
    {
        if(inorder[index] == rootVal)
        {
            break;
        }
    }
    vector<int>leftInorder{inorder.begin(),inorder.begin() + index};
    vector<int>rightInorder{inorder.begin() + index + 1,inorder.end()};
    postorder.resize(postorder.size() - 1);
    vector<int>leftPostorder{postorder.begin(),postorder.begin() + leftInorder.size()};
    vector<int>rightPostorder{postorder.begin() + leftInorder.size(),postorder.end()};
    root->left = build(leftInorder,leftPostorder);
    root->right = build(rightInorder,rightPostorder);
    return root;    
}

TreeNode* buildTreeNode(vector<int>&inorder,vector<int>&postorder)
{
    if(inorder.size() == 0 || postorder.size() == 0)return nullptr;
    return build(inorder,postorder);
}

TreeNode* build(vector<int>&preorder,int preBeg,int preEnd,vector<int>&inorder,int inBeg,int inEnd)
{
    if(preBeg == preEnd)return nullptr;
    int rootVal = preorder[preBeg];
    TreeNode* root = new TreeNode(rootVal);
    if(preEnd - preBeg == 1) return root;
    int index = 0;
    for(index = inBeg; index < inEnd; ++ index)
    {
        if(inorder[index] == rootVal)
        {
            break;
        }
    }
    
    int leftInorderBeg = inBeg;
    int leftInorderEnd = index;
    int rightInorderBeg = index + 1;
    int rightInorderEnd = inEnd;

    int leftPreorderBeg = preBeg + 1;
    int leftPreorderEnd = preBeg + 1 + index - inBeg;
    int rightPreorderBeg = preBeg + 1 + index - inBeg;
    int rightPreorderEnd = preEnd;
    root->left = build(preorder,leftPreorderBeg,leftPreorderEnd,inorder,leftInorderBeg,leftInorderEnd);    
    root->right = build(preorder,rightPreorderBeg,rightInorderEnd,inorder,rightInorderBeg,rightInorderEnd);
    return root;
}

TreeNode* buildTreeNodeII(vector<int>&preorder,vector<int>&inorder)
{
    if(preorder.size() == 0 || inorder.size() == 0)
    {
        return nullptr;
    }    
    return build(preorder,0,preorder.size(),inorder,0,inorder.size());
}

TreeNode* constructMaxBinaryTree(const vector<int>& nums)
{
    TreeNode* node = new TreeNode(0);
    if(nums.size() == 1)
    {
        node->val = nums[0];
        return node;
    }
    int maxIndex = 0;
    int maxVal = *max_element(nums.begin(),nums.end());
    for(int i = 0; i < nums.size(); ++i)
    {
        if(nums[i] == maxVal)
        {
            maxIndex = i;
            break;
        }
    }
    node->val = maxVal;
    if(maxIndex > 0)
    {
        vector<int>vecN{nums.begin(),nums.begin() + maxIndex};
        node->left = constructMaxBinaryTree(vecN);
    }
    if(maxIndex < nums.size() - 1)
    {
        vector<int>vecN{nums.begin()+maxIndex+1,nums.end()};
        node->right = constructMaxBinaryTree(vecN);
    }
    return node;
}

TreeNode* mergeTree(TreeNode* t1, TreeNode* t2)
{
    if(nullptr == t1)return t2;
    if(nullptr == t2)return t1;
    t1->val += t2->val;
    t1->left = mergeTree(t1->left,t2->left);
    t1->right = mergeTree(t1->right,t2->right);
    return t1;

}

TreeNode* mergeTree_q(TreeNode* t1, TreeNode* t2)
{
    if(nullptr == t1)return t2;
    if(nullptr == t2)return t1;
    queue<TreeNode*>q;
    q.push(t1);
    q.push(t2);
    while(!q.empty())
    {
        TreeNode* n1 = q.front();q.pop();
        TreeNode* n2 = q.front();q.pop();
        n1->val += n2->val;
        if(n1->left != nullptr && n2->left != nullptr)
        {
            q.push(n1->left);
            q.push(n2->left);
        }
        if(n1->right != nullptr && n2->right != nullptr)
        {
            q.push(n1->right);
            q.push(n2->right);
        }
        if(n1->left == nullptr && n2->left != nullptr)
        {
            n1->left = n2->left;
        }
        if(n1->right == nullptr && n2->right != nullptr)
        {
            n1->right = n2->right;
        }        
    } 
    return t1;
}

TreeNode* searchBST(TreeNode* root, int val)
{
    if(nullptr == root || root->val == val)return root;
    if(root->val > val)return searchBST(root->left,val);
    if(root->val < val)return searchBST(root->right,val);
    return nullptr;        
}

TreeNode* searchBST_iter(TreeNode* root,int val)
{
    while(root!=nullptr)
    {
        if(root->val > val)root = root->left;
        else if(root->val < val) root = root->right;
        else return root;
    }
    return nullptr; 
}

int maxV = INT_MIN;
bool isValidBST(TreeNode* root)
{
    if(nullptr == root)return true;
    bool left = isValidBST(root->left);
    if(maxV < root->val) maxV = root->val;
    bool right = isValidBST(root->right);
    return left && right;
}

bool isValidBST_st(TreeNode* root)
{
    stack<TreeNode*>st;
    TreeNode* pre = nullptr;
    TreeNode* cur = root;
    while(cur != nullptr || !st.empty())
    {
        if(cur != nullptr)
        {
            st.push(cur);
            cur = cur->left;
        }
        else
        {
            cur = st.top();st.pop();
            if(pre != nullptr && pre->val >= cur->val)return false;
            pre = cur;
            cur = cur->right;
        }
    }
    return true;
}

void minTravelsal(TreeNode* node,TreeNode* pre,vector<int>&res)
{
    if(nullptr == node)return;
    minTravelsal(node->left,pre,res);
    if(pre != nullptr)
    {
        res[0] = min(res[0],node->val - pre->val);
    }
    pre = node;
    minTravelsal(node->right,pre,res);

}

int getMinDiff(TreeNode* node)
{
    vector<int>res{INT_MAX};
    minTravelsal(node,nullptr,res);
    return res[0];
}

int getMinDiff_st(TreeNode* node)
{
    if(nullptr == node)return 0;
    stack<TreeNode*>st;
    TreeNode* cur = node;
    TreeNode* pre = nullptr;
    int res = INT_MAX;
    while(cur != nullptr || !st.empty())
    {
        if(cur != nullptr)
        {
            st.push(cur);
            cur = cur->left;
        }
        else
        {
            cur = st.top();st.pop();
            if(pre != nullptr)res = min(res,cur->val - pre->val);
            pre = cur;
            cur = cur->right;
        }
    }
    return res;
}

void travelsal(TreeNode* node, unordered_map<int,int>& map)
{
    if(nullptr == node)return ;
    ++map[node->val];
    travelsal(node->left,map);
    travelsal(node->right,map);

}

vector<int>findMode(TreeNode* node)
{
    vector<int>res;
    if(nullptr == node)return res;
    unordered_map<int,int>map;
    travelsal(node,map);
    vector<pair<int,int>>v{map.begin(),map.end()};
    sort(v.begin(),v.end(),[](const pair<int,int>&a,const pair<int,int>&b){return a.second > b.second;});
    res.push_back(v[0].first);
    for(int i = 1; i < v.size(); ++i)
    {
        if(v[i].second == v[0].second)
        {
            res.push_back(v[i].first);
        }
    }    
    return res;
}

vector<int>findMode_st(TreeNode* node)
{
    stack<TreeNode*>st;
    TreeNode* cur = node;
    TreeNode* pre = nullptr;
    vector<int>res;
    int cnt = 0, maxCnt = INT_MIN;
    while(cur != nullptr || !st.empty())
    {
        if(cur != nullptr)
        {
            st.push(cur);
            cur = cur->left;
        }
        else
        {
            cur = st.top();st.pop();
            if(pre == nullptr)cnt = 1;
            else if(pre->val == cur->val)++cnt;
            else cnt = 1;
            if(cnt == maxCnt)
            {
                res.push_back(cur->val);                
            }
            if(cnt > maxCnt)
            {
                maxCnt = cnt;
                res.clear();
                res.push_back(cur->val);
            }
            pre = cur;
            cur = cur->right;
        }
        
    }
    return res;    
}

TreeNode* lowestCommonTree(TreeNode* node,TreeNode* p, TreeNode* q)
{
    if(node == nullptr || node == p || node == q)return node;
    TreeNode* left = lowestCommonTree(node->left,p,q);
    TreeNode* right = lowestCommonTree(node->right,p,q);
    if(left != nullptr && right != nullptr)return node;
    else if(left != nullptr && right == nullptr)return left;
    else if(left == nullptr && right != nullptr )return right;
    else return nullptr;
}

TreeNode* lowestCommonTreeII(TreeNode* node,TreeNode* p, TreeNode* q)
{
    if(node == nullptr || node == p || node == q)return node;
    if(node->val > p->val && node->val > q->val)
    {
        TreeNode* left = lowestCommonTreeII(node->left,p,q);
        if(left != nullptr)return left;
    }    
    if(node->val < p->val && node->val < q->val)
    {
        TreeNode* right = lowestCommonTreeII(node->right,p,q);
        if(right != nullptr)return right;
    }    
    return node;
}

TreeNode* lowestCommonTreeII_iter(TreeNode* node,TreeNode* p, TreeNode* q)
{
    if(node == nullptr || node == p || node == q)return node;
    while(node)
    {
        if(node->val > p->val && node->val >q->val)
        {
            node = node->left;
        }
        else if(node->val < p->val && node->val < q->val)
        {
            node = node->right;
        }
        else 
        return node;
    }
    return nullptr;    
}

TreeNode* insertIntoBST(TreeNode* root, int val)
{
    if(nullptr == root){
        TreeNode* node = new TreeNode(val);
        return node;
    }
    root->left = insertIntoBST(root->left,val);
    root->right = insertIntoBST(root->right,val);
    return root;
}

TreeNode* insertIntoBST_iter(TreeNode* root,int val)
{
    if(nullptr == root)
    {
        TreeNode* node = new TreeNode(val);
        return node;
    }
    TreeNode* cur = root;
    TreeNode* pre = nullptr;
    while(cur != nullptr)
    {
        pre = cur ;
        if(cur->val > val)cur = cur->left;
        else cur = cur->right;
    }
    TreeNode* node = new TreeNode(val);
    if(val < pre->val)pre->left = node;
    else pre->right = node;
    return root;
}

TreeNode* deleteNode(TreeNode* root, int key)
{
    if(nullptr == root)return root;
    if(root->val == key)
    {
        if(root->left == nullptr) return root->right;
        else if(root->right == nullptr) return root->left;
        else
        {
            TreeNode* cur = root->right;
            while (cur->left != nullptr)            
            {
                cur = cur->left;
            }
            cur->left = root->left;
            TreeNode* tmp = root;
            cur->left = tmp;
            root = root->right;
            delete tmp;
            return root;            
        }
    }
    if(root->val > key)root->left = deleteNode(root->left,key);
    if(root->val < key)root->right = deleteNode(root->right,key);
    return root;
}

TreeNode* deleteOneNode(TreeNode* target)
{
    if(nullptr == target)return target;
    if(target->right == nullptr)return target->left;
    TreeNode* cur = target->right;
    while(cur->left)
    {
        cur = cur->left;
    }
    cur->left = target->left;
    return target->right;
}

TreeNode* deleteNode_iter(TreeNode* root,int key)
{
    if(nullptr == root)return root;
    TreeNode* cur = root;
    TreeNode* pre = nullptr;
    while(cur)
    {
        if(cur->val == key)break;
        pre = cur;
        if(cur->val > key)cur = cur->left;
        else cur = cur->right;
    }
    if(nullptr == pre)
    {
        return deleteOneNode(cur);
    }
    if(pre->left && pre->left->val == key)
    {
        pre->left = deleteOneNode(cur);
    }
    if(pre->right && pre->right->val ==key)
    {
        pre->right = deleteOneNode(cur);
    }
    return root;
}

TreeNode* trimTree(TreeNode* root, int low ,int high)
{
    if(nullptr == root)return nullptr;
    if(root->val < low)
    {
        TreeNode* right = trimTree(root->right,low,high);
        return right;
    }
    
    if(root->val > high)
    {
        TreeNode* left = trimTree(root->left,low,high);
        return left;
    }
    root->left = trimTree(root->left,low,high);
    root->right = trimTree(root->right,low,high);
    return root;
}

TreeNode* trimTreeNode_iter(TreeNode* root,int L ,int H)
{
    if(nullptr == root)return nullptr;
    if(root->val < L || root->val > H)
    {
        if(root->val < L)root = root->right;
        else root = root->left;
    }
    TreeNode* cur = root;
    while(cur != nullptr)
    {
        while(cur->left != nullptr && cur->left->val < L)
        {
            cur->left = cur->left->right;
        }
        cur = cur->left;
    }
    cur = root;
    while(cur != nullptr)
    {
        while(cur->right != nullptr && cur->right->val > H)
        {
            cur->right = cur->right->left;
        }
        cur = cur->right;
    }
    return root;
}

TreeNode* travel(const vector<int>&nums,int left, int right)
{
    if(left > right) return nullptr;
    int mid = left + (right - left) / 2;
    TreeNode* root = new TreeNode(nums[mid]);
    root->left = travel(nums,left,mid - 1);
    root->right = travel(nums,mid + 1,right);
    return root;
}

TreeNode* sortedAtoBST(const vector<int>& nums)
{
    return travel(nums,0,nums.size() - 1);
}

TreeNode* sortedAtoBST_q(const vector<int>& nums)
{
    if(nums.size() == 0)return nullptr;
    TreeNode* root = new TreeNode(0);
    queue<TreeNode*>q;
    queue<int>leftq,rightq;
    q.push(root);
    leftq.push(0);
    rightq.push(nums.size() - 1);
    while(!q.empty())
    {
        TreeNode* cur = q.front();q.pop();
        int left = leftq.front();leftq.pop();
        int right = rightq.front();rightq.pop();
        int mid = left + (right - left) / 2;
        cur->val = nums[mid];
        if(left <= mid - 1)
        {
            cur->left = new TreeNode(0);
            q.push(cur->left);
            leftq.push(left);
            rightq.push(mid - 1);
        }
        if(right >= mid  + 1)
        {
            cur->right = new TreeNode(0);
            q.push(cur->right);
            leftq.push(mid + 1);
            rightq.push(right);
        }
    }
    return root;
}

int preVal = 0;

void transvel(TreeNode* root)
{
    if(nullptr == root)return;
    transvel(root->right);
    root->val += preVal;
    preVal = root->val;
    transvel(root->left);
}

void transvel_st(TreeNode* root)
{
    if(nullptr == root)return;
    stack<TreeNode*>st;
    TreeNode* cur = root;
    while(cur != nullptr || !st.empty())
    {
        if(cur != nullptr)
        {
            st.push(cur);
            cur = cur->right;
        }
        else
        {
            cur = st.top();st.pop();
            cur->val += preVal;
            preVal = cur->val;
            cur = cur->left;
        }
    }
}

TreeNode* convertBST(TreeNode* root)
{
    preVal = 0;
    // transvel(root);
    transvel_st(root);
    return root;
}


int main()
{
    //二叉树的三种遍历
    TreeNode t0(0);
    TreeNode t1(1);
    TreeNode t2(2);
    TreeNode t3(3);
    t0.left = &t1;
    t0.right = &t2;
    t2.right = &t3;
    vector<int>vec;
    print(visit(&t0));
    
    //二叉树的层序遍历
    print(levelOrder(&t0));

    //LeetCode107二叉树的层次遍历II
    print(levelOrderII(&t0));

    //LeetCode199二叉树的右视图
    print(rightSideView(&t0));

    //LeetCode637 二叉树的层平均值
    print<double>(averageofLevels(&t0));

    //LeetCode515 二叉树的层最大值
    print<int>(largestVals(&t0));

    //LeetCode116 填充每一个节点的下一个节点
    print(visit(connect(&t0)));

    //LeetCode117 填充每一个节点的下一个节点II
    //同LeetCode116

    //LeetCode226 翻转二叉树
    print(levelOrder(&t0));
    cout << "====" << endl;    
    print(levelOrder(invertTree(&t0)));
    print(levelOrder(dfs_invertTree(&t0)));
    cout << "====" << endl;    
    print(levelOrder(bfs_invertTree(&t0)));

    //LeetCode101对称二叉树
    TreeNode n0(1);
    TreeNode n1(2);
    TreeNode n2(2);
    TreeNode n3(3);
    TreeNode n4(4);
    TreeNode n5(3);
    TreeNode n6(4);
    n0.left = &n1;
    n0.right = &n2;
    n1.left = &n3;
    n1.right = &n4;
    n2.left = &n6;
    n2.right = &n5;
    print(levelOrder(&n0));
    cout << isSymmetric(&n0) << endl;
    cout << isSymmetric_queue(&n0) << endl;
    cout << isSymmetric_stack(&n0) << endl;

    //LeetCode104 二叉树的最大深度
    cout << getDepth(&n0) << endl;
    cout << getDepth_q(&n0) << endl;

    //LeetCode111 二叉树的最小深度
    cout << getMinDepth(&t0) << endl;
    cout << getMinDepth_q(&t0) << endl;

    //LeetCode222 二叉树的节点个数
    cout << getCountNums(&n0) << endl;
    cout << getCountNums_q(&n0) << endl;

    //LeetCode110 平衡二叉树
    cout << isBalance(&n0) <<endl;

    //LeetCode257 二叉树的所有路径    
    print<string>(binaryTreePath(&t0));
    print<string>(binaryTreePaths(&t0));

    //LeetCode404 左叶子之和
    cout << sumOfLeftLeaves(&t0) << endl;
    cout << sumOfLeftLeaves_st(&t0) << endl;
    
    
    //LeetCode513 树左下角的值    
    cout << findBottomLeftVal(&n0) << endl;

    //LeetCode112 路径总和
    print(levelOrder(&n0));
    cout << hasPathSum(&n0,1) << endl;
    cout << hasPathSum_st(&n0,7) << endl;

    //LeetCode113 路径总和II
    print(pathSum(&n0,6));

    //LeetCode106 从中序与后序遍历序列构造二叉树
    vector<int>inorder{9,3,15,20,7};
    vector<int>postorder{9,15,7,20,3};    
    print(levelOrder(buildTreeNode(inorder,postorder))); 

    //LeetCode105 从前序与中序遍历构造二叉树
    vector<int>preorder{3,9,20,15,7};
    print(levelOrder(buildTreeNodeII(preorder,inorder)));

    //LeetCode654 构造一棵最大的二叉树
    vector<int>nums{3,2,1,6,0,5};    
    print(levelOrder(constructMaxBinaryTree(nums)));

    //LeetCode617 合并二叉树
    TreeNode tr0(1);
    TreeNode tr1(3);
    TreeNode tr2(2);
    TreeNode tr3(5);
    TreeNode tl0(2);
    TreeNode tl1(1);
    TreeNode tl2(3);
    TreeNode tl3(4);
    TreeNode tl4(7);
    tr0.left = &tr1;
    tr0.right = &tr2;
    tr1.left = &tr3;

    tl0.left = &tl1;
    tl0.right = &tl2;
    tl1.right = &tl3;
    tl2.right = &tl4;
    print(levelOrder(&tr0));
    print(levelOrder(&tl0));
    // print(levelOrder(mergeTree(&tr0,&tl0)));
    // print(levelOrder(mergeTree_q(&tr0,&tl0)));

    //LeetCode700 二叉搜索树中的搜索
    print(levelOrder(searchBST(&tl0,3)));
    print(levelOrder(searchBST_iter(&tl0,3)));

    //LeetCode98 验证二叉搜索
 
 
标签：right,TreeNode,cur,nullptr,代码,随想录,二叉树,root,left	

来源： https://www.cnblogs.com/fourmi/p/16284310.html 


本站声明：
1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；

2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；

3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；

4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；

5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。