17. 电话号码的字母组合

代码随想录

17. 电话号码的字母组合

46. 全排列

思路：
1，字母和数字的映射
采用一个数组来映射

String[10] numString = {
		"", // 0
   	 "", // 1
    "abc", // 2
    "def", // 3
    "ghi", // 4
    "jkl", // 5
    "mno", // 6
    "pqrs", // 7
    "tuv", // 8
    "wxyz", // 9
}

回溯法解决n个循环的问题

由图可知，遍历的深度，就是输入数据的长度，叶子节点就是我们要收集的结果，
输出[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]。

然后开始回溯三部曲：
需要一个字符串来接收叶子节点的结果
每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以选择高效的StringBuilder

//先把每次的结果，放到temp中，然后再最后放到list中
//这两个变量，我依然定义为全局
StringBuilder temp = new StringBuilder();

再来看参数，参数指定是有题目中给的digits，然后还有一个参数int index
index，这个不是77中的startindex了，而是用来记录遍历第几个数字了 ，用来遍历digits的
同时，index也表示树的深度

//目前代码
List<String> list;
StringBuilder temp;
//digits，用来告诉我们，要回溯的字符串，index，用来记录遍历第几个数字了
public void backtracking(String digits,int index){
	
}

确认终止条件
举例子，
例如，输入用例，“23,”其终止条件，递归两层，

if(index==digits.length()){
	list.add(temp.toString());
	return;
}

//确认单层递归逻辑
首先要取到index指向的数字，然后，找到对应的字符集
然后for循环处理这个字符集

class Solution {

    //设置全局列表存储最后的结果
    List<String> list = new ArrayList<>();

    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0) {
            return list;
        }
        //初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
        //将这个设置为全局变量，那么就不用在回溯中添加这个参数了
        String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        //迭代处理
        backTracking(digits, numString, 0);
        return list;

    }

    //每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuild
    StringBuilder temp = new StringBuilder();

    //比如digits如果为"23",num 为0，则str表示2对应的 abc
    public void backTracking(String digits, String[] numString, int num) {
        //遍历全部一次记录一次得到的字符串
        if (num == digits.length()) {
            list.add(temp.toString());
            return;
        }
        //str 表示当前num对应的字符串
        String str = numString[digits.charAt(num) - '0'];
        for (int i = 0; i < str.length(); i++) {
            temp.append(str.charAt(i));
            //c
            backTracking(digits, numString, num + 1);
            //剔除末尾的继续尝试
            temp.deleteCharAt(temp.length() - 1);
        }
    }
}

class Solution {

    String[] numString={
        "",     //0
        "",     //1
        "abc",     //2
        "def",     //3
        "ghi",     //4
        "jkl",     //5
        "mno",     //6
        "pqrs",     //7
        "tuv",     //8
        "wxyz"      //9
    };

    public List<String> letterCombinations(String digits) {
        if(digits==null||digits.length()==0){
            return res;
        }
        //回溯解决问题
        backTracking(digits,numString,0);
        return res;
    }
    //定义一个接收结果的
    List<String> res = new LinkedList<>();
    //每次的结果，用stringbuilder来接收
    StringBuilder path = new StringBuilder();

    //递归的深度=字符串的长度
    //要操作的数组，递归的深度，for的宽度,num是初始操作节点序号
    public void backTracking(String digits,String[] numString,int num){
        //递归终止条件
        // if(path.length() == digits.length()){
        //     res.add(path.toString());
        //     return;
        // }
          if(num == digits.length()){
            res.add(path.toString());
            return;
        }
        //单层递归逻辑
        //for循环要确定其宽度，就是传入的digits的个数
        //我还想双层for循环呢，先确定第一层的for循环
        String str = numString[digits.charAt(num)-'0'];
        for(int i=0;i<str.length();i++){
            //对第一层进行操作
            path.append(str.charAt(i));
            //开始对第二层进行操作
            backTracking(digits,numString,num+1);
            //返回上一层，同时要返回上一步操作
            path.deleteCharAt(path.length()-1);
        }
    }

}

能定义为全局变量，尽量定义为全局的，而不是放到参数中，比如numString

class Solution {

    String[] numString={
        "",     //0
        "",     //1
        "abc",     //2
        "def",     //3
        "ghi",     //4
        "jkl",     //5
        "mno",     //6
        "pqrs",     //7
        "tuv",     //8
        "wxyz"      //9
    };

    public List<String> letterCombinations(String digits) {
        if(digits==null||digits.length()==0){
            return res;
        }
        //回溯解决问题
        backTracking(digits,0);
        return res;
    }
    //定义一个接收结果的
    List<String> res = new LinkedList<>();
    //每次的结果，用stringbuilder来接收
    StringBuilder path = new StringBuilder();

    //递归的深度=字符串的长度
    //要操作的数组，递归的深度，for的宽度,num是初始操作节点序号
    public void backTracking(String digits,int num){
        //递归终止条件
        // if(path.length() == digits.length()){
        //     res.add(path.toString());
        //     return;
        // }
          if(num == digits.length()){
            res.add(path.toString());
            return;
        }
        //单层递归逻辑
        //for循环要确定其宽度，就是传入的digits的个数
        //我还想双层for循环呢，先确定第一层的for循环
        String str = numString[digits.charAt(num)-'0'];
        for(int i=0;i<str.length();i++){
            //对第一层进行操作
            path.append(str.charAt(i));
            //开始对第二层进行操作
            backTracking(digits,num+1);
            //返回上一层，同时要返回上一步操作
            path.deleteCharAt(path.length()-1);
        }
    }

}