LeetCode 17. 电话号码的字母组合（C、C++、python）

最新推荐文章于 2025-06-03 18:07:49 发布
最新推荐文章于 2025-06-03 18:07:49 发布
阅读量1.2k 收藏 4
点赞数
CC 4.0 BY-SA版权
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_27060423/article/details/83420141
本文介绍了一种将数字字符串转换为可能的字母组合的算法，适用于电话按键等场景。通过递增的方式，算法生成所有可能的组合，适用于多种编程语言如C、C++和Python。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例:

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

说明:
尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

C

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
char** letterCombinations(char* digits, int* returnSize) 
{
    int n=strlen(digits);
    if(n==0)
    {
        *returnSize=0;
        return NULL;
    }
    int count=1;
    for(int i=0;i<n;i++)
    {
        if(digits[i]=='7' || digits[i]=='9')
        {
            count*=4;
        }
        else
        {
            count*=3;
        }
    }
    char** res=(char**)malloc(sizeof(char*)*count);
    for(int i=0;i<count;i++)
    {
        res[i]=(char*)malloc(sizeof(char)*n);
    }
    int k=0;
    int row=1;
    for(int i=0;i<n;i++)
    {
        switch(digits[i])
        {
            case '2':
                for(int j=0;j<row;j++)
                {
                    strcpy(res[j+row],res[j]);
                    strcpy(res[j+2*row],res[j]);
                }
                for(int j=0;j<row;j++)
                {
                    res[j][k]='a';
                    res[j+row][k]='b';
                    res[j+2*row][k]='c';
                }
                k++;
                row*=3;
                break;
            case '3':
                for(int j=0;j<row;j++)
                {
                    strcpy(res[j+row],res[j]);
                    strcpy(res[j+2*row],res[j]);
                }
                for(int j=0;j<row;j++)
                {
                    res[j][k]='d';
                    res[j+row][k]='e';
                    res[j+2*row][k]='f';
                }
                k++;
                row*=3;
                break;
            case '4':
                for(int j=0;j<row;j++)
                {
                    strcpy(res[j+row],res[j]);
                    strcpy(res[j+2*row],res[j]);
                }
                for(int j=0;j<row;j++)
                {
                    res[j][k]='g';
                    res[j+row][k]='h';
                    res[j+2*row][k]='i';
                }
                k++;
                row*=3;
                break;
            case '5':
                for(int j=0;j<row;j++)
                {
                    strcpy(res[j+row],res[j]);
                    strcpy(res[j+2*row],res[j]);
                }
                for(int j=0;j<row;j++)
                {
                    res[j][k]='j';
                    res[j+row][k]='k';
                    res[j+2*row][k]='l';
                }
                k++;
                row*=3;
                break;
            case '6':
                for(int j=0;j<row;j++)
                {
                    strcpy(res[j+row],res[j]);
                    strcpy(res[j+2*row],res[j]);
                }
                for(int j=0;j<row;j++)
                {
                    res[j][k]='m';
                    res[j+row][k]='n';
                    res[j+2*row][k]='o';
                }
                k++;
                row*=3;
                break;
            case '7':
                for(int j=0;j<row;j++)
                {
                    strcpy(res[j+row],res[j]);
                    strcpy(res[j+2*row],res[j]);
                    strcpy(res[j+3*row],res[j]);
                }
                for(int j=0;j<row;j++)
                {
                    res[j][k]='p';
                    res[j+row][k]='q';
                    res[j+2*row][k]='r';
                    res[j+3*row][k]='s';
                }
                k++;
                row*=4;
                break;
            case '8':
                for(int j=0;j<row;j++)
                {
                    strcpy(res[j+row],res[j]);
                    strcpy(res[j+2*row],res[j]);
                }
                for(int j=0;j<row;j++)
                {
                    res[j][k]='t';
                    res[j+row][k]='u';
                    res[j+2*row][k]='v';
                }
                k++;
                row*=3;
                break;
            case '9':
                for(int j=0;j<row;j++)
                {
                    strcpy(res[j+row],res[j]);
                    strcpy(res[j+2*row],res[j]);
                    strcpy(res[j+3*row],res[j]);
                }
                for(int j=0;j<row;j++)
                {
                    res[j][k]='w';
                    res[j+row][k]='x';
                    res[j+2*row][k]='y';
                    res[j+3*row][k]='z';
                }
                k++;
                row*=4;
                break;            
        }
    }
    for(int i=0;i<count;i++)
    {
        res[i][k]='\0';
    }
    *returnSize=count;
    return res;
}

C++

class Solution {
public:
    vector<string> letterCombinations(string digits) 
    {
        int n=digits.length();
        vector<string> ans;
        if(n==0)
        {
            return ans;
        }
        vector<string> res{""};
        for(int i=0;i<n;i++)
        {
            int m=res.size();
            switch(digits[i])
            {
                case '2':
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res[j]+='a';
                        res[j+m]+='b';
                        res[j+m*2]+='c';
                    }
                    break;
                case '3':
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res[j]+='d';
                        res[j+m]+='e';
                        res[j+m*2]+='f';
                    }
                    break;
                case '4':
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res[j]+='g';
                        res[j+m]+='h';
                        res[j+m*2]+='i';
                    }
                    break;
                case '5':
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res[j]+='j';
                        res[j+m]+='k';
                        res[j+m*2]+='l';
                    }
                    break;
                case '6':
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res[j]+='m';
                        res[j+m]+='n';
                        res[j+m*2]+='o';
                    }
                    break;
                case '7':
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res[j]+='p';
                        res[j+m]+='q';
                        res[j+m*2]+='r';
                        res[j+m*3]+='s';
                    }
                    break;
                case '8':
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res[j]+='t';
                        res[j+m]+='u';
                        res[j+m*2]+='v';
                    }
                    break;
                case '9':
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res.push_back(res[j]);
                    }
                    for(int j=0;j<m;j++)
                    {
                        res[j]+='w';
                        res[j+m]+='x';
                        res[j+m*2]+='y';
                        res[j+m*3]+='z';
                    }  
                    break;
            }            
        }
        return res;        
    }
};

python

class Solution:
    def letterCombinations(self, digits):
        """
        :type digits: str
        :rtype: List[str]
        """
        n=len(digits)
        res=['']
        if n==0:
            return []
        for i in range(0,n):
            m=len(res)
            if digits[i]=='2':
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res[j]+='a'
                    res[j+m]+='b'
                    res[j+m*2]+='c'
            if digits[i]=='3':
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res[j]+='d'
                    res[j+m]+='e'
                    res[j+m*2]+='f'   
            if digits[i]=='4':
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res[j]+='g'
                    res[j+m]+='h'
                    res[j+m*2]+='i'
            if digits[i]=='5':
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res[j]+='j'
                    res[j+m]+='k'
                    res[j+m*2]+='l'
            if digits[i]=='6':
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res[j]+='m'
                    res[j+m]+='n'
                    res[j+m*2]+='o'
            if digits[i]=='7':
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res[j]+='p'
                    res[j+m]+='q'
                    res[j+m*2]+='r'
                    res[j+m*3]+='s'
            if digits[i]=='8':
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res[j]+='t'
                    res[j+m]+='u'
                    res[j+m*2]+='v'
            if digits[i]=='9':
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res.append(res[j])
                for j in range(0,m):
                    res[j]+='w'
                    res[j+m]+='x'
                    res[j+m*2]+='y'
                    res[j+m*3]+='z'
        return res

 

leetcode: 17. 电话号码的字母组合
uncle_ll的博客
07-22 862
给定一个仅包含数字2-9的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。给出数字到字母的映射如下（与电话按键相同）。注意1不对应任何字母。来源力扣（LeetCode）
题17. 电话号码的字母组合
漠宸离若的博客
08-26 221
C++ class Solution { public: vector<string> letterCombinations(string digits) { vector<string> ret; if(digits.size()==0) return ret; vector<string> dict = {"abc", "def", "ghi",...
【LeetCode】 电话号码的字母组合 [C++]
ly_6699的博客
03-16 1342
题目描述 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 已知数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例： 输入：“23” 输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]. 解题思路： 1.若输入的字符串为空则直接返回。 if(index==digits.size()) ...
【C语言】Leetcode 17. 电话号码的字母组合
weixin_43744788的博客
04-05 1276
解题思路： 1、电话号码使用一个hash表，直接通过hash表格，得到数字对应的字符已经长度。 2、通过数字的个数digitsLen，求出实际的输出的字符串数组的长度*returnSize； 3、数字长度循环，然后通过j的循环，通过每个数字将相关的字符遍历一遍。越往后的interval越小。 res[j][i] = g_hash[digits[i] - ‘0’].c[j / interval % ...
leecode算法实战（5-31）
最新发布
m0_73815461的博客
06-03 195
题解给出另一种思路，对于pop操作和peek操作，可以不将栈B返回到栈A。但是这样的操作会加入额外的判断，有利有弊吧，两者均可。首先的操作肯定是使用.对原字符串进行分割，得到若干子数组，然后将两数组补成相同长度，缺省补0。对于pop操作，我们先将栈A的元素全部加入到栈B，然后返回栈B的第一个元素并删除，再将栈B的元素返回栈A。栈和队列的关键区别就是先入先出还是先入后出，我们考虑使用两个栈实现队列。分别命名为栈A和栈B。递归的代码量虽然不多，但是想清楚逻辑是有难度的，主要是return左边部分还是右半部分。
C++编程-电话号码的字母组合
weixin_43979090的博客
04-25 1012
题目： 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例 1： 输入：digits = “23” 输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”] 示例 2： 输入：digits = “” 输出：[] 示例 3： 输入：digits = “2” 输出：[“a”,“b”,“c”] 提示： 0 <= digits.length &lt
【LeetCode】-- 17.电话号码的字母组合
局部变量和全局变量
06-10 876
给定一个仅包含数字2-9的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。给出数字到字母的映射如下（与电话按键相同），注意 1 不对应任何字母
leetcode-17-电话号码的字母组合
m0_49293816的博客
10-18 381
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。 > 注意 1 不对应任何字母。 示例: 输入："23" (2: abc 3: def) 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]. 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-numb
代码随想录算法训练营Day25 | 216.组合总和III、17.电话号码的字母组合 | Python | 个人记录向
Python基本算法
04-27 933
回溯算法：216.组合总和III、17.电话号码的字母组合。
【LeetCode每日一题】——17.电话号码的字母组合
IronmanJay
10-03 1223
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
电话号码的字母组合 回溯＆DFS和BFS 18岁 4和 两个指针 19 从列表末尾删除第N个节点 链表 20 有效括号 堆叠与排队 21岁 合并两个排序列表 链表 22 产生括号 回溯＆DFS和BFS 23 合并k个排序列表 链表 24 成对...
17.电话号码的字母组合
xxylllw
12-02 290
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入：“23” 输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]. 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number 著作权归领扣网络所有。商业转载请联系官方授权，非
LeetCode-17-电话号码的字母组合(C)
asd123pwj的博客
10-17 553
文章首发及后续更新：http://mwhls.top/634.html 新的更新内容请到mwhls.top查看。 如果没有图片请到上方的文章首发页面查看。 这算是我第一次能正常分配二级指针内存的题了。 题目 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入："23"输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "
电话号码的字母组合
KobeSacre的博客
05-30 161
电话号码的字母组合 题目： 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例 1： 输入：digits = “23” 输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”] 示例 2： 输入：digits = “” 输出：[] 示例 3： 输入：digits = “2” 输出：[“a”,“b”,“c”] 解题思路：先用list保存对应数字的
lc17: 电话号码的字母组合
LYB的博客
09-07 361
lc17: 电话号码的字母组合回溯代码复杂度分析 回溯 首先用哈希表将数字与对应的字母映射起来，然后进行回溯操作。 回溯可找到所有的可行解，如果发现一个解不可行，则舍弃。每个数字对应的字母都可能进入字母组合，所以直接穷举所有的解即可。 回溯过程中维护一个combination字符串，表示已有的字符排列，初始为空，每次取电话号码的一位数字，从哈希表中获得该数字对应的所有字母，将其中一个字母插入到combination后，然后继续处理电话号码的后一位数字，直到处理完所有的digit，即得到一个完整的字母排列，然
LeetCode第 17 题：电话号码的字母组合(C++)
zj
08-01 465
17. 电话号码的字母组合 - 力扣（LeetCode） 这题，好像就只能不停地枚举了。。。 class Solution { public: unordered_map<char, string> map = {{'2', "abc"}, {'3', "def"}, {'4', "ghi"}, {'5', "jkl"}, {'6', "mno"}, {'7', "pqrs"}, {'8', "tuv"}, {'9', "wxyz"}}; vector<st
【LeetCode】17. 电话号码的字母组合 (C++)
rabbitsockx的博客
12-21 635
原题地址：https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/submissions/ 题目描述： 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入："23" 输出：["ad", "ae", ...
力扣(LeetCode)17. 电话号码的字母组合(C++)
墨染
11-19 614
【墨染】回溯。图解。
Leetcode：17. 电话号码的字母组合（C++）
Cosmoshhhyyy的博客
01-20 1222
给定一个仅包含数字2-9的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。
LeetCode算法题解：C++与Python实现技巧
17. 电话号码的字母组合（回溯＆DFS和BFS）：这个问题通常需要遍历电话按键的所有可能字符组合，并使用深度优先搜索（DFS）或广度优先搜索（BFS）算法。 18. 4和（两个指针）：与3总和类似的问题，但这里是求和为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值