首先講解 兩個小技巧

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))