//stack iteration solution public static IList<int> StackInorderTraversal(TreeNode root) { var list = new List<int>(); if (root == null) return list; var stack = new Stack<TreeNode>(); var temp = root; while (temp != null) { while (temp != null) { if (temp.right != null) stack.Push(temp.right); stack.Push(temp); temp = temp.left; } temp = stack.Pop(); while (stack.Count != 0 && temp.right == null) { list.Add(temp.val); temp = stack.Pop(); } list.Add(temp.val); if (stack.Count != 0) temp = stack.Pop(); else temp = null; } return list; }
public static IList<IList<int>> LevelOrderBottom(TreeNode root) { if(root == null) return new List<IList<int>>(); List<IList<int>> result = new List<IList<int>>(); List<int> level = new List<int>(); var queue = new Queue<NodeWithHeight>(); int height = 0; var temp = new NodeWithHeight(root,height); queue.Enqueue(temp); while(queue.Count != 0){ temp = queue.Dequeue(); if (temp.Height > height) { result.Insert(0, level); height = temp.Height; level = new List<int>(); level.Add(temp.Node.val); } else level.Add(temp.Node.val); if (temp.Node.left != null) queue.Enqueue(new NodeWithHeight(temp.Node.left, temp.Height + 1)); if (temp.Node.right != null) queue.Enqueue(new NodeWithHeight(temp.Node.right, temp.Height + 1)); } if (level.Count != 0) result.Insert(0, level); return result; }
public void TestMethodIsSameTree() { var tree1 = new TreeNode(0); var tree2 = new TreeNode(0); var tree3 = new TreeNode(0); var tree4 = new TreeNode(1); tree1.left = new TreeNode(1); tree1.right = new TreeNode(1); tree1.left.left = new TreeNode(2); tree2.left = new TreeNode(1); tree2.right = new TreeNode(1); tree2.left.left = new TreeNode(2); tree3.left = new TreeNode(1); tree3.right = new TreeNode(1); tree3.left.right = new TreeNode(2); tree1.left = new TreeNode(1); tree1.right = new TreeNode(1); tree1.left.left = new TreeNode(2); Assert.AreEqual(true, SameTreeSolution.IsSameTree(tree1, tree2)); Assert.AreEqual(false, SameTreeSolution.IsSameTree(tree1, tree3)); Assert.AreEqual(false, SameTreeSolution.IsSameTree(tree1, tree4)); }
/// <summary> /// The recursive way /// </summary> /// <param name="root"></param> /// <returns></returns> public static IList<int> PreorderTraversal(TreeNode root) { if (root == null) return new List<int>(); else return new List<int>() { root.val } .Concat(PreorderTraversal(root.left)) .Concat(PreorderTraversal(root.right)) .ToList(); }
//recursive solution public static IList<int> InorderTraversal(TreeNode root) { var list = new List<int>(); if (root == null) return list; list.AddRange(InorderTraversal(root.left)); list.Add(root.val); list.AddRange(InorderTraversal(root.right)); return list; }
public static TreeNode InvertTree(TreeNode root) { if (root == null) return null; var buffer = root.left; root.left = root.right; root.right = buffer; InvertTree(root.left); InvertTree(root.right); return root; }
public static bool IsSameTree(TreeNode p, TreeNode q) { if (p == null && q == null) return true; else if ((p != null && q == null) || (p == null && q != null)) return false; else if (p.val != q.val) return false; else return IsSameTree(p.left, q.left) == true && IsSameTree(p.right, q.right) == true; }
public void TestMethodMaxDepth() { var tree = new TreeNode(0); tree.left = new TreeNode(1); tree.right = new TreeNode(1); tree.left.left = new TreeNode(2); tree.left.left.left = new TreeNode(3); tree.left.right = new TreeNode(2); int depth = MaximumDepthOfABinaryTree.MaxDepth(tree); Assert.AreEqual(4, depth); }
public void TestMethodLowestCommonAncestor() { var tree0 = new TreeNode(20); tree0.left = new TreeNode(10); tree0.right = new TreeNode(30); tree0.left.left = new TreeNode(5); tree0.left.right = new TreeNode(15); tree0.right.left = new TreeNode(25); tree0.right.right = new TreeNode(35); tree0.left.left.left = new TreeNode(2); Assert.AreEqual(20, LCASolution.LowestCommonAncestor(tree0, tree0.left.left.left, tree0.right.right).val); Assert.AreEqual(5, LCASolution.LowestCommonAncestor(tree0, tree0.left.left.left, tree0.left.left).val); }
public void TestMethodLevelOrderBottom() { var tree = new TreeNode(3); tree.left = new TreeNode(9); tree.right = new TreeNode(20); tree.right.left = new TreeNode(15); tree.right.right = new TreeNode(7); var list = LevelOrderBTTII.LevelOrderBottom(tree); Assert.AreEqual(15, list[0][0]); Assert.AreEqual(7, list[0][1]); Assert.AreEqual(9, list[1][0]); Assert.AreEqual(20, list[1][1]); Assert.AreEqual(3, list[2][0]); }
/// <summary> /// The stack solution /// </summary> /// <param name="root">Root node of the tree</param> /// <returns>A list of PreOrderTraversal of the tree</returns> public static IList<int> StackPreorderTraversal(TreeNode root) { var list = new List<int>(); var stack = new Stack<TreeNode>(); TreeNode temp; if (root != null) stack.Push(root); while (stack.Count != 0) { temp = stack.Pop(); list.Add(temp.val); if(temp.right != null) stack.Push(temp.right); if(temp.left != null) stack.Push(temp.left); } return list; }
public void TestMethodInvertTree() { var tree = new TreeNode(10); tree.left = new TreeNode(8); tree.right = new TreeNode(12); tree.left.left = new TreeNode(7); tree.left.right = new TreeNode(9); tree = InvertBinaryTreeSolution.InvertTree(tree); Assert.AreEqual(10, tree.val); Assert.AreEqual(8, tree.right.val); Assert.AreEqual(12, tree.left.val); Assert.AreEqual(7, tree.right.right.val); Assert.AreEqual(9, tree.right.left.val); }
public void TestMethodInorderTraversal() { var tree = new TreeNode(1); tree.left = new TreeNode(2); tree.right = new TreeNode(3); tree.right.left = new TreeNode(4); tree.right.right = new TreeNode(5); IList<int> list = new List<int> { 2, 1, 4, 3, 5 }; for (int i = 0; i < InOrderTraversalSolution.InorderTraversal(tree).Count; i++) { Assert.AreEqual(list[i], InOrderTraversalSolution.InorderTraversal(tree)[i]); } for (int i = 0; i < InOrderTraversalSolution.StackInorderTraversal(tree).Count; i++) { Assert.AreEqual(list[i], InOrderTraversalSolution.StackInorderTraversal(tree)[i]); } }
public void TestMethodPreOrderTraversal() { var tree = new TreeNode(1); tree.left = new TreeNode(2); tree.right = new TreeNode(3); tree.right.left = new TreeNode(4); tree.right.right = new TreeNode(5); IList<int> list = new List<int> { 1, 2, 3, 4, 5 }; for (int i = 0; i < PreOrderTraversalSolution.PreorderTraversal(tree).Count; i++) { Assert.AreEqual(i + 1, PreOrderTraversalSolution.PreorderTraversal(tree)[i]); } for (int i = 0; i < PreOrderTraversalSolution.StackPreorderTraversal(tree).Count; i++) { Assert.AreEqual(i + 1, PreOrderTraversalSolution.StackPreorderTraversal(tree)[i]); } }
public static TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { TreeNode small, large; if (p.val < q.val) { small = p; large = q; } else { small = q; large = p; } var temp = root; while (!(temp.val >= small.val && temp.val <= large.val)) { if (temp.val < small.val) temp = temp.right; else temp = temp.left; } return temp; }
public NodeWithHeight(TreeNode node, int height) { Node = node; Height = height; }
//The recursive solution public static int MaxDepth(TreeNode root) { return root == null ? 0 : 1 + Math.Max(MaxDepth(root.left), MaxDepth(root.right)); }