介绍原理

karatsuba 算法要求乘数与被乘数要满足以下几个条件，第一，乘数与被乘数的位数相同；第二，乘数与被乘数的位数应为  2 次幂，即为 2 ^ 2,  2 ^ 3, 2 ^ 4， 2 ^ n 等数值。

ratsuba算法，乘法规模就下降一半。所以，对于两个n= 2^K位数乘法运算，我们需要计算3^k次乘法运算。而K=logn(底数为2)，3^K=3^logn=2 ^(log3*logn)=2^(lo

下面我们先来看几个简单的例子，并以此来了解 karatsuba 算法的使用方法。

t = int(n1_pad[:mid_len])    q: int = int(n1_pad[mid_len:])    r: int = int(n2_pad[:mid_len])    s:

两位数相乘

我们设被乘数 A = 85，乘数 B = 41。下面来看我们的操作步骤：

的情况下的时间复杂度为W(n)，则可以列出递推方程式。W(n)=W(n-1)+n-1,W(1)=0很容易求出上述的W(n)=n(n-1)/21.2二分归并排序时间复杂度求解设二分归并排序的最坏情况下时

将 A, B 一分为二，令 p = A 的前半部分 = 8，q = A 的后半部分 = 5 ， r = B 的前半部分 = 4 ，s = B 的后半部分 =  1，n = 2。通过简单的数学运算：

w)*10+w。换成数值求解的过程如下：A*B=85*41=(8*10+5)*(4*10+1)=8*4*10*10+(8*1+5*4)*10+5*1。其中u=8*4=32，v=(8-5)(1-4)=-

A * B = pq * rs= (p * 10 + q) * (r * 10 + s)  =p * r * 10 ^ 2 + (p * s + q * r ) * 10 + q * s。

间复杂度。比如两个N位数相乘，我们需要将每一位按规则相乘，所以需要计算 N*N次乘法。而使用 Karatsuba算法每层需要计算三次乘法，两次加法，以及若干次加法，每使用一次karatsuba算法，乘

令 u = p * r，v =(p - q) * (s - r)，w = q * s。所以 A * B =  u * 10 ^ 2 + (u + v + w) * 10 + w。

ba算法每层需要计算三次乘法，两次加法，以及若干次加法，每使用一次karatsuba算法，乘法规模就下降一半。所以，对于两个n= 2^K位数乘法运算，我们需要计算3^k次乘法运算。而K=logn(底数

d(n2_str, n2_len, max_len)    p: int = int(n1_pad[:mid_len])    q: int = int(n1_pad[mid_len:])    r:

换成数值求解的过程如下：

时间复杂度求解设插入排序的基本运算是元素的比较，对规模为n的输入，最坏的情况下的时间复杂度为W(n)，则可以列出递推方程式。W(n)=W(n-1)+n-1,W(1)=0很容易求出上述的W(n)=n(n

A * B = 85 * 41 = (8 * 10 + 5) * ( 4 * 10 + 1) = 8 * 4 * 10 * 10 + (8 * 1 + 5 * 4) * 10 + 5 * 1。

-q)*(s-r)，w=q*s。所以A*B= u*10^2+(u+v+w)*10+w。换成数值求解的过程如下：A*B=85*41=(8*10+5)*(4*10+1)=8*4*10*10+(8*1+5*

其中 u = 8 * 4 = 32，v = (8 - 5) (1 - 4) = -9，w = 5 * 1 = 5。

N位数的乘法结果。时间复杂度我们平常使用的长乘法，是O(n^2)的时间复杂度。比如两个N位数相乘，我们需要将每一位按规则相乘，所以需要计算 N*N次乘法。而使用 Karatsuba算法每层需要计算三次

所以，A * B = 32 * 100 + (32 - 9 + 5) * 10 + 5 = 3485。与长乘法所得结果一致。

t = max_len >> 1    n1_pad: str = pad(n1_str, n1_len, max_len)    n2_pad: str = pad(n2_str, n2

四位数相乘

我们设被乘数 A = 8537，乘数 B = 4123。下面来看我们的操作步骤：

程，可以参考文章离散数学中的数据结构与算法】十汉诺塔我们知道汉诺塔的递归算法对应的递推式子为：T(n)=2T(n-1)+1,T(1)=1上述的式子，即为递推方程。1.1插入排序时间复杂度求解设插入排序

将 A, B 一分为二，令 p = A 的前半部分 = 85，q = A 的后半部分 = 37 ， r = B 的前半部分 = 41 ，s = B 的后半部分 =  23，n = 4。

部分= 1，n=2。通过简单的数学运算：A*B=pq*rs =(p*10+q)*(r*10+s) = p*r*10^2+(p*s+q*r)*10+q*s。令u=p*r，v=(p-q)*(s-r)，w=

==> 其中，u = 85 * 41, v = (85 - 37) * (23 - 41), w = 37 * 23。

,v,w的数值。接着，我们在计算n/2乘法的过程中又会遇到n/4位的乘法运算……以此类推，直到我们遇到两个个位数的乘法，我们就直接返回这两个个位数乘法的结果。层层返回，最终得到N位数的乘法结果。时间复

==> A * B = 8537 * 4123 = u * 10 ^ 4 + (u + v + w) * 10 ^ 2 + w =  3485_0000 +34_7200 + 851 = 35198051。

位数的乘法，我们就直接返回这两个个位数乘法的结果。层层返回，最终得到N位数的乘法结果。时间复杂度我们平常使用的长乘法，是O(n^2)的时间复杂度。比如两个N位数相乘，我们需要将每一位按规则相乘，所以需

在我们计算 u， v,  w 的过程中又会涉及两位数的乘法，我们继续使用 Karatsuba 算法得出两位数相乘的结果。

eil(log2(real_len))    mid_len: int = max_len >> 1    n1_pad: str = pad(n1_str, n1_len, max_le

N 位数相乘

我们令 n 为 乘数与被乘数的位数，令 p = A 的前半部分，q = A 的后半部分， r = B 的前半部分 ，s = B 的后半部分。

1.递推方程的引入汉诺塔问题大家都知道，现在以汉诺塔问题来引入递推方程，可以参考文章离散数学中的数据结构与算法】十汉诺塔我们知道汉诺塔的递归算法对应的递推式子为：T(n)=2T(n-1)+1,T(1)

==> 其中， u = p * r，v = (p - q) * (s - r)，w = q * s。

半部分=8，q=A的后半部分=5，r=B的前半部分=4，s=B的后半部分= 1，n=2。通过简单的数学运算：A*B=pq*rs =(p*10+q)*(r*10+s) = p*r*10^2+(p*s+q

所以 A * B =  u * 10 ^ n + (u + v + w) * 10 ^ (n / 2) + w。

则是两个n/2位的乘法运算。我们继续调用Karatsuba算法计算u,v,w的数值。接着，我们在计算n/2乘法的过程中又会遇到n/4位的乘法运算……以此类推，直到我们遇到两个个位数的乘法，我们就直接返

而 u, v, w 则是两个 n / 2 位的乘法运算。我们继续调用 Karatsuba 算法计算 u, v, w 的数值。接着，我们在计算 n / 2 乘法的过程中又会遇到 n / 4 位的乘法运算……以此类推，直到我们遇到两个个位数的乘法，我们就直接返回这两个个位数乘法的结果。层层返回，最终得到 N 位数的乘法结果。

2_len: int = len(n2_str)    real_len: int = max(n1_len, n2_len)    max_len: int = 2 ** ceil(log2(rea

时间复杂度

我们平常使用的长乘法，是 O (n ^ 2) 的时间复杂度。比如两个 N 位数相乘，我们需要将每一位按规则相乘，所以需要计算  N * N 次乘法。而使用  Karatsuba 算法每层需要计算三次乘法，两次加法，以及若干次加法，每使用一次 karatsuba 算法，乘法规模就下降一半。

于什么是递推方程，这里就不再多说了。本文主要讲讲简单的递推方程来求解算法的时间复杂度文章目录1.递推方程的引入1.1插入排序时间复杂度求解1.2二分归并排序时间复杂度求解2总结1.递推方程的引入汉诺塔

所以，对于两个 n =  2 ^ K 位数乘法运算，我们需要计算 3 ^ k 次乘法运算。而 K = log n(底数为 2)， 3 ^ K = 3 ^ log n = 2  ^ (log 3 * log n) = 2 ^ (log n * log 3) = n ^ log 3 (底数为 2)。

入1.1插入排序时间复杂度求解1.2二分归并排序时间复杂度求解2总结1.递推方程的引入汉诺塔问题大家都知道，现在以汉诺塔问题来引入递推方程，可以参考文章离散数学中的数据结构与算法】十汉诺塔我们知道汉诺

代码实现from math import log2, ceil

def pad(string: str, real_len: int, max_len: int) -> str:

pad_len: int = max_len - real_len

return f"{"0" * pad_len}{string}"

def kara(n1: int, n2: int) -> int:

if n1

return n1 * n2

n1_str: str = str(n1)

n2_str: str = str(n2)

n1_len: int = len(n1_str)

n2_len: int = len(n2_str)

real_len: int = max(n1_len, n2_len)

max_len: int = 2 ** ceil(log2(real_len))

mid_len: int = max_len >> 1

n1_pad: str = pad(n1_str, n1_len, max_len)

n2_pad: str = pad(n2_str, n2_len, max_len)

p: int = int(n1_pad[:mid_len])

q: int = int(n1_pad[mid_len:])

r: int = int(n2_pad[:mid_len])

s: int = int(n2_pad[mid_len:])

u: int = kara(p, r)

v: int = kara(q-p, r-s)

w: int = kara(q, s)

return u * 10 ** max_len + (u+v+w) * 10 ** mid_len + w

输出结果：

乘数B=41。下面来看我们的操作步骤：将A,B一分为二，令p=A的前半部分=8，q=A的后半部分=5，r=B的前半部分=4，s=B的后半部分= 1，n=2。通过简单的数学运算：A*B=pq*rs =(

==> kara(123456, 9734) == 123456 * 9734

= u*10^n+(u+v+w)*10^(n/2)+w。而u,v,w则是两个n/2位的乘法运算。我们继续调用Karatsuba算法计算u,v,w的数值。接着，我们在计算n/2乘法的过程中又会遇到n/4

==> kara(1234233456756, 32459734) == 1234233456756 * 32459734

n1_len: int = len(n1_str)    n2_len: int = len(n2_str)    real_len: int = max(n1_len, n2_len)