我辅助函数定义就是将你传给我的两个节点，进行连接。
采用前序遍历，然后需要把这两个节点各自的左右节点连接&&这一个节点的左和一个节点的有连接。

// 主函数
Node connect(Node root) {
    if (root == null) return null;
    connectTwoNode(root.left, root.right);
    return root;
}

// 辅助函数
void connectTwoNode(Node node1, Node node2) {
    if (node1 == null || node2 == null) {
        return;
    }
    /**** 前序遍历位置 ****/
    // 将传入的两个节点连接
    node1.next = node2;

    // 连接相同父节点的两个子节点
    connectTwoNode(node1.left, node1.right);
    connectTwoNode(node2.left, node2.right);
    // 连接跨越父节点的两个子节点
    connectTwoNode(node1.right, node2.left);
}

这个函数的定义是：以传给我的头节点的二叉树拉平成一个链表。

进行后序遍历

具体：把他的左右先进行拉平，然后把左树当做右树，左边为null，最后把原来的右树放到现在右树的下面。

// 定义：将以 root 为根的树拉平为链表
void flatten(TreeNode root) {
    // base case
    if (root == null) return;

    flatten(root.left);
    flatten(root.right);

    /**** 后序遍历位置 ****/
    // 1、左右子树已经被拉平成一条链表
    TreeNode left = root.left;
    TreeNode right = root.right;

    // 2、将左子树作为右子树
    root.left = null;
    root.right = left;

    // 3、将原先的右子树接到当前右子树的末端
    TreeNode p = root;
    while (p.right != null) {
        p = p.right;
    }
    p.right = right;
}

test函数的定义：返回给定的数组中的最大值new出的节点。

采用前序遍历，

public TreeNode constructMaximumBinaryTree(int[] nums) {
		return test(nums, 0, nums.length - 1);
    }

	public TreeNode test(int[] nums, int start, int end){
		if (start > end) {
			return null;
		}
		int index = start;
		int max = nums[start];
		for (int i = start + 1; i <= end; i++) {
			if (max < nums[i]) {
				max = nums[i];
				index = i;
			}
		}
		TreeNode node = new TreeNode(max);

		node.left = test(nums, start, index - 1);
		node.right = test(nums, index +1, end);
		return node;
	}

辅助函数的定义：通过给定的前序，中序数组找到根节点。

流程：根据前序遍历可以知道，根节点就是前序遍历的首位，根节点的下一位就是前序遍历数组的下一位，在通过中序遍历数组就可以确定是左右哪个节点。然后分开去求左右子树。

class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
		return test(preorder, 0, preorder.length -1 , inorder, 0 , inorder.length-1);
    }

	public TreeNode test(int[] preorder,int prestart, int preend, int[] inorder, int instart, int inend) {
		if (prestart > preend) {
			return null;
		}
		int index = 0;
		for (int i = instart; i <= inend; i++) {
			if (preorder[prestart] == inorder[i]) {
				index = i;
				break;
			}
		}
		TreeNode node = new TreeNode(preorder[prestart]);
		int size = index - instart;
		node.left = test(preorder, prestart + 1, size + prestart, inorder, instart, index -1);
		node.right = test(preorder, size +prestart + 1, preend, inorder, index + 1, inend);
		return node;
	}
}

和上一题原理相同。

根节点的遍历从后序遍历的末尾开始。

class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
		return build(inorder, 0, inorder.length-1, postorder, postorder.length - 1, 0);
    }

	public TreeNode build(int[] inorder,int instart, int inend, int[] postorder, int postend, int poststart) {
		if (postend < poststart) {
			return null;
		}
		int index = 0;
		for (int i = 0; i < inorder.length; i++) {
			if (postorder[postend] == inorder[i]) {
				index = i;
				break;
			}
		}
		int size = index - instart;
		TreeNode node = new TreeNode(postorder[postend]);
		node.left = build(inorder, instart, index - 1, postorder, poststart + size-1, poststart);
		node.right = build(inorder, index + 1, inend, postorder, postend - 1, poststart +size);

		return node;
	}
}

思考：我想要查看有没有重复的子树，首先我要获取到所有的子树，在获取的途中，进行查看是否已经获取过了，获取过了我就放到集合里。

如何获取一个子树呢？

获取自己下面的所有节点，在加上自己不就是一个子树了（所以用后序遍历）。然后放到集合里。

怎样把一个子树串联起来呢，->序列化，用字符串拼接。

class Solution {
    public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
        if (root == null) {
			return null;
		}
        findMap(root);
  
        return list;
    }
	Map<String, Integer> map = new HashMap<>();
    List<TreeNode> list = new ArrayList<>();

	public String findMap(TreeNode root){
		if (root == null) {
			return "#";
		}
		String s1 = findMap(root.left);
		String s2 = findMap(root.right);
		String s = root.val+"," + s1+"," + s2;
		if (map.containsKey(s)) {
			if (map.get(s) == 1) {
				list.add(root);
			}
			map.put(s, map.get(s) + 1);
		}else {
			map.put(s, 1);
		}
		return s;
	}
}

遇到任何递归型的问题，无非就是灵魂三问：

1、这个函数是干嘛的？

2、这个函数参数中的变量是什么的是什么？

3、得到函数的递归结果，你应该干什么？

TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    // base case
    if (root == null) return null;
    if (root == p || root == q) return root;

    TreeNode left = lowestCommonAncestor(root.left, p, q);
    TreeNode right = lowestCommonAncestor(root.right, p, q);
    // 情况 1
    if (left != null && right != null) {
        return root;
    }
    // 情况 2
    if (left == null && right == null) {
        return null;
    }
    // 情况 3
    return left == null ? right : left;
}

有点难理解。。。

因为只有一个根节点只能判断左右孩子的是否符合，所以需要一个辅助函数。

辅助函数定义：验证当前节点是否是大于min小于max。

public boolean isValidBST(TreeNode root) {
		return judge(root, null, null);
    }
	/**
	 * 要求：max.min > root.val > min.val
	 * @param root
	 * @param min
	 * @param max
	 * @return
	 */
	public boolean judge(TreeNode root, TreeNode min, TreeNode max) {
		if (root == null) {
			return true;
		}
		if (min != null && min.val >= root.val) {
			return false;
		}
		if (max != null && max.val <= root.val) {
			return false;
		}
		return judge(root.left, min, root) && judge(root.right, root, max);
	}

删除分为三种情况，1，要删除的节点是末尾节点。2，只有一个非空节点，3，有两个孩子。分别讨论。

第三种情况的时候：先找到要删除节点的右子树的最小值，记录下值，然后删掉，然后把值给要删除的节点。

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
		if (root == null) {
			return null;
		}
        if (root.val == key) {
			//删除 分为两种删除，在末尾直接删除，在中间(左右都存在和存在一个孩子)就要判断了
        	if (root.left == null && root.right == null) {
				return null;
			}
        	if (root.left == null || root.right == null) {
				if (root.left == null) {
					return root.right;
				}else {
					return root.left;
				}
			}
        	//左右孩子都存在
        	//首先找到右子树中最小的节点
        	TreeNode minNode = getMin(root.right);
        	//删除最小的节点
        	root.right = deleteNode1(root.right, minNode.val);
        	root.val = minNode.val;
		}else if(root.val > key) {
			root.left = deleteNode(root.left, key);
		}else {
			root.right = deleteNode(root.right, key);
		}
        return root;
    }

	public TreeNode getMin(TreeNode node) {
		if (node.left == null) {
			return node;
		}
		return getMin(node.left);
	}

	public TreeNode deleteNode1(TreeNode node, int val) {
		if (node == null) {
			return null;
		}
        if (node.val == val) {
			if (node.right != null) {
				return node.right;
			}
			return null;
		}else if(node.val > val) {
			node.left = deleteNode1(node.left, val);
		}
        return node;
	}
}

说明：使用辅助指针记录上一个节点和头结点。

class Solution {
    Node pre,head;
    public Node treeToDoublyList(Node root) {
        if(root == null){
            return null;
        }
        dfs(root);
        head.left = pre;
        pre.right = head;
        return head;
    }

    private void dfs(Node root) {
        if(root == null){
            return;
        }
        dfs(root.left);
        if (pre == null){
            head = root;
        }else{
            pre.right = root;
        }
        root.left = pre;
        pre = root;
        dfs(root.right);
    }
}

解析地址