回溯法

回溯法

1.树的遍历

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

示例:
给定如下二叉树，以及目标和 target = 22，

          5
         / \
        4   8
       /   / \
      11  13  4
     /  \    / \
    7    2  5   1

class Solution {
    List<List<Integer>> lists=new ArrayList<List<Integer>>();
    List<Integer> list=new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {
                     preorder(root,target);
                     return lists;
    }
    public void preorder(TreeNode root,int target){
            if(root==null){
                return;
            }
            target=target-root.val;
            list.add(root.val);
            if(target==0&&root.left==null&&root.right==null){
                lists.add(new ArrayList<>(list));
            }
            preorder(root.left,target);
            preorder(root.right,target);
            list.remove(list.size()-1);
    }
}

2.字符串的遍历

输入一个字符串，打印出该字符串中字符的所有排列。

你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]
输入：s = "aab"
输出：["aab","aba","baa"]

class Solution {
     char[]c;
     List<String> str=new ArrayList<String>();
     StringBuilder builder=new StringBuilder();
     public String[] permutation(String s) {
            c=s.toCharArray();
            dfs(0);
            return str.toArray(new String[str.size()]);
    }
    public void dfs(int x){
            if(x==c.length){
                str.add(builder.toString());
                return;
            }
            HashSet<Character> set=new HashSet<>();
            for(int i=x;i<c.length;i++){
                if(set.contains(c[i]))
                {continue;}
                set.add(c[i]);
                swap(x,i);
                builder.append(c[x]);
                dfs(x+1);
                builder.deleteCharAt(builder.length()-1);
                swap(x,i);
            }
    }
    public void swap(int i,int j) {
        char temp=c[i];
        c[i]=c[j];
        c[j]=temp;
    }
}