//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));
}
