LCA

Author: sam41290

binarytree_levelorder_traversal.cpp

@@ -0,0 +1,67 @@
+/*
+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(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> ret;
+        if(root==NULL)
+            return ret;
+        vector<TreeNode *> fringe;
+        int fringe_pos = 0;
+        int next_itr = 1;
+        fringe.push_back(root);
+
+        while(next_itr != 0)
+        {
+            vector<int> tmp;
+            
+            int i = next_itr;
+            next_itr = 0;
+            TreeNode *cur;
+            for(int j=0;j<i;j++)
+            {
+                cur=fringe[fringe_pos];
+                tmp.push_back(cur->val);
+                if(cur->left!=NULL)
+                {
+                    fringe.push_back(cur->left);
+                    next_itr++;
+                }
+                if(cur->right!=NULL)
+                {
+                    fringe.push_back(cur->right);
+                    next_itr++;
+                }
+                fringe_pos++;
+            }
+            ret.push_back(tmp);
+        }
+        return ret;
+    }
+};

binarytree_zigzag_levelorder_traversal.cpp

@@ -0,0 +1,85 @@
+/*
+Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).
+
+For example:
+Given binary tree [3,9,20,null,null,15,7],
+    3
+   / \
+  9  20
+    /  \
+   15   7
+return its zigzag level order traversal as:
+[
+  [3],
+  [20,9],
+  [15,7]
+]
+*/
+
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
+        vector<vector<int>> ret;
+        if(root==NULL)
+            return ret;
+        vector<TreeNode *> fringe;
+        int depth = 0;
+        int fringe_pos = 0;
+        int next_itr = 1;
+        fringe.push_back(root);
+        
+        while(next_itr != 0)
+        {
+            vector<int> tmp;
+            if(depth%2!=0)
+            {
+                int j = fringe_pos + next_itr - 1;
+                while(j>=fringe_pos)
+                {
+                    tmp.push_back(fringe[j]->val);
+                    j--;
+                }
+            }
+            else
+            {
+                int j = fringe_pos;
+                while (j<=(fringe_pos + next_itr - 1))
+                {
+                    tmp.push_back(fringe[j]->val);
+                    j++;
+                }
+            }
+            ret.push_back(tmp);
+            int i = next_itr;
+            next_itr = 0;
+            TreeNode *cur;
+            for(int j=0;j<i;j++)
+            {
+                cur=fringe[fringe_pos];
+                if(cur->left!=NULL)
+                {
+                    fringe.push_back(cur->left);
+                    next_itr++;
+                }
+                if(cur->right!=NULL)
+                {
+                    fringe.push_back(cur->right);
+                    next_itr++;
+                }
+                fringe_pos++;
+            }
+            depth++;
+        }
+        return ret;
+    }
+};

construct_binarytree_from_inroder_preorder.cpp

@@ -0,0 +1,47 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+        
+        cout<<preorder.size()<<" "<<inorder.size()<<"\n";
+        
+        if(preorder.size()==0 || inorder.size()==0)
+            return NULL;
+        
+        TreeNode *root = new TreeNode(preorder[0]);
+        
+        vector<int> inorder_left;
+        
+        int i;
+        for(i = 0;i<inorder.size();i++)
+        {
+            if(inorder[i]==preorder[0])
+                break;
+            inorder_left.push_back(inorder[i]);
+        }
+        vector<int> preorder_left;
+        int j;
+        for(j=1;j<=i;j++)
+            preorder_left.push_back(preorder[j]);
+        
+        root->left = buildTree(preorder_left,inorder_left);
+        
+        int right_size = inorder.size() - (i+1);
+        if(right_size > 0)
+        {
+            vector<int> inorder_right(inorder.begin() + i + 1,inorder.end());
+            vector<int> preorder_right(preorder.begin() + i + 1,preorder.end());
+            root->right = buildTree(preorder_right,inorder_right);
+        }
+        return root;
+        
+    }
+};

lowest_common_ancestor.cpp

@@ -0,0 +1,62 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+        vector<TreeNode *> stack;
+        TreeNode *ret;
+        int x=-1,y=-1,top=-1;
+        TreeNode *current = root;
+        int found = 0;
+        while(current!=NULL)
+        {
+            stack.push_back(current);
+            top++;
+            if(current == p || current == q)
+            {
+                if(y==-1)
+                {
+                    x=top;
+                    y=1;
+                    ret=stack[x];
+                }
+                cout<<"lca ind:"<<x<<"\n";
+                found++;
+            }
+            if(found == 2)
+                return ret;
+            if(current->left==NULL)
+            {
+                while(top>=0)
+                {
+                    current = stack[top];
+                    top--;
+                    if(y==1 && x>top)
+                    {
+                        ret=stack[x];
+                        x=top;
+                    }
+                    stack.pop_back();
+                    if(current->right != NULL)
+                    {
+                        break;
+                    }
+                }
+                current=current->right;
+                continue;
+
+            }
+            current=current->left;
+        }
+        if(found==2)
+            return ret;
+        return NULL;
+    }
+};