数据结构和算法十六

剑指 Offer 34. 二叉树中和为某一值的路径

题目：输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。
示例:
给定如下二叉树，以及目标和 target = 22，

                  5
                 / \
                4   8
               /   / \
              11  13  4
             /  \    / \
            7    2  5   1
    返回:

    [
       [5,4,11,2],
       [5,8,4,5]
    ]

提示：
         节点总数 <= 10000

/*解题思路：
本问题是典型的二叉树方案搜索问题，使用回溯法解决，其包含 先序遍历 + 路径记录 两部分。
先序遍历： 按照 “根、左、右” 的顺序，遍历树的所有节点。
路径记录： 在先序遍历中，记录从根节点到当前节点的路径。当路径为 ① 根节点到叶节点形成的路径 且 ② 各节点值的和等于目标值 sum 时，将此路径加入结果列表。

算法流程：
	pathSum(root, sum) 函数：
		初始化： 结果列表 res ，路径列表 path 。
		返回值： 返回 res 即可。
	recur(root, tar) 函数：
		递推参数：当前节点root，当前目标值 tar 。
		终止条件：若节点 root 为空，则直接返回。
		递推工作：
			路径更新： 将当前节点值 root.val 加入路径 path ；
			目标值更新：tar=tar-root.val（即目标值tar从sum减至0）；
			路径记录： 当 ① root 为叶节点 且 ② 路径和等于目标值 ，则将此路径 path 加入 res 。
			先序遍历： 递归左 / 右子节点。
			路径恢复： 向上回溯前，需要将当前节点从路径 path 中删除，即执行 path.pop() 。
复杂度分析：
	时间复杂度 O(N):N为二叉树的节点数，先序遍历需要遍历所有节点。
	空间复杂度 O(N):最差情况下，即树退化为链表时，path 存储所有树节点，使用O(N)额外空间。
*/
class Method{
    LinkedList<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>(); 
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        recur(root, sum);
        return res;
    }
    void recur(TreeNode root, int tar) {
        if(root == null) return;
        path.add(root.val);
        tar -= root.val;
        if(tar == 0 && root.left == null && root.right == null)
            res.add(new LinkedList(path));
        recur(root.left, tar);
        recur(root.right, tar);
        path.removeLast();
    }
}

剑指 Offer 36. 二叉搜索树与双向链表

题目：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。

为了让您更好地理解问题，以下面的二叉搜索树为例：

我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。
下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。

特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。

/*解题思路：
本解法基于性质：二叉搜索树的中序遍历为递增序列。
将二叉搜索树转换成一个 “排序的循环双向链表” ，其中包含三个要素：
1、排序链表：节点应从小到大排序，因此应使用 中序遍历 “从小到大”访问树的节点。
2、双向链表：在构建相邻节点的引用关系时，设前驱节点pre和当前节点cur，不仅应构建pre.right=cur，也应构建 cur.left=pre。
3、循环链表：设链表头节点head和尾节点tail，则应构建head.left=tail和tail.right=head。
*/

中序遍历 为对二叉树作 “左、根、右” 顺序遍历，递归实现如下：

// 打印中序遍历
void dfs(Node root) {
    if(root == null) return;
    dfs(root.left); // 左
    System.out.println(root.val); // 根
    dfs(root.right); // 右
}

根据以上分析，考虑使用中序遍历访问树的各节点 cur ；并在访问每个节点时构建 cur 和前驱节点 pre 的引用指向；中序遍历完成后，最后构建头节点和尾节点的引用指向即可。

/*算法流程：
dfs(cur): 递归法中序遍历；
1、终止条件： 当节点 cur 为空，代表越过叶节点，直接返回；
2、递归左子树，即 dfs(cur.left) ；
3、构建链表：
	（1）当pre为空时：代表正在访问链表头节点，记为 head ；
	（2）当pre不为空时：修改双向节点引用，即 pre.right = cur ， cur.left = pre ；
	（3）保存cur：更新 pre = cur ，即节点 cur 是后继节点的 pre ；
4、递归右子树，即 dfs(cur.right) ；
treeToDoublyList(root)：
1、特例处理：若节点root为空，则直接返回；
2、初始化：空节点pre；
3、转化为双向链表：调用dfs(root) ；
4、构建循环链表：中序遍历完成后，head 指向头节点，pre指向尾节点，因此修改head和pre的双向节点引用即可；
5、返回值：返回链表的头节点head即可；

复杂度分析：
	时间复杂度O(N)：N为二叉树的节点数，中序遍历需要访问所有节点。
	空间复杂度O(N)：最差情况下，即树退化为链表时，递归深度达到N,系统使用O(N)栈空间。
*/
class Method{
    Node pre, head;
    public Node treeToDoublyList(Node root) {
        if(root == null) return null;
        dfs(root);
        head.left = pre;
        pre.right = head;
        return head;
    }
    void dfs(Node cur) {
        if(cur == null) return;
        dfs(cur.left);
        if(pre != null) pre.right = cur;
        else head = cur;
        cur.left = pre;
        pre = cur;
        dfs(cur.right);
    }
}

总结：

      光阴似箭，日月如梭！不得不感叹这时间过的是如此之快！5月已经悄悄地溜走了2天，仿佛昨日还在眼前，今日又已经不在，明日又即将展现在眼前！
      如果累了，就放下手中的事务去繁华的地方看一看，然后再对比自己看一看，还有什么理由说累呢？身边的人都在努力，还有什么理由选择后退呢？加油吧！
      最后，愿我们都能在各行各业中能够取得不同的成就！能够用自身的所学知识为国家贡献出自己的一份力量！一起加油！