🚀 25-Aug-2020

Author: sureshmangs

competitive programming/leetcode/102. Binary Tree Level Order Traversal.cpp

@@ -0,0 +1,59 @@
+Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
+
+For example:
+Given binary tree [3,9,20,null,null,15,7],
+    3
+   / \
+  9  20
+    /  \
+   15   7
+return its level order traversal as:
+[
+  [3],
+  [9,20],
+  [15,7]
+]
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * 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>> levelOrder(TreeNode* root) {
+        vector<vector<int> > res;
+        if(!root) return res;
+        queue<TreeNode*> q;
+        q.push(root);
+        while(!q.empty()){
+            int size=q.size();
+            vector<int> tmp;
+            while(size--){
+                TreeNode* curr=q.front();
+                q.pop();
+                tmp.push_back(curr->val);
+                if(curr->left) q.push(curr->left);
+                if(curr->right) q.push(curr->right);
+            }
+            res.push_back(tmp);
+        }
+        return res;
+    }
+};

competitive programming/leetcode/104. Maximum Depth of Binary Tree.cpp

@@ -0,0 +1,42 @@
+Given a binary tree, find its maximum depth.
+
+The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+Note: A leaf is a node with no children.
+
+Example:
+
+Given binary tree [3,9,20,null,null,15,7],
+
+    3
+   / \
+  9  20
+    /  \
+   15   7
+return its depth = 3.
+
+
+
+
+
+
+
+
+/**
+ * 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(TreeNode* root) {
+        if(!root) return 0;
+        return 1 + max(maxDepth(root->left), maxDepth(root->right)) ;
+    }
+};

competitive programming/leetcode/2020-August-Challenge/Day-07-Vertical Order Traversal of a Binary Tree.cpp

@@ -0,0 +1,104 @@
+Given a binary tree, return the vertical order traversal of its nodes values.
+
+For each node at position (X, Y), its left and right children respectively will be at positions (X-1, Y-1) and (X+1, Y-1).
+
+Running a vertical line from X = -infinity to X = +infinity, whenever the vertical line touches some nodes, we report the values of the nodes in order from top to bottom (decreasing Y coordinates).
+
+If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.
+
+Return an list of non-empty reports in order of X coordinate.  Every report will have a list of values of nodes.
+
+
+
+Example 1:
+
+
+
+Input: [3,9,20,null,null,15,7]
+Output: [[9],[3,15],[20],[7]]
+Explanation:
+Without loss of generality, we can assume the root node is at position (0, 0):
+Then, the node with value 9 occurs at position (-1, -1);
+The nodes with values 3 and 15 occur at positions (0, 0) and (0, -2);
+The node with value 20 occurs at position (1, -1);
+The node with value 7 occurs at position (2, -2).
+Example 2:
+
+
+
+Input: [1,2,3,4,5,6,7]
+Output: [[4],[2],[1,5,6],[3],[7]]
+Explanation:
+The node with value 5 and the node with value 6 have the same position according to the given scheme.
+However, in the report "[1,5,6]", the node value of 5 comes first since 5 is smaller than 6.
+
+
+Note:
+
+The tree will have between 1 and 1000 nodes.
+Each node's value will be between 0 and 1000.
+
+
+
+
+
+
+/**
+ * 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) {}
+ * };
+ */
+
+struct nodes {
+    int x, y, val;
+};
+
+class Solution {
+public:
+
+    vector<nodes> coords;
+
+    static bool comp(nodes a, nodes b){
+        if(a.x < b.x) return true;
+        else if(a.x > b.x) return false;
+        else if(a.y > b.y) return true;
+        else if(a.y < b.y)return false;
+        else return a.val < b.val;
+    }
+
+    void traversal(TreeNode* root, int x, int y){
+        if(!root) return;
+        coords.push_back({x, y, root->val});
+        traversal(root->left, x-1, y-1);
+        traversal(root->right, x+1, y-1);
+
+    }
+
+    vector<vector<int>> verticalTraversal(TreeNode* root) {
+        vector<vector<int>> res;
+
+        traversal(root, 0, 0);  // <root, x coordinate, y coordinate>
+
+        sort(coords.begin(), coords.end(), comp);
+
+        int n=coords.size(), i=0;
+        while(i<n){
+            vector<int> tmp;
+            do {
+                tmp.push_back(coords[i].val);
+                i++;
+            }while(i<n && coords[i].x==coords[i-1].x);
+            res.push_back(tmp);
+        }
+
+
+        return res;
+
+    }
+};

competitive programming/leetcode/543. Diameter of Binary Tree.cpp

@@ -0,0 +1,56 @@
+Given a binary tree, you need to compute the length of the diameter of the tree. The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.
+
+Example:
+Given a binary tree
+          1
+         / \
+        2   3
+       / \
+      4   5
+Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
+
+Note: The length of path between two nodes is represented by the number of edges between them.
+
+
+
+
+
+
+
+
+
+
+/**
+ * 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 getDiameter(TreeNode* root, int &res){
+        if(!root) return 0;
+
+        int l=getDiameter(root->left, res);
+        int r=getDiameter(root->right, res);
+
+        int tmp=max(l,r)+1;
+        int ans=max(tmp, l+r+1);
+        res=max(res, ans);
+
+        return tmp;
+    }
+
+    int diameterOfBinaryTree(TreeNode* root) {
+        if(!root) return 0;
+        int res=INT_MIN;
+        getDiameter(root, res);
+        return res-1;
+    }
+};

competitive programming/leetcode/987. Vertical Order Traversal of a Binary Tree.cpp

@@ -0,0 +1,104 @@
+Given a binary tree, return the vertical order traversal of its nodes values.
+
+For each node at position (X, Y), its left and right children respectively will be at positions (X-1, Y-1) and (X+1, Y-1).
+
+Running a vertical line from X = -infinity to X = +infinity, whenever the vertical line touches some nodes, we report the values of the nodes in order from top to bottom (decreasing Y coordinates).
+
+If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.
+
+Return an list of non-empty reports in order of X coordinate.  Every report will have a list of values of nodes.
+
+
+
+Example 1:
+
+
+
+Input: [3,9,20,null,null,15,7]
+Output: [[9],[3,15],[20],[7]]
+Explanation:
+Without loss of generality, we can assume the root node is at position (0, 0):
+Then, the node with value 9 occurs at position (-1, -1);
+The nodes with values 3 and 15 occur at positions (0, 0) and (0, -2);
+The node with value 20 occurs at position (1, -1);
+The node with value 7 occurs at position (2, -2).
+Example 2:
+
+
+
+Input: [1,2,3,4,5,6,7]
+Output: [[4],[2],[1,5,6],[3],[7]]
+Explanation:
+The node with value 5 and the node with value 6 have the same position according to the given scheme.
+However, in the report "[1,5,6]", the node value of 5 comes first since 5 is smaller than 6.
+
+
+Note:
+
+The tree will have between 1 and 1000 nodes.
+Each node's value will be between 0 and 1000.
+
+
+
+
+
+
+/**
+ * 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) {}
+ * };
+ */
+
+struct nodes {
+    int x, y, val;
+};
+
+class Solution {
+public:
+
+    vector<nodes> coords;
+
+    static bool comp(nodes a, nodes b){
+        if(a.x < b.x) return true;
+        else if(a.x > b.x) return false;
+        else if(a.y > b.y) return true;
+        else if(a.y < b.y)return false;
+        else return a.val < b.val;
+    }
+
+    void traversal(TreeNode* root, int x, int y){
+        if(!root) return;
+        coords.push_back({x, y, root->val});
+        traversal(root->left, x-1, y-1);
+        traversal(root->right, x+1, y-1);
+
+    }
+
+    vector<vector<int>> verticalTraversal(TreeNode* root) {
+        vector<vector<int>> res;
+
+        traversal(root, 0, 0);  // <root, x coordinate, y coordinate>
+
+        sort(coords.begin(), coords.end(), comp);
+
+        int n=coords.size(), i=0;
+        while(i<n){
+            vector<int> tmp;
+            do {
+                tmp.push_back(coords[i].val);
+                i++;
+            }while(i<n && coords[i].x==coords[i-1].x);
+            res.push_back(tmp);
+        }
+
+
+        return res;
+
+    }
+};