public IList<IList<int>> LevelOrder(TreeNode root)
{
if (root == null)
return null;
List<IList<int>> level = new List<IList<int>>();
Queue<TreeNode> q = new Queue<TreeNode>();
q.Enqueue(root);
int length = q.Count;
while (length != 0)
{
List<int> list = new List<int>();
for (int i = 1; i <= length; i++)
{
TreeNode node = q.Dequeue();
list.Add(node.val);
if (node.left != null)
q.Enqueue(node.left);
if (node.right != null)
q.Enqueue(node.right);
}
if (list.Count != 0)
level.Add(list);
length = q.Count;
}
return level;
}
public bool IsSameTree(TreeNode p, TreeNode q)
{
if (p == null && q == null)
return true;
else if (p == null || q == null)
return false;
return (p.val == q.val) && IsSameTree(p.left, q.left) && IsSameTree(p.right,q.right);
}
private bool help(TreeNode node1, TreeNode node2)
{
if (node1 == null && node2 == null)
return true;
if (node1 == null || node2 == null)
return false;
return (node1.val == node2.val) && (help(node1.left, node2.right)) && (help(node1.right, node2.left));
}
//LeetCode 104:https://leetcode.com/problems/maximum-depth-of-binary-tree/
public int MaxDepth(TreeNode root)
{
if (root == null)
return 0;
int left = MaxDepth(root.left);
int right = MaxDepth(root.right);
return Math.Max(left,right)+1;
}
//可以看懂里面的逻辑，但是不是很理解为什么这样写，先放这里
public bool Inorder(TreeNode node)
{
if (node == null)
return true;
if (!Inorder(node.left)) return false;
if (pre != null && node.val <= pre.val) return false;
pre = node;
return Inorder(node.right);
}
public static void Main11()
{
TreeNode node1 = new TreeNode(2);
TreeNode node2 = new TreeNode(1);
TreeNode node3 = new TreeNode(3);
node1.left = node2;
node1.right = node3;
Convert(node1);
Console.ReadLine();
}
private TreeNode help(int[] nums, int begin, int end)
{
if (begin < end)
return null;
int mid = (begin + end) / 2;
TreeNode node = new TreeNode(nums[mid]);
node.right = help(nums, mid + 1, end);
node.left = help(nums, begin, mid - 1);
return node;
}
//模拟中序遍历构造二叉树
private TreeNode help(int begin,int end)
{
if (begin > end)//这里的判断很重要，跟数组很像
return null;
int mid = (begin + end) / 2;
TreeNode left=help(begin,mid-1);//按照中序遍历的顺序先构造左子树
TreeNode node = new TreeNode(current.val);
node.left = left;
current = current.next;
node.right = help(mid + 1, end);//再构造右子树
return node;
}
private TreeNode Make(int[] preorder, int[] inorder, int prebegin, int preend, int inbegin, int inend)
{
//递归结束条件
if (prebegin > preend)
return null;
int i = inbegin;
while (preorder[prebegin] != inorder[i])
i++;
TreeNode node = new TreeNode(inorder[i]);
node.left = Make(preorder, inorder, prebegin + 1, prebegin + i - inbegin, inbegin, i - 1);
node.right = Make(preorder, inorder, prebegin + i - inbegin + 1, preend, i + 1, inend);
return node;
}
private static TreeNode last = null; //代表链表最后一个节点
#endregion Fields
#region Methods
public static void Convert(TreeNode node)
{
if (node == null)
return;
if (node.left != null)
Convert(node.left);
//链表指向下一个节点使用left，指向上一个节点是用right
node.left = last;
if (last != null)
last.right = node;
last = node;
if (node.right != null)
Convert(node.right);
}
//相似的一道题，将一颗二叉树转成它的镜像，剑指offer面试题19题
public void MirrorRecursively(TreeNode head)
{
if (head == null)
return;
if (head.left == null && head.right == null)
return;
TreeNode temp = head.right;
head.left = head.right;
head.right = temp;
if (head.left != null)
MirrorRecursively(head.left);
if (head.right != null)
MirrorRecursively(head.right);
}
private int RootValue(TreeNode root, ref int Max)
{
if (root == null)
return 0;
int rootmax = root.val;
int left = RootValue(root.left, ref Max);
int right = RootValue(root.right, ref Max);
//求出以root为节点的最大值
rootmax = Math.Max(rootmax, root.val + left);
rootmax = Math.Max(rootmax, root.val + right);
//为什么不对！！！我知道了，root父亲的最大值不可能出现这种情况root.val + right + left，多画点图就明白了
Max = Math.Max(Math.Max(rootmax,Max), root.val + right + left);
//求到现在这个root节点为止的最大值
//Max = Math.Max(rootmax, Max);
return rootmax;
}
public void Flatten(TreeNode root)
{
if (root == null)
return;
if (last != null)
{
last.left = null;
last.right = root;
}
last = root;
TreeNode left = root.left;
TreeNode right = root.right;
if (left != null)
{
Flatten(left);
}
if (right != null)
{
Flatten(right);
}
}
public int MaxPathSum(TreeNode root)
{
int Max = root.val;
RootValue(root, ref Max);
return Max;
}
public bool IsValidBST(TreeNode root)
{
if (root == null)
return true;
return Inorder(root);
}
public bool IsSymmetric(TreeNode root)
{
if (root == null)
return false;
return help(root.left, root.right);
}
