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