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