二叉树剪枝之回溯的应用

前言

回溯操作对于二叉树非常重要，除此之外，对于单向链表也很重要，而它的思想可以用后进先出的栈来替换，更灵活的完成相应的操作。

一、案例

二、题解

package com.xhu.offer.offerII;

//二叉树剪枝
public class PruneTree {
    //回溯+左右为null+自己的值为0，返回以此作为子树的结果来交给父节点取删除。
    //总结：二叉树叶子节点的左右空节点很重要，它是能将二叉树当成递归操作必不可少的一部分，考虑进去才能完成递归，特别是回溯操作。
    public TreeNode pruneTree(TreeNode root) {
        if (root == null) return null;

        TreeNode left = pruneTree(root.left);
        TreeNode right = pruneTree(root.right);
        if (left == null) root.left = null;
        if (right == null) root.right = null;
        if (left == null && right == null && root.val == 0) return null;

        return root;
    }

    // Definition for a binary tree node.
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

}

总结

1）注意回溯关联二叉树+叶节点的左右节点一起做统一处理，回溯关联单向链表+栈更灵活的替代回溯。
2）二叉树叶子节点的左右空节点很重要，它是能将二叉树当成递归操作必不可少的一部分，考虑进去才能完成递归，特别是回溯操作。

参考文献

[1] LeetCode 原题

附录

当要求二叉树每条路径的相关问题时，也是回溯的经典应用，遇到叶子节点就返回路径Collection，然后回溯时左右路径collection合并，作为该子树的路径collection。

package com.xhu.offer.offerII;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//从根节点到叶节点的路径数字之和
public class SumNumbers {
    //回溯返回子树的各条路径+左右子树路径合并以后就是一家人向上走一条路了。
    public int sumNumbers(TreeNode root) {
        List<int[]> cache = recursion(root);
        int res = 0;
        Iterator<int[]> iterator = cache.iterator();
        while (iterator.hasNext()) {
            res += iterator.next()[0];
        }
        return res;
    }

    private List<int[]> recursion(TreeNode root) {
        if (root.left == null && root.right == null) {
            List<int[]> r = new ArrayList<>();
            r.add(new int[]{root.val, 1});
            return r;
        }
        List<int[]> left = new ArrayList<>(), right = left;
        if (root.left != null) {
            left = recursion(root.left);
        }

        if (root.right != null) {
            right = recursion(root.right);
        }
        List<int[]> r = new ArrayList<>(left);
        r.addAll(right);
        Iterator<int[]> iterator = r.iterator();
        while (iterator.hasNext()) {
            int[] t = iterator.next();
            t[0] = (int) (t[0] + Math.pow(10, t[1]++) * root.val);
        }

        return r;
    }

    // Definition for a binary tree node.
    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode() {
        }

        TreeNode(int val) {
            this.val = val;
        }

        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

}