kth smallest in bst

Author: sam41290

convert_sorted_array_to_BST.cpp

@@ -0,0 +1,34 @@
+/**
+ * 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* sortedArrayToBST(vector<int>& nums) {
+        
+        int n=nums.size();
+        TreeNode *root;
+        if(n==0)
+            return NULL;
+        if(n==1)
+        {
+            root = new TreeNode(nums[0]);
+            return root;
+        }
+        else
+        {
+            int mid = n/2;
+            root = new TreeNode(nums[mid]);
+            vector<int> vec_left(nums.begin(),nums.begin() + mid);
+            vector<int> vec_right(nums.begin() + mid + 1,nums.end());
+            root->left=sortedArrayToBST(vec_left);
+            root->right=sortedArrayToBST(vec_right);
+        }
+        return root;
+    }
+};

inorder_traversal_iterative.cpp

@@ -0,0 +1,46 @@
+/**
+ * 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<int> inorderTraversal(TreeNode* root) {
+        vector<int> ret;
+        vector<TreeNode *> stack;
+        if(root == NULL)
+            return ret;
+        TreeNode *current=root;
+        int top=-1;
+        while(current!=NULL)
+        {
+            stack.push_back(current);
+            top++;
+            if(current->left==NULL)
+            {
+                //ret.push_back(current->val);
+                while(top>=0)
+                {
+                    current = stack[top];
+                    top--;
+                    stack.pop_back();
+                    ret.push_back(current->val);
+                    if(current->right != NULL)
+                    {
+                        break;
+                    }
+                }
+                current=current->right;
+                continue;
+                
+            }
+            current=current->left;
+                
+        }
+        return ret;
+    }
+};

kth_smallest_in_bst.cpp

@@ -0,0 +1,52 @@
+/*
+Given a binary search tree, write a function kthSmallest to find the kth smallest element in it.
+
+Note: 
+You may assume k is always valid, 1 ≤ k ≤ BST's total elements.
+*/
+
+
+/**
+ * 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:
+    int kthSmallest(TreeNode* root, int k) {
+        vector<int> ret;
+        vector<TreeNode *> stack;
+        TreeNode *current=root;
+        int top=-1;
+        while(current!=NULL)
+        {
+            stack.push_back(current);
+            top++;
+            if(current->left==NULL)
+            {
+                //ret.push_back(current->val);
+                while(top>=0)
+                {
+                    current = stack[top];
+                    top--;
+                    stack.pop_back();
+                    ret.push_back(current->val);
+                    if(current->right != NULL)
+                    {
+                        break;
+                    }
+                }
+                current=current->right;
+                continue;
+
+            }
+            current=current->left;
+
+        }
+        return ret[k-1];
+    }
+};

maximum_depth_of_binary_tree.cpp

@@ -0,0 +1,31 @@
+/**
+ * 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:
+    
+    int max_depth = 0;
+    
+    void dfs(TreeNode *node,int depth)
+    {
+        if(depth > max_depth)
+            max_depth = depth;
+        if(node->left!=NULL)
+            dfs(node->left,depth + 1);
+        if(node->right!=NULL)
+            dfs(node->right,depth + 1);
+        return;
+    }
+    
+    int maxDepth(TreeNode* root) {
+        if(root!=NULL)
+            dfs(root,1);
+        return max_depth;
+    }
+};

symmetric_tree.cpp

@@ -0,0 +1,95 @@
+/*
+Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
+
+For example, this binary tree [1,2,2,3,4,4,3] is symmetric:
+
+    1
+   / \
+  2   2
+ / \ / \
+3  4 4  3
+But the following [1,2,2,null,3,null,3] is not:
+    1
+   / \
+  2   2
+   \   \
+   3    3
+*/
+
+
+
+/**
+ * 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:
+    
+    bool isSymmetric(TreeNode* root) {
+        
+        if(root == NULL)
+            return true;
+        
+        bool ret = true;
+        
+        vector<TreeNode *> fringe;
+        fringe.push_back(root);
+        int depth = 0;
+        int next_itr=1;
+        int fringe_pos = 0;
+        while(next_itr!=0)
+        {
+            int i = next_itr;
+            int k = fringe_pos + i - 1;
+            next_itr = 0;
+            if(i==1)
+            {
+                TreeNode *tmp = fringe[fringe_pos];
+                fringe.push_back(tmp->left);
+                next_itr++;
+                fringe.push_back(tmp->right);
+                next_itr++;
+                fringe_pos++;
+            }
+            else
+            {
+                int mid = i/2;
+                
+                for(int j=0;j<i;j++)
+                {
+                    TreeNode *tmp = fringe[fringe_pos];
+                    if(tmp!=NULL)
+                    {
+                        fringe.push_back(tmp->left);
+                        next_itr++;
+                        fringe.push_back(tmp->right);
+                        next_itr++;
+                    }
+                    if(j<mid)
+                    {
+                        TreeNode *tmp2 = fringe[k];
+                        if(tmp == NULL && tmp2!=NULL)
+                            return false;
+                        else if(tmp2 == NULL && tmp!=NULL)
+                            return false;
+                        else if(tmp!=NULL && tmp2!=NULL)
+                        {
+                            if(tmp->val != tmp2->val)
+                                return false;
+                        }
+                        k--;
+                    }
+                    fringe_pos++;
+                }
+                
+            }
+            
+        }
+        return ret;
+    }
+};