字符串相乘（大数相乘） python实现

最新推荐文章于 2025-05-24 11:58:12 发布

UESTC_20172222

最新推荐文章于 2025-05-24 11:58:12 发布

阅读量2.8k

点赞数 1

CC 4.0 BY-SA版权

分类专栏：常规算法题目文章标签：字符串相乘大数相乘 python实现 list 反转 str 反转

本文链接：https://blog.youkuaiyun.com/qq_32806793/article/details/84866315

常规算法题目专栏收录该内容

38 篇文章

订阅专栏

本文详细介绍了一种在Python中处理大数乘法的方法，通过字符串形式表示的非负整数进行乘法运算，避免了标准库大数类型或直接转换为整数的限制。文章提供了两种解题思路，一种采用数组存储，另一种采用链表存储，对比了两者在时间复杂度上的差异。

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

首先讲解两个小技巧

list 反转 reverse

>>> l=[1,2,3,4,5,6]
>>> l.reverse()
>>> l
[6, 5, 4, 3, 2, 1]

str 反转 [::-1]

>>> 
>>> s="abcde"
>>> r_s=s[::-1]
>>> r_s
'edcba'
>>>

题目描述

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

示例 1:

输入: num1 = “2”, num2 = “3”
输出: “6”
示例 2:

输入: num1 = “123”, num2 = “456”
输出: “56088”
说明：

num1 和 num2 的长度小于110。
num1 和 num2 只包含数字 0-9。
num1 和 num2 均不以零开头，除非是数字 0 本身。
不能使用任何标准库的大数类型（比如 BigInteger）或直接将输入转换为整数来处理。

解答

需要知道

两个数相乘，其乘积结果的位数 小于等于 两个数长度之和
例如：
12345 * 6789 乘积结果的位数不超过9（5+4）

思路

思路很简单，代码完全模拟我们的思维方式请在纸上算 123X456 同时结合着代码 multiply_best 一步一步来看
千万要静下心看！！！

我这里实现了两种解题思路
这里感慨一下:两个算法采用的思想是一样的，但是时间复杂度确实差距很大，区别就在一个采用了数组存储（操作简单），一个采用链表存储（操作复杂）

class ListNode:
    def __init__(self,value):
        self.value=value
        self.exp=None
        self.next=None


class Solution:
    @staticmethod
    def multiply_best(num1, num2):
        """
        采用数组存储
        :type num1: str
        :type num2: str
        :rtype: str
        """
        if num1=="0" or num2=="0":
            return "0"
        res=[0]*(len(num1)+len(num2))
        len_num1 = len(num1)
        len_num2 = len(num2)
        for i in range(len_num1-1,-1,-1):
            num_1 = int(num1[i])
            exp_1= len_num1-i-1
            for j in range(len_num2 - 1, -1, -1):
                num_2 = int(num2[j])
                exp_2 = len_num2 - j - 1
                exp=exp_1+exp_2
                res[exp]+=num_1*num_2
                c=res[exp]//10
                res[exp]=res[exp] % 10
                exp+=1
                while c>0:
                    res[exp] += c
                    c = res[exp] // 10
                    res[exp] = res[exp] % 10
                    exp = exp + 1
        flag = False
        if res[-1]==0:
            flag = True


        res_str=""
        for i in range(len(res)-1,-1,-1):
            if res[i]==0 and flag:
                flag=False
                continue
            else:
                res_str+=str(res[i])
        return res_str




    @staticmethod
    def multiply_worse(num1, num2):
        """
        采用链表存储
        :type num1: str
        :type num2: str
        :rtype: str
        """
        if num1=="0" or num2=="0":
            return 0



        p_head_num1=ListNode(-1)
        p_head_num2 = ListNode(-1)
        res_head=ListNode(-1)


        len_num1=len(num1)
        len_num2=len(num2)

        for index,num in enumerate(num1):
            p = ListNode(int(num))
            p.exp = len_num1-index-1
            p.next=p_head_num1.next
            p_head_num1.next=p

        for index,num in enumerate(num2):
            p = ListNode(int(num))
            p.exp = len_num2-index-1
            p.next=p_head_num2.next
            p_head_num2.next=p


        p2=p_head_num2.next
        while p2 is not None:
            p1 = p_head_num1.next
            while p1 is not None:
                tmp = p2.value*p1.value
                c = tmp // 10
                value = tmp % 10
                exp = p2.exp+p1.exp
                p = res_head.next
                q=res_head
                flag_1 = True
                flag_2 = True
                while p is not None:
                    if p.exp==exp:
                        c += (p.value + value)//10
                        p.value=(p.value+value)%10
                        flag_1=False
                        q = p
                        p = p.next
                        if c == 0:
                            flag_2=False
                        break
                    q=p
                    p=p.next
                if flag_1:
                    p_new=ListNode(value)
                    p_new.exp=exp
                    q.next=p_new
                    q=q.next
                if c >0 and flag_2 :
                    while c != 0 and p is not None:
                        y=p.value + c
                        p.value = y % 10
                        c = y//10
                        exp=exp+1
                        q=p
                        p=p.next
                    if c>0:
                        p_new = ListNode(c)
                        p_new.exp = exp + 1
                        q.next = p_new


                p1=p1.next
            p2=p2.next
        p=res_head.next
        res=""
        while p is not None:
            res=str(p.value)+res
            p=p.next
        return res





if __name__=="__main__":
    num1="999"
    num2="999"
    print(Solution.multiply_best(num1,num2))