乘风破浪：LeetCode真题_017_Letter Combinations of a Phone Number

乘风破浪：LeetCode真题_017_Letter Combinations of a Phone Number

一、前言

   如何让两个或者多个集合中的随机挑选的元素结合到一起，并且得到所有的可能呢？我们可能事先并不知道会用到哪几个集合，因此我们可以通过递归方法来解决。

二、Letter Combinations of a Phone Number

2.1 问题

2.2 分析和解决

     通过上面的题目，我们基本上可以理解题意了，但是我们要怎么去处理呢，这个时候就需要用到递归算法了。

public class Solution {
    private static final String[] KEYS = { "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" };

    public List<String> letterCombinations(String digits) {
        List<String> ret = new LinkedList<String>();
        combination("", digits, 0, ret);
        if(ret.get(0) == ""){
            ret.clear();
        }
        return ret;
    }

    private void combination(String prefix, String digits, int offset, List<String> ret)         {
        if (offset >= digits.length()) {
            ret.add(prefix);
            return;
        }
        String letters = KEYS[(digits.charAt(offset) - '0')];
        for (int i = 0; i < letters.length(); i++) {
            combination(prefix + letters.charAt(i), digits, offset + 1, ret);
        }
    }
}

     这里特别要注意，如果输入为空的情况下，我们的输出也必须为空，比如[]作为输入，[]也必须作为输出，而不是[""]。

     当然我们也可以看看不同的递归写法：

import java.util.LinkedList;
import java.util.List;

public class Solution {

    private String[] map = {
            "abc",
            "def",
            "ghi",
            "jkl",
            "mno",
            "pqrs",
            "tuv",
            "wxyz",
    };
    private List<String> result;    // 存储最终结果
    private char[] chars;           // 保存去掉0，1字符的结果
    private char[] curResult;       // 存储中间结果
    private int end = 0;            // 字符数组中的第一个未使用的位置
    private int handle = 0;         // 当前处理的是第几个字符数字

    /**
     * 题目大意
     * 给定一个数字串，返回数字上所有字符的所有组合，数字到字符的映射如上图所示。
     * 注意： 尽管上面的结果以字符顺序排列的，你可以以任何顺序返回结果。
     *
     * 解题思路
     * 一个数组保存数字和字的映射关用系，根据数字串的输入，找到对应的字符，组合结果。
     */
    public List<String> letterCombinations(String digits) {
        result = new LinkedList<>();

        if (digits != null && digits.length() > 0) {

            chars = digits.toCharArray();

            // 对字符串进行处理，去掉0和1
            // 找第一个0或者1的位置
            while (end < digits.length() && chars[end] != '0' && chars[end] != '1') {
                end++;
            }

            handle = end + 1;
            while (handle < chars.length) {
                if (chars[handle] != '0' && chars[handle] != '1') {
                    chars[end] = chars[handle];
                    end++;
                }
                handle++;
            }

            curResult = new char[end];
            // while结束后，end为有效字符的长度
            handle = 0; // 指向第一个有效字符的位置

            letterCombinations();
        }
        return result;
    }

    private void letterCombinations() {
        if (handle >= end) {
            result.add(new String(curResult));
        } else {
            int num = chars[handle] - '2';
            for (int i = 0; i < map[num].length(); i++) {
                curResult[handle] = map[num].charAt(i);
                handle++;
                letterCombinations();
                handle--;
            }
        }
    }
}

     上面的递归也是非常有意思的，大家可以仔细的玩味一下。

       接下来我们再看一种自己构建队列的方式来处理的方法：

import java.util.*;
class Solution {
    public List<String> letterCombinations(String digits) {
        LinkedList<String> result = new LinkedList<>();
        if(digits.isEmpty())
            return result;
        String[] mapping = new String[] {"0", "1", "abc","def","ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        result.add("");
        
        while(result.peek().length() != digits.length()) {
            String remove = result.remove();
            String map = mapping[digits.charAt(remove.length())-'0'];

            
            for(char c : map.toCharArray()) {
                result.addLast(remove + c);
            }
            
            
        }
        
        return result;
    }
}

      在这里定义了一个result队列，首先看看当前的指针所对应的元素的长度有没有达到给定的字符串的长度：

result.peek().length()

     如果没有则继续，如果已经达到了，那么已经完成了遍历。

     其次，最开始的元素出队列，它的长度就是下一个需要选择的给定字符串的位置，因此取出对应的数字，找到对应的字符串，然后将弹出的字符串和这些字符串拼接，入队列。

     String map = mapping[digits.charAt(remove.length())-'0'];

     for(char c : map.toCharArray()) {
         result.addLast(remove + c);
     }

       依次这样遍历，知道满足条件，这样就得到了结果。

       我们举一个例子：

     同样的其实可以转换成堆栈来做，道理是一样的。

三、总结

    当我们遇到问题的时候，不能解决的情况下一定要想到递归，动态规划这些方法，不然的话我们将无从做起，另外递归也有许多的技巧，都是可以转换成堆栈或者队列来解决的。