可变层数的多层嵌套遍历实现

可变层数的多层嵌套遍历实现

工作时遇到过一个视频拼接需求，需要支持多段素材的组合拼接。比如两段视频拼接，第一段视频集编号为[1,2]，第二段视频集编号有[3,4]，合并的结果为(1,3)(1,4)(2,3)(2,4)。当时使用的是循环的方式实现的，最近在leetcode刷题，发现了一个和该场景类似的题目:17.电话号码的字母组合。

题目描述

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

这里记录下两种实现。

深度优先遍历

使用了回溯的思想，每次找到一个遍历解后就回到上一层。

 String [] letterMap = {"","*", "abc", "def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    List<String> res = new ArrayList();
    public List<String> letterCombinations(String digits) {
        if(digits == null || digits.length() == 0) {
            return res;
        }
        dfs(digits, new StringBuilder(), 0);
        return res;
    }
    public void dfs(String digits, StringBuilder str, int index) {
    	// 拼接后的字符串长度等于数字串长度，说明深度到底了，不再继续递归
        if(index == digits.length()) {
            res.add(str.toString());
            return;
        }
        int ch = digits.charAt(index);
        int position = ch - '0';
        String strMapping = letterMap[position];
        for(int i = 0; i < strMapping.length();i++) {
            str.append(strMapping.charAt(i));
            // 遍历下一层
            dfs(digits,str, index+1);
            // 回溯
            str.deleteCharAt(str.length() - 1);
        }
    }

使用循环

使用一个数组存储每一层嵌套的遍历索引，每次找到一个解就更新最内层的循环的索引值，同时检查是否超过循环次数，超过了就更新更外层循环的索引值

private final String[] charMap = new String[]{"abc","def","ghj","jkl","mno","pqrs","tuv","wxyz"};
public List<String> letterCombinations(String digits) {
        List<String> result = new ArrayList<>();
        int length = digits.length();
        if (length == 0) {
            return result;
        }
        // 用来存储不定长遍历的索引值
        int[] indexs = new int[length];
        for(;;) {
            // 从内到外，更新多层循环的索引值
            for (int i = length - 1; i > 0; i--) {
                if (indexs[i] != charMap[digits.charAt(i) - '2'].length()) {
                    break;
                }
                indexs[i-1] ++;
                indexs[i] = 0;
            }
            if (indexs[0] >= charMap[digits.charAt(0) - '2'].length()) {
                break;
            }
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < length; i++) {
                builder.append(charMap[digits.charAt(i) - '2'].charAt(indexs[i]));
            }
            indexs[length-1] ++;
            result.add(builder.toString());
        }
        return result;
    }

比较

深度优先遍历的方式比较简介，但受限到栈帧数量的限制，数字串较长时会导致栈溢出。循环的方式没有这个限制，但是需要额外的空间存储遍历索引值等信息。