Tree

Author: shreymehul

101.IsSymmetric.cs

@@ -0,0 +1,50 @@
+// 101. Symmetric Tree
+
+// Given the root of a binary tree, check whether it is a mirror of itself (i.e., symmetric around its center).
+
+ 
+
+// Example 1:
+
+
+// Input: root = [1,2,2,3,4,4,3]
+// Output: true
+// Example 2:
+
+
+// Input: root = [1,2,2,null,3,null,3]
+// Output: false
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public bool IsSymmetric(TreeNode root)
+    {
+        if (root == null)
+            return true;
+        return CheckInvertTree(root.left, root.right);
+    }
+    
+    public bool CheckInvertTree(TreeNode root1, TreeNode root2)
+    {
+        if (root1 == null && root2 == null )
+            return true;
+        if (root1 == null || root2 == null)
+            return false;
+        if (root1.val != root2.val)
+            return false;
+        return CheckInvertTree(root1.left, root2.right) &&
+        CheckInvertTree(root1.right, root2.left);
+    }
+}

102.LevelOrder.cs

@@ -0,0 +1,61 @@
+// 102. Binary Tree Level Order Traversal
+
+// Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).
+
+ 
+
+// Example 1:
+
+
+// Input: root = [3,9,20,null,null,15,7]
+// Output: [[3],[9,20],[15,7]]
+// Example 2:
+
+// Input: root = [1]
+// Output: [[1]]
+// Example 3:
+
+// Input: root = []
+// Output: []
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public IList<IList<int>> LevelOrder(TreeNode root) {
+        IList<IList<int>> res = new List<IList<int>>();
+        if (root == null)
+        {
+        return res;
+        }
+
+        Queue<TreeNode> queue = new Queue<TreeNode>();
+            queue.Enqueue(root);
+        while (queue.Count > 0)
+        {
+            IList<int> level = new List<int>();
+            int size = queue.Count;
+            for (int i = 0; i < size; i++)
+            {
+                TreeNode currNode = queue.Dequeue();
+                level.Add(currNode.val);
+                if (currNode.right != null)
+                    queue.Enqueue(currNode.right);
+                    if (currNode.left != null)
+                    queue.Enqueue(currNode.left);
+            }
+            res.Add(level);
+        }
+        return res.Reverse();
+    }
+}

103.ZigzagLevelOrder.cs

@@ -0,0 +1,71 @@
+// 103. Binary Tree Zigzag Level Order Traversal
+// Given the root of a binary tree, return the zigzag level order traversal of its nodes' values. (i.e., from left to right, then right to left for the next level and alternate between).
+
+ 
+
+// Example 1:
+
+
+// Input: root = [3,9,20,null,null,15,7]
+// Output: [[3],[20,9],[15,7]]
+// Example 2:
+
+// Input: root = [1]
+// Output: [[1]]
+// Example 3:
+
+// Input: root = []
+// Output: []
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public IList<IList<int>> ZigzagLevelOrder(TreeNode root) {
+        IList<IList<int>> result = new List<IList<int>>();
+        if (root == null)
+            return result;
+        Queue<TreeNode> q = new Queue<TreeNode>();
+        q.Enqueue(root);
+        int level = 0;
+        while (q.Count > 0)
+        {
+            int size = q.Count;
+            List<int> valLevel = new List<int>();
+            for(int i=0; i< size; i++)
+            {
+                TreeNode top = q.Dequeue();
+                valLevel.Add(top.val);
+                if(top.left!=null)
+                    q.Enqueue(top.left);
+                if(top.right!=null)
+                    q.Enqueue(top.right);
+            }
+            if (level % 2 == 0)
+            {
+                result.Add(valLevel);
+            }
+            else
+            {
+                List<int> reverseLevelValue = new List<int>();
+                for(int i = valLevel.Count -1; i >= 0; i--)
+                {
+                    reverseLevelValue.Add(valLevel[i]);
+                }
+                result.Add(reverseLevelValue);
+            }
+            level++;
+        }
+        return result;
+    }
+}

104.MaxDepth.cs

@@ -0,0 +1,48 @@
+// 104. Maximum Depth of Binary Tree
+
+// Given the root of a binary tree, return its maximum depth.
+
+// A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+ 
+
+// Example 1:
+
+
+// Input: root = [3,9,20,null,null,15,7]
+// Output: 3
+// Example 2:
+
+// Input: root = [1,null,2]
+// Output: 2
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public int MaxDepth(TreeNode root) {
+        if (root == null)
+            return 0;
+        int leftHeight, rightHeight;
+        leftHeight = rightHeight = 0;
+        if (root.left != null)
+        {
+            leftHeight = MaxDepth(root.left);
+        }
+        if (root.right != null)
+        {
+            rightHeight = MaxDepth(root.right);
+        }
+        return 1 + Math.Max(leftHeight, rightHeight);
+    }
+}

107.LevelOrderBottom.cs

@@ -0,0 +1,66 @@
+// 107. Binary Tree Level Order Traversal II
+
+// Given the root of a binary tree, return the bottom-up level order traversal of its nodes' values. (i.e., from left to right, level by level from leaf to root).
+
+ 
+
+// Example 1:
+
+
+// Input: root = [3,9,20,null,null,15,7]
+// Output: [[15,7],[9,20],[3]]
+// Example 2:
+
+// Input: root = [1]
+// Output: [[1]]
+// Example 3:
+
+// Input: root = []
+// Output: []
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public IList<IList<int>> LevelOrderBottom(TreeNode root) {
+        IList<IList<int>> res = new List<IList<int>>();
+        if (root == null)
+        {
+        return res;
+        }
+
+        Queue<TreeNode> queue = new Queue<TreeNode>();
+        queue.Enqueue(root);
+        while (queue.Count > 0) 
+        {
+            IList<int> level = new List<int>();
+            int size = queue.Count;
+            for (int i = 0; i < size; i++)
+            {
+                TreeNode currNode = queue.Dequeue();
+                level.Add(currNode.val);
+                if (currNode.left != null)
+                    queue.Enqueue(currNode.left);
+                if (currNode.right != null)
+                    queue.Enqueue(currNode.right);
+            }
+            res.Add(level);
+        }
+        IList<IList<int>> finalres = new List<IList<int>>();
+        for(int i = res.Count-1; i >=0; i--)
+        {
+            finalres.Add(res[i]);
+        }
+        return finalres;
+    }
+}

110.IsBalanced.cs

@@ -0,0 +1,58 @@
+// 110. Balanced Binary Tree
+
+// Given a binary tree, determine if it is height-balanced.
+
+// For this problem, a height-balanced binary tree is defined as:
+
+// a binary tree in which the left and right subtrees of every node differ in height by no more than 1.
+
+ 
+
+// Example 1:
+
+
+// Input: root = [3,9,20,null,null,15,7]
+// Output: true
+// Example 2:
+
+
+// Input: root = [1,2,2,3,3,null,null,4,4]
+// Output: false
+// Example 3:
+
+// Input: root = []
+// Output: true
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    bool isBalanced = true;
+    public int Height(TreeNode root)
+    {
+        if (root == null)
+            return 0;
+        int leftHeight = Height(root.left);
+        int rightHeight = Height(root.right);
+
+        if (Math.Abs(leftHeight - rightHeight) > 1)
+            isBalanced = false;
+        return Math.Max(leftHeight, rightHeight) + 1;
+    }
+    public bool IsBalanced(TreeNode root) {
+       if (root == null)
+            return true;
+        Height(root);
+        return isBalanced; 
+    }
+}