private static BinaryTreeNodeWithParent <T> MinNode <T>(BinaryTreeNodeWithParent <T> node) where T : IComparable <T> { while (node.Left != null) { node = node.Left; } return(node); }
private static BinaryTreeNodeWithParent<int> AddChildren(BinaryTreeNodeWithParent<int> parent, int[] sortedArray) { if (sortedArray.Length == 0) return null; var newNode = new BinaryTreeNodeWithParent<int>(sortedArray[sortedArray.Length / 2]); newNode.Parent = parent; newNode.Left = AddChildren(newNode, sortedArray.Take(sortedArray.Length / 2).ToArray()); newNode.Right = AddChildren(newNode, sortedArray.Skip(sortedArray.Length / 2 + 1).ToArray()); return newNode; }
//Adds all leaves of a binary tree to a given list private static void GetLeaves(BinaryTreeNodeWithParent <int> origin, ref NodePath leaves) { if (origin == null) { return; } if (origin.Left == null && origin.Right == null) { leaves.Add(origin); return; } GetLeaves(origin.Left, ref leaves); GetLeaves(origin.Right, ref leaves); }
public static List <NodePath> FindPathsWithSum(this BinaryTreeNodeWithParent <int> root, int sum) { var paths = new List <NodePath>(); var leaves = new NodePath(); GetLeaves(root, ref leaves); foreach (var leaf in leaves) { paths.AddRange(GetPathsWithSum(leaf, sum)); } paths.ForEach(x => x.Reverse()); return(paths.Count != 0 ? paths : null); }
private static bool CompareNodes <T>(BinaryTreeNodeWithParent <T> subtree, BinaryTreeNodeWithParent <T> tree) where T : IComparable <T> { //Check if we are finished... if (subtree == null && tree == null) { return(true); } //otherwise compare children bool left; if (subtree.Left == null && tree.Left == null) { left = true; } else if (subtree.Left == null || tree.Left == null) { left = false; } else { left = subtree.Left.Data.CompareTo(tree.Left.Data) == 0; } bool right; if (subtree.Right == null && tree.Right == null) { right = true; } else if (subtree.Right == null || tree.Right == null) { right = false; } else { right = subtree.Right.Data.CompareTo(tree.Right.Data) == 0; } //If both children are null or equal, check their children. if (left && right) { return(CompareNodes(subtree.Left, tree.Left) && CompareNodes(subtree.Right, tree.Right)); } return(false); }
//Travel upwards from leaf node and return any path that adds to the sum //We don't stop when we reach the sum since there may be negative values private static List <NodePath> GetPathsWithSum(BinaryTreeNodeWithParent <int> node, int sum) { NodePath currPath = new NodePath(); int currSum = 0; List <NodePath> pathsWithSum = new List <NodePath>(); while (node != null) { currSum += node.Data; currPath.Add(node); if (currSum == sum) { pathsWithSum.Add(currPath.ToList()); //ToList to make a copy } node = node.Parent; } return(pathsWithSum); }
public static BinaryTreeNodeWithParent <T> GetSuccessor <T>(this BinaryTreeNodeWithParent <T> node) where T : IComparable <T> { if (node.Right != null) { return(MinNode(node.Right)); } while (node.Parent != null) { BinaryTreeNodeWithParent <T> prev = node; node = node.Parent; if (node?.Left == prev) { return(node); } } return(null); }
public static bool IsSubtreeOf <T>(this BinaryTreeNodeWithParent <T> subtreeRoot, BinaryTreeNodeWithParent <T> treeRoot) where T : IComparable <T> { if (subtreeRoot == null || treeRoot == null) { return(false); } BinaryTreeNodeWithParent <T> currNode; var queue = new Queue <BinaryTreeNodeWithParent <T> >(); queue.Enqueue(treeRoot); //Iterate through each node and compare it to the first node of the subtree. If they match, //compare for each child in the subtree. while (!queue.IsEmpty) { currNode = queue.Dequeue(); if (currNode.Data.CompareTo(subtreeRoot.Data) == 0) { if (CompareNodes(subtreeRoot, currNode)) { return(true); } } if (currNode.Left != null) { queue.Enqueue(currNode.Left); } if (currNode.Right != null) { queue.Enqueue(currNode.Right); } } return(false); }