【C++算法】64.字符串_字符串相乘

---

题目链接：

43. 字符串相乘

---

题目描述：

---

解法

解法一：模拟列竖式运算

细节：

1. 高位相乘要补上0
2. 将字符串逆序
3. 处理前导0，例如0x123=0，而不是000
4. 注意计算结果的顺序

解法二：对解法一的优化：无进位相乘然后相加，最后处理进位

例如：123x456

两个数字的乘积最多有m+n位，但由于未处理进位，所以是m+n-1位

---

C++ 算法代码：

class Solution 
{
public:string multiply(string n1, string n2) {// 大整数乘法算法// 基本思路：先不考虑进位，按位相乘并累加，最后统一处理进位int m = n1.size(), n = n2.size();  // 获取两个字符串的长度// 先将字符串反转，使低位在左边，便于从低位开始处理reverse(n1.begin(), n1.end());reverse(n2.begin(), n2.end());// 创建临时数组存储每位相乘的结果// 两个数字的乘积最多有m+n位，但由于未处理进位，所以是m+n-1位vector<int> tmp(m + n - 1);// 步骤1: 无进位相乘后相加// 模拟手算乘法过程，但不处理进位for(int i = 0; i < m; i++)for(int j = 0; j < n; j++)// n1[i]和n2[j]相乘的结果累加到tmp[i+j]位置// 这里i+j表示最终结果中的位置：第i位乘以第j位的结果应该放在第i+j位tmp[i + j] += (n1[i] - '0') * (n2[j] - '0');// 步骤2: 处理进位int cur = 0;  // 当前处理的位置int t = 0;    // 进位值string ret;   // 存储最终结果// 处理所有位置和最终进位while(cur < m + n - 1 || t){// 如果还有位置未处理，加上当前位置的值if(cur < m + n - 1) t += tmp[cur++];// 添加当前位的结果（对10取余）ret += t % 10 + '0';// 计算进位值t /= 10;}// 步骤3: 处理前导零// 注意：由于结果是反向存储的，所以前导零在结果字符串的末尾while(ret.size() > 1 && ret.back() == '0') ret.pop_back();// 将结果反转回正常顺序reverse(ret.begin(), ret.end());return ret;}
};

---

图解

例如：n1 = "123" 乘以 n2 = "45"

步骤1：预处理

m = n1.size() = 3
n = n2.size() = 2反转n1: "123" -> "321"
反转n2: "45" -> "54"创建tmp数组，长度为m+n-1 = 4: [0, 0, 0, 0]

步骤2：无进位相乘

遍历两个数的每一位，将乘积累加到对应位置：

i=0, j=0: n1[0]=3, n2[0]=5, 相乘=15, 累加到tmp[0+0]=tmp[0]
tmp = [15, 0, 0, 0]i=0, j=1: n1[0]=3, n2[1]=4, 相乘=12, 累加到tmp[0+1]=tmp[1]
tmp = [15, 12, 0, 0]i=1, j=0: n1[1]=2, n2[0]=5, 相乘=10, 累加到tmp[1+0]=tmp[1]
tmp = [15, 22, 0, 0]i=1, j=1: n1[1]=2, n2[1]=4, 相乘=8, 累加到tmp[1+1]=tmp[2]
tmp = [15, 22, 8, 0]i=2, j=0: n1[2]=1, n2[0]=5, 相乘=5, 累加到tmp[2+0]=tmp[2]
tmp = [15, 22, 13, 0]i=2, j=1: n1[2]=1, n2[1]=4, 相乘=4, 累加到tmp[2+1]=tmp[3]
tmp = [15, 22, 13, 4]

现在tmp数组包含了所有位相乘的结果（未处理进位）：[15, 22, 13, 4]

步骤3：处理进位

从低位开始处理tmp数组中的每个元素，处理进位：

初始：cur = 0, t = 0, ret = ""循环1:cur = 0, t += tmp[0] = 15, cur++ret += 15 % 10 + '0' = '5't = 15 / 10 = 1当前ret = "5"循环2:cur = 1, t += tmp[1] = 1 + 22 = 23, cur++ret += 23 % 10 + '0' = '3't = 23 / 10 = 2当前ret = "53"循环3:cur = 2, t += tmp[2] = 2 + 13 = 15, cur++ret += 15 % 10 + '0' = '5't = 15 / 10 = 1当前ret = "535"循环4:cur = 3, t += tmp[3] = 1 + 4 = 5, cur++ret += 5 % 10 + '0' = '5't = 5 / 10 = 0当前ret = "5355"循环5:cur = 4 (超出tmp范围), t = 0 (无进位)循环条件不满足，退出循环

此时ret = “5355”，表示计算结果的反向存储

步骤4：处理前导零和反转

检查前导零：ret.size() > 1 且 ret.back() == '0'
这里ret.back() = '5'，不是'0'，无需处理前导零反转ret: "5355" -> "5535"

所以 123 × 45 = 5535，这是正确的结果。

完整过程可视化

1. 初始状态：
   • n1 = “123”, n2 = “45”
   • 反转后：n1 = “321”, n2 = “54”
   • tmp = [0, 0, 0, 0]
2. 无进位乘法：
   • 3×5=15 -> tmp[0]=15
   • 3×4=12 -> tmp[1]=12
   • 2×5=10 -> tmp[1]=22
   • 2×4=8 -> tmp[2]=8
   • 1×5=5 -> tmp[2]=13
   • 1×4=4 -> tmp[3]=4
   • 最终tmp = [15, 22, 13, 4]
3. 处理进位：
   • tmp[0]=15: 当前位=5, 进位=1
   • tmp[1]=22+1=23: 当前位=3, 进位=2
   • tmp[2]=13+2=15: 当前位=5, 进位=1
   • tmp[3]=4+1=5: 当前位=5, 进位=0
   • 反向结果ret = “5355”
4. 最终结果：
   • 反转ret得到 “5535”