public static void Test() { List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; TreeNode root = new TreeNode(0); Binary_Tree.CreatWQBinaryTree(list, root); }
public static TreeNode InvertTree(TreeNode root) { if (root == null || (root.left == null && root.right == null)) return root; List<TreeNode> nodeList = new List<TreeNode>(); nodeList.Add(root); for (int i = 0; i < nodeList.Count; ) { if (nodeList[i] == null || (nodeList[i].left == null && nodeList[i].right == null)) { i++; continue; } TreeNode tempNode = nodeList[i].right; nodeList[i].right = nodeList[i].left; nodeList[i].left = tempNode; nodeList.Add(nodeList[i].right); nodeList.Add(nodeList[i].left); i++; } return root; }
public static void PerTraverse(TreeNode root) { if (root != null) { Console.Write("{0} ", root.val); PerTraverse(root.left); PerTraverse(root.right); } else { return; } }
public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { if (root == null) { return root; } if (root.val > p.val && root.val > q.val) { return LowestCommonAncestor(root.left, p, q); } else if (root.val < p.val && root.val< q.val) { return LowestCommonAncestor(root.right, p, q); } return root; }
public static TreeNode SortedArrayToBST(int[] nums, int begin, int end, TreeNode node) { int middle = begin + (end - begin) / 2; if (begin == end) { return new TreeNode(nums[middle]); } else if (begin > end) { return null; } else { node = new TreeNode(nums[middle]); } node.left = SortedArrayToBST(nums, begin, middle - 1, node); node.right = SortedArrayToBST(nums, middle + 1, end, node); return node; }
/// <summary> /// 创建一颗完全二叉树 /// </summary> /// <param name="list"></param> /// <param name="root"></param> /// <returns></returns> public static TreeNode CreatWQBinaryTree(List<int> list, TreeNode root) { //代表节点个数,根节点为1 int i = 1; TreeNode Node = root; //当前父节点编号 int nodeNumber = 1; //父节点编号集合 List<TreeNode> nodes = new List<TreeNode>(); //添加根节点 nodes.Add(root); //思路,根据完全二叉树的性质,我们可以一个父节点一个父节点的顺序插入左右节点 while (i < list.Count) { //添加左节点 Node.left = new TreeNode(list[i]); nodes.Add(Node.left); i++; //添加右节点 if (i < list.Count) { Node.right = new TreeNode(list[i]); nodes.Add(Node.right); i++; } else break; //前往下一个父节点 nodeNumber++; Node = nodes[nodeNumber - 1]; } return root; }
/// <summary> /// /// </summary> /// <param name="root"></param> /// <returns></returns> public static bool IsSymmetric(TreeNode root) { var result = false; if (root == null) return true; var nodeListA = PreorderTraversal(root.left); var nodeListB = PreorderTraversalReverse(root.right); if (nodeListA.Count == nodeListB.Count) { for (int i = 0; i < nodeListA.Count; i++) { if (nodeListA[i] != nodeListB[i]) { return false; } } result = true; } return result; }
public static bool IsSymmetric2(TreeNode root) { if (root == null) { return true; } if (root.right == null && root.left == null) { return true; } else if (root.right == null || root.left == null) { return false; } List<TreeNode> NodesLeft = new List<TreeNode>(); List<TreeNode> NodesRight = new List<TreeNode>(); NodesLeft.Add(root.left); NodesRight.Add(root.right); int nodeNumber = 0; while (nodeNumber >= 0) { if (NodesLeft[nodeNumber].val != NodesRight[nodeNumber].val) { return false; } //进行左节点 if (NodesLeft[nodeNumber].left != null) { NodesLeft.Add(NodesLeft[nodeNumber].left); } if (NodesRight[nodeNumber].right != null) { NodesRight.Add(NodesRight[nodeNumber].right); } if (NodesRight.Count != NodesLeft.Count) { return false; } //进行右节点 if (NodesLeft[nodeNumber].right != null) { NodesLeft.Add(NodesLeft[nodeNumber].right); } if (NodesRight[nodeNumber].left != null) { NodesRight.Add(NodesRight[nodeNumber].left); } if (NodesRight.Count != NodesLeft.Count) { return false; } if (nodeNumber == NodesRight.Count-1) { break; } nodeNumber++; } return true; }
/// <summary> /// https://leetcode.com/discuss/54627/c%23-accepted-issymmetrictree-recursive-and-non-recursive /// </summary> public static void Test() { List<int> list = new List<int>() { 1,2,2,3,4,4,3,6,5,7,8,8,7,5,5 }; TreeNode root = new TreeNode(list[0]); Binary_Tree.CreatWQBinaryTree(list, root); Console.Write(IsSymmetric2(root)); }
public static IList<int> PreorderTraversalReverse(TreeNode root) { if (root == null) { return new List<int>(); } List<int> preorder = new List<int>(); List<TreeNode> Nodes = new List<TreeNode>(); Nodes.Add(root); int nodeNumber = 0; while (nodeNumber >= 0) { //这里判断根节点是否已经保存了 if (nodeNumber == Nodes.Count() - 1) { preorder.Add(Nodes[nodeNumber].val); } else { nodeNumber = nodeNumber - 1; } //进行右节点 if (Nodes[nodeNumber].right != null) { Nodes.Add(Nodes[nodeNumber].right); nodeNumber++; continue; } //进行左节点 if (Nodes[nodeNumber].left != null) { Nodes.Add(Nodes[nodeNumber].left); nodeNumber++; continue; } //左右都跑完后,上一个节点设为空 else { if (nodeNumber == 0) { break; } if (Nodes[nodeNumber - 1].right == null) { Nodes[nodeNumber - 1].left = null; } else { Nodes[nodeNumber - 1].right = null; } } Nodes.RemoveAt(nodeNumber); } return preorder; }
/// <summary> ///层序遍历 /// </summary> /// <param name="root"></param> public static void LayerTraverse(TreeNode root) { TreeNode Node = root; List<TreeNode> Nodes = new List<TreeNode>(); Nodes.Add(root); int nodeNumber = 0; while (Nodes.Count > 0) { if (Node.left != null) { Nodes.Add(Node.left); } else break; if (Node.right != null) { Nodes.Add(Node.right); } else break; nodeNumber++; Node = Nodes[nodeNumber]; } foreach (var node in Nodes) { Console.WriteLine(node.val); } }
public static IList<IList<int>> LevelOrder(TreeNode root) { List<IList<int>> treeList = new List<IList<int>>(); List<TreeNode> Nodes = new List<TreeNode>(); if (root == null) { return treeList; } //用来保存节点的深度 List<int> NodeDepth = new List<int>(); Dictionary<int, List<int>> dic = new Dictionary<int, List<int>>(); TreeNode Node = root; bool left = false; bool rigth = false; NodeDepth.Add(0); Nodes.Add(root); treeList.Add(new List<int>() { root.val }); int nodeNumber = 0; while (Nodes.Count > 0) { if (Node.left != null) { left = false; Nodes.Add(Node.left); //当前深度等于 NodeDepth.Add(NodeDepth[nodeNumber] + 1); if (dic.ContainsKey(NodeDepth[nodeNumber] + 1)) { dic[NodeDepth[nodeNumber] + 1].Add(Node.left.val); } else { List<int> sameDepthNodeList = new List<int>(); sameDepthNodeList.Add(Node.left.val); dic.Add(NodeDepth[nodeNumber] + 1, sameDepthNodeList); } } else left = true; if (Node.right != null) { rigth = false; Nodes.Add(Node.right); NodeDepth.Add(NodeDepth[nodeNumber] + 1); if (dic.ContainsKey(NodeDepth[nodeNumber] + 1)) { dic[NodeDepth[nodeNumber] + 1].Add(Node.right.val); } else { List<int> sameDepthNodeList = new List<int>(); sameDepthNodeList.Add(Node.right.val); dic.Add(NodeDepth[nodeNumber] + 1, sameDepthNodeList); } } else rigth = true; nodeNumber++; if (rigth && left && nodeNumber > Nodes.Count() - 1) { break; } Node = Nodes[nodeNumber]; } foreach (var sameDepthNodeList in dic.Values) { treeList.Add(sameDepthNodeList); } return treeList; }
public static void Test() { List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; TreeNode root = new TreeNode(list[0]); Binary_Tree.CreatWQBinaryTree(list, root); var listRes = PreorderTraversal(root); foreach (var number in listRes) { Console.Write(number + " "); } }
public static void Test() { List<int> listp = new List<int>() { 1}; TreeNode p = new TreeNode(listp[0]); Binary_Tree.CreatWQBinaryTree(listp, p); List<int> listq = new List<int>() { 1}; TreeNode q = new TreeNode(listq[0]); Binary_Tree.CreatWQBinaryTree(listq, q); Console.Write(IsSameTree(p, q)); }
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; } TreeNode Nodep = p; TreeNode Nodeq = q; List<TreeNode> PNodes = new List<TreeNode>(); List<TreeNode> QNodes = new List<TreeNode>(); PNodes.Add(p); QNodes.Add(q); int nodeNumber = 0; while (PNodes.Count > 0) { if (Nodep.val != Nodeq.val) { return false; } if (Nodep.left != null) { if (Nodeq.left == null || Nodeq.left.val != Nodep.left.val) { return false; } PNodes.Add(Nodep.left); QNodes.Add(Nodeq.left); } else if (Nodeq.left != null) { return false; } if (Nodep.right != null) { if (Nodeq.right == null || Nodeq.right.val != Nodep.right.val) { return false; } PNodes.Add(Nodep.right); QNodes.Add(Nodeq.right); } else if (Nodeq.right != null) { return false; } nodeNumber++; if (nodeNumber >= PNodes.Count) { break; } Nodep = PNodes[nodeNumber]; Nodeq = QNodes[nodeNumber]; } return true; }