Add files via upload

Author: black-shadows

Trees/Boundary Traversal Of Binary Tree.cpp

@@ -0,0 +1,46 @@
+void inorder(TreeNode *root , vector<int> &ans){
+     
+     if(root==NULL)return ;
+     
+     inorder(root->left,ans);
+     if(root->left==NULL&&root->right==NULL){
+     ans.push_back(root->val);
+     }
+     inorder(root->right,ans);
+ }
+vector<int> Solution::solve(TreeNode* A) {
+    vector<int> ans;
+    TreeNode *root=A;
+    while(root->left!=NULL&&root->right!=NULL){
+        while(root->left!=NULL)
+        {
+            ans.push_back(root->val);
+            root = root->left;
+        }
+        if(root->right!=NULL)
+        {
+            root = root->right;
+            ans.push_back(root->val);
+        }
+    }
+    vector<int>right_bount;
+    root = A;
+     while(root->left!=NULL&&root->right!=NULL){
+        while(root->right!=NULL)
+        {
+                root = root->right;
+                right_bount.push_back(root->val);
+        }
+        if(root->left!=NULL)
+        {
+            root = root->left;
+            right_bount.push_back(root->val);
+        }
+    }
+    root = A;
+    inorder(root,ans);
+    reverse(right_bount.begin(),right_bount.end());
+    
+    ans.insert(ans.end(),right_bount.begin()+1,right_bount.end());
+    return ans;
+}

Trees/Equal Tree Partition.cpp

@@ -0,0 +1,18 @@
+long f(TreeNode* x) {
+     return x?x->val+f(x->left)+f(x->right):0L;
+}
+long g(TreeNode* x, long s, bool& res) {
+    if(!x)return 0;
+    long a = g(x->left, s, res);
+    long b = g(x->right, s, res);
+    if(x->left&&a==s)res=true;
+    if(x->right&&b==s)res=true;
+    return a+x->val+b;
+}
+int Solution::solve(TreeNode* A) {
+    long s = f(A);
+    if(!A||(s&1))return 0;
+    bool res=false;
+    g(A,s/2,res);
+    return res;
+}

Trees/Largest BST Subtree.cpp

@@ -0,0 +1,40 @@
+struct Info {
+    int sz;
+    int mx;
+    int mn;
+    int ans;
+    bool isBST;
+};
+
+Info largestBSTinBinaryTree(TreeNode* root) {
+    if (root == NULL)
+        return {0, INT_MIN, INT_MAX, 0, true};
+
+    if (root->left == NULL && root->right == NULL)
+        return {1, root->val, root->val, 1, true};
+
+    Info l = largestBSTinBinaryTree(root->left);
+    Info r = largestBSTinBinaryTree(root->right);
+
+    Info ret;
+    ret.sz = (1 + l.sz + r.sz);
+
+    if (l.isBST && r.isBST && l.mx < root->val && r.mn > root->val) {
+        ret.mn = min(l.mn, min(r.mn, root->val));
+        ret.mx = max(r.mx, max(l.mx, root->val));
+        ret.ans = ret.sz;
+        ret.isBST = true;
+        return ret;
+    }
+
+    ret.ans = max(l.ans, r.ans);
+    ret.isBST = false;
+    return ret;
+}
+
+ 
+int Solution::solve(TreeNode* A) {
+    Info res=largestBSTinBinaryTree(A);
+    return res.ans;
+}
+

Trees/Longest Consecutive Sequence in Binary Tree.cpp

@@ -0,0 +1,24 @@
+int ans=0;
+
+void dfs(TreeNode *root,int v,int out) {
+    if (!root)
+        return ;
+    if (root->val==v+1)
+        ++out ;
+    else
+        out=1 ;
+    ans=max(ans, out);
+    dfs(root->left,root->val,out);
+    dfs(root->right,root->val,out);
+}
+int longestConsecutive(TreeNode* root) {
+    if (!root)
+        return  0;
+    ans=0;
+    dfs(root,root->val, 0);
+    return ans;
+}
+
+int Solution::solve(TreeNode* A) {
+    return longestConsecutive(A);
+}