public static IList<string> BinaryTreePaths2(TreeNode head)
{
if (head == null)
{
return new List<string>();
}
IList<string> path1 = new List<string>();
IList<string> path2 = new List<string>();
if (head.left != null)
{
path1 = BinaryTreePaths2(head.left);
for (var i = 0; i < path1.Count; i++)
{
path1[i] = head.val + "->" + path1[i];
}
}
if (head.right != null)
{
path2 = BinaryTreePaths2(head.right);
for (var i = 0; i < path2.Count; i++)
{
path2[i] = head.val + "->" + path2[i];
}
}
foreach (var p in path2)
{
path1.Add(p);
}
return head.left == null && head.right == null?new List<string> { head.val.ToString() }: path1;
}
private static void AddNewNode(TreeNode n, List<TreeNode> p, IList<List<TreeNode>> path)
{
var newP = new List<TreeNode>();
foreach (var node in p)
{
var newNode = new TreeNode(node.val);
newP.Add(newNode);
}
newP.Add(n);
path.Add(newP);
path.Remove(p);
}
/// <summary>
/// this one is not right.
/// </summary>
/// <param name="root"></param>
/// <param name="p"></param>
/// <param name="q"></param>
/// <returns></returns>
public static TreeNode LowestCommonAncestor1(TreeNode root, TreeNode p, TreeNode q)
{
if (p == q || (p.left != null && p.left == q) || (p.right != null && p.right == q))
{
return p;
}
if ((q.left != null && q.left == p) || (q.right != null && q.right == p))
{
return q;
}
var parentP = FindParent(root, p);
var parentQ = FindParent(root, q);
return LowestCommonAncestor1(root, parentP, parentQ);
}
public static IList<IList<int>> LevelOrderBottom1(TreeNode root)
{
var bottomUpTraversal = new List<IList<int>>();
var nodeTag = new Dictionary<int, TreeNode>();
if (root != null)
{
TagTreeNodes(root, 0, nodeTag);
var tag = nodeTag.Keys;
var nLevelMax = System.Math.Floor(System.Math.Log(tag.Max()+1, 2));
for (var i = nLevelMax; i >=0 ; i--)
{
var level = new List<int>();
for (var j = System.Math.Pow(2, i)-1; j <= System.Math.Pow(2, i+1) - 2; j++)
{
if (nodeTag.ContainsKey((int)j))
{
level.Add(nodeTag[(int)j].val);
}
}
bottomUpTraversal.Add(level);
}
}
return bottomUpTraversal;
}
public static IList<IList<int>> LevelOrder(TreeNode root)
{
if(root!=null)
{
TagLevel1(root, 1);
}
return levelOrder;
}
public static bool IsSymmetric2(TreeNode root)
{
return root==null||IsSymmetricIter(root.left, root.right);
}
public static bool IsSameTree1(TreeNode p, TreeNode q)
{
//if (p == null )
//{
// return q == null;
//}
//if (q == null)
//{
// return false;
//}
//if (p.val != q.val)
//{
// return false;
//}
//return IsSameTree1(p.left, q.left) && IsSameTree1(p.right, q.right);
return p == null || q == null ? p == q : (p.val == q.val) && IsSameTree1(p.left, q.left) && IsSameTree1(p.right, q.right);
}
private static void InorderTraversalIter(TreeNode root, IList<int> ret)
{
if (root.left!=null)
{
InorderTraversalIter(root.left, ret);
}
ret.Add(root.val);
if (root.right != null)
{
InorderTraversalIter(root.right, ret);
}
}
private static int MaxDepth2Iter(TreeNode root, ref int count)
{
if (root.left == null && root.right == null)
{
return count;
}
var n = count + 1;
if (root.right == null)
{
return MaxDepth2Iter(root.left, ref n);
}
if (root.left == null)
{
return MaxDepth2Iter(root.right, ref n);
}
return System.Math.Max(MaxDepth2Iter(root.left, ref n), MaxDepth2Iter(root.right, ref n));
}
private static int FindMinDepth(TreeNode node, int depth)
{
if (node.left == null && node.right == null)
{
return depth;
}
if (node.left == null)
{
return FindMinDepth(node.right, depth + 1);
}
if(node.right==null)
{
return FindMinDepth(node.left, depth + 1);
}
return System.Math.Min(FindMinDepth(node.left, depth + 1), FindMinDepth(node.right, depth + 1));
}
private static TreeNode FindParent(TreeNode root, TreeNode p)
{
if (root == null || root == p)
{
return root;
}
if (root.left == p || root.right == p)
{
return root;
}
var a = FindParent(root.left, p);
var b = FindParent(root.right, p);
return a == null ? b : a;
}
private static void FindAncestorIter(TreeNode root, int n, IList<Tuple<TreeNode, int>> tree, ref int indexP, ref int indexQ, TreeNode p, TreeNode q)
{
tree.Add(new Tuple<TreeNode, int>(root, n));
if (root == p)
{
indexP = n;
}
if (root == q)
{
indexQ = n;
}
if (indexP != 0 && indexQ != 0)
{
return;
}
if (root.left != null)
{
FindAncestorIter(root.left, 2*n, tree, ref indexP, ref indexQ, p, q);
}
if (root.right != null)
{
FindAncestorIter(root.right, 2 * n + 1, tree, ref indexP, ref indexQ, p, q);
}
}
private static List<TreeNode> FindAllParents(TreeNode root, TreeNode p)
{
var parents = new List<TreeNode>();
while (root != p)
{
parents.Add(p);
p = FindParent(root, p);
}
parents.Add(root);
return parents;
}
private static void BuildStack(TreeNode root, Stack<int> tree)
{
if (root != null)
{
if (root.right != null)
{
BuildStack(root.right, tree);
}
tree.Push(root.val);
if (root.left != null)
{
BuildStack(root.left, tree);
}
}
}
public static TreeNode InvertTree2(TreeNode root)
{
if (root == null)
{
return null;
}
Queue<TreeNode> nodeQueue = new Queue<TreeNode>();
nodeQueue.Enqueue(root);
while(nodeQueue.Count != 0)
{
var node = nodeQueue.Dequeue();
if(node.left != null)
{
nodeQueue.Enqueue(node.left);
}
if(node.right != null)
{
nodeQueue.Enqueue(node.right);
}
var tmp = node.left;
node.left = node.right;
node.right = tmp;
}
return root;
}
private static void TagLevel(TreeNode node, int level)
{
if (level == nodeTag.Count)
{
nodeTag.Add(new List<int>());
}
nodeTag[level].Add(node.val);
if (node.left != null)
{
TagLevel(node.left, level+1);
}
if (node.right != null)
{
TagLevel(node.right, level+1);
}
}
public static bool IsBalanced(TreeNode root)
{
if (root == null)
{
return true;
}
Console.WriteLine(MaxDepth2(root.left));
Console.WriteLine(MaxDepth2(root.right));
return System.Math.Abs(MaxDepth2(root.left) - MaxDepth2(root.right)) <= 1 && IsBalanced(root.right) && IsBalanced(root.left);
}
private static void TagLevel1(TreeNode node, int level)
{
if (level > levelOrder.Count)
{
levelOrder.Add(new List<int>());
}
levelOrder[level - 1].Add(node.val);
if (node.left != null)
{
TagLevel1(node.left, level + 1);
}
if (node.right != null)
{
TagLevel1(node.right, level + 1);
}
}
public static bool IsSameTree2(TreeNode p, TreeNode q)
{
//if (p == null)
//{
// return q == null;
//}
//if (q == null)
//{
// return false;
//}
if (p == null || q == null)
{
return p == q;
}
Queue<TreeNode> nodesP = new Queue<TreeNode>();
Queue<TreeNode> nodesQ = new Queue<TreeNode>();
nodesP.Enqueue(p);
nodesQ.Enqueue(q);
while (nodesP.Count != 0)
{
TreeNode a = nodesP.Dequeue();
TreeNode b = nodesQ.Dequeue();
//if (a.val != b.val)
//{
// return false;
//}
//if ((a.left == null && b.left != null) || (a.left != null && b.left == null))
//{
// return false;
//}
//if ((a.right == null && b.right != null) || (a.right != null && b.right == null))
//{
// return false;
//}
//if (a.left != null && b.left != null)
//{
// nodesP.Enqueue(a.left);
// nodesQ.Enqueue(b.left);
//}
//if (a.right != null && b.right != null)
//{
// nodesP.Enqueue(a.right);
// nodesQ.Enqueue(b.right);
//}
if (a.val != b.val)
return false;
if (a.left != null)
nodesP.Enqueue(a.left);
if (b.left != null)
nodesQ.Enqueue(b.left);
if (nodesP.Count != nodesQ.Count)
return false;
if (a.right != null)
nodesP.Enqueue(a.right);
if (b.right != null)
nodesQ.Enqueue(b.right);
if (nodesP.Count != nodesQ.Count)
return false;
}
return true;
}
private static void TagNodes(TreeNode p, int n, Dictionary<TreeNode, int> index)
{
index.Add(p, n);
var m = n*2 + 1;
var l = n*2 + 2;
if (p.left != null)
{
TagNodes(p.left, m, index);
}
if (p.right != null)
{
TagNodes(p.right, l, index);
}
}
public static bool IsSymmetric1(TreeNode root)
{
if (root == null)
{
return true;
}
var lQueue = new Queue<TreeNode>();
var rQueue = new Queue<TreeNode>();
if (root.left != null)
{
lQueue.Enqueue(root.left);
}
if (root.right != null)
{
rQueue.Enqueue(root.right);
}
if (lQueue.Count != rQueue.Count)
{
return false;
}
while (lQueue.Count != 0)
{
var l = lQueue.Dequeue();
var r = rQueue.Dequeue();
if (l.val != r.val)
{
return false;
}
if (l.left != null)
{
lQueue.Enqueue(l.left);
}
if (r.right != null)
{
rQueue.Enqueue(r.right);
}
if (lQueue.Count != rQueue.Count)
{
return false;
}
if (l.right != null)
{
lQueue.Enqueue(l.right);
}
if (r.left != null)
{
rQueue.Enqueue(r.left);
}
if (lQueue.Count != rQueue.Count)
{
return false;
}
}
return true;
}
private static void TagTreeNodes(TreeNode node, int n, IDictionary<int, TreeNode> nodeTag)
{
nodeTag.Add(n, node);
var l = 2*n + 1;
var r = 2*n + 2;
if (node.left != null)
{
TagTreeNodes(node.left, l, nodeTag);
}
if (node.right != null)
{
TagTreeNodes(node.right, r, nodeTag);
}
}
public static bool IsSymmetricIter(TreeNode l, TreeNode r)
{
if (l == null && r == null)
{
return true;
}
if (l == null || r == null)
{
return false;
}
return l.val == r.val && IsSymmetricIter(l.left, r.right) && IsSymmetricIter(l.right, r.left);
}
private void PreorderTraversalIter(TreeNode node, IList<int> traversal)
{
traversal.Add(node.val);
if (node.left != null)
{
PreorderTraversalIter(node.left, traversal);
}
if (node.right != null)
{
PreorderTraversalIter(node.right, traversal);
}
}
public static IList<IList<int>> LevelOrderBottom(TreeNode root)
{
if (root != null)
{
TagLevel(root, 0);
}
var newNodeTag = new List<IList<int>>();
for (var i = nodeTag.Count - 1; i >= 0; i--)
{
newNodeTag.Add(nodeTag[i]);
}
return newNodeTag;
}
public static bool HasPathSum(TreeNode root, int sum)
{
if (root == null)
{
return false;
}
if (root.left == null && root.right == null)
{
return root.val == sum;
}
return HasPathSum(root.left, sum - root.val) || HasPathSum(root.right, sum - root.val);
}
public static int LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q)
{
var tree = new List<Tuple<TreeNode, int>>();
int indexP = 0;
int indexQ = 0;
if (root != null)
{
FindAncestorIter(root, 1, tree, ref indexP, ref indexQ, p, q);
}
while (indexP != indexQ)
{
if (indexP > indexQ)
{
indexP = indexP / 2;
}
else
{
indexQ = indexQ / 2;
}
}
foreach (var item in tree)
{
if (item.Item2 == indexP)
return item.Item1.val;
}
return 0;
}
public static TreeNode InvertTree1(TreeNode root)
{
if(root == null)
{
return null;
}
if (root.left == null && root.right == null)
{
return root;
}
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
root.left = InvertTree1(root.left);
root.right = InvertTree1(root.right);
return root;
}
public static TreeNode LowestCommonAncestor10(TreeNode root, TreeNode p, TreeNode q)
{
if (root == null)
{
return null;
}
var tree = new List<Tuple<TreeNode, int>>();
var queue = new Queue<Tuple<TreeNode, int>>();
queue.Enqueue(new Tuple<TreeNode, int>(root, 1));
var indexP = 0;
var indexQ = 0;
while (indexP>0&&indexQ>0)
{
var item = queue.Dequeue();
var node = item.Item1;
var n = item.Item2;
tree.Add(item);
if (node == p)
{
indexP = n;
}
if (node == q)
{
indexQ = n;
}
if (node.left != null)
{
queue.Enqueue(new Tuple<TreeNode, int>(node.left, 2 * n));
}
if (node.right != null)
{
queue.Enqueue(new Tuple<TreeNode, int>(node.right, 2 * n + 1));
}
}
while (indexP != indexQ)
{
if (indexP > indexQ)
{
indexP = indexP / 2;
}
else
{
indexQ = indexQ / 2;
}
}
foreach (var item in tree)
{
if (item.Item2 == indexP)
return item.Item1;
}
return null;
}
public IList<int> PreorderTraversal(TreeNode root)
{
var traversal = new List<int>();
if (root != null)
{
PreorderTraversalIter(root, traversal);
}
return traversal;
}
