Stanford Algorithms(一): 大数相乘(c++版)
刚不就在中国大学Mooc上参加了陈越老师的数据结构的课程,收获很大.觉得趁热打铁,也把算法的部分也给一块学了吧,就在Coursera上注册了一个斯坦福大学的算法课,课程的量很重,估计要学一个学期吧,慢慢的学,稳扎稳打.
课程里推荐了很多书,我找了一本, 书名就叫Algorithms,作者是S.Dasgupta教授,简单翻看了一下,觉得写的挺不错,就姑且把这本书当做教材了.
还是那句话,贵精不贵多,一门学深入了,收获就会很大,总之:
不要做一个浮躁的人.
第一节课就出了一个很有意思的题:两个数相乘.
也许会有人问,这有什么难,程序里直接就能算,但是题目出的是两个64个数字相乘,这就有意思了.
这个计算两个数字相乘的算法,视频里介绍过了,就是分治的思想,递归的调用,把原本的O(n^2)的问题变成了O(logn),效率无以提升很多.
我到网上一查,发现这是个很出名的,叫做大数相乘的算法问题,参考了一些文章,但感觉写的都不是很详细.
我是用C++实现的.先看看思路吧:
1.数字太多,int肯定不行,要用string
2.具体的算法已经有了,实现的困难,在于实现两个string数字之间的加,减,以及乘法.
要用的函数大概是这些:
string multiply(string x, string y);
string simplyMultiply(string x, string y);
int string2int(string x);
string int2string(int x);
string add(string x, string y);
string Minus(string x, string y);
string addZero(string x, int zeroNum);
string addPreZero(string x, int zeroNum);
string reverseString(string s);
int Max(int x, int y);其中有三个函数比较简单:
int Max(int x, int y){
/*
* Description: find max number
* Input: Two integers
* Output: Return max between x and y
*/
return x > y ? x : y;
}
int string2int(string x){
/*
* Description: Change string to int
* Input: A string
* Output: Return a integer represents origin string
*/
int n = x.length();
int s = 0;
for(int i = 0; i < n; ++i){
s = 10 * s + x[i] - ‘0‘;
}
return s;
}
string int2string(int x){
/*
* Description: Change int to string
* Input: An integers
* Output: Return a string represents origin integers
*/
string result;
stringstream stream;
stream << x;
stream >> result;
return result;
}这里借助了stringstream,可以轻松实现类型之间的转换,当然是涉及到string的.
两个string的加和减,考虑平时手算的方式,是尾对齐的,因此用程序实现的话,先把它们倒转,变成头对齐,就方便计算了.
string simplyMultiply(string x, string y){
/*
* Description: multiply two string, whose length = 1
* Input: Two string
* Output: Return product
*/
if(x.empty() | y.empty()){
return int2string(0);
}else{
int result = string2int(x) * string2int(y);
return int2string(result);
}
}
string reverseString(string s){
/*
* Description: Reverse the string
* Input: A string
* Output: Return a reversed string
*/
string result;
for(auto temp = s.end() - 1; temp >= s.begin(); --temp){
result.push_back(*temp);
}
return result;
}
还有两个额外的操作,就是在string前面和后面添加0,在前面添加0是为了让两个string的位数相等,因为这个算法处理的是两个等长string,因此要补位,不然会出问题;后面加0,是要用到与10^n相乘这种情况.
string addZero(string x, int zeroNum){
/*
* Description: Add zero between a string, simulate x * 10^n
* Input: A string, a integer represents zero‘s number after it
* Output: Return a string, which is added n‘s 0
*/
string temp(zeroNum, ‘0‘);
x.append(temp);
return x;
}
string addPreZero(string x, int zeroNum){
/*
* Description: Add zero before a string to fill in empty place
* Input: A string, a integer represents zero‘s number
* Output: Return a string, which is added n‘s 0 before it
*/
string temp(zeroNum, ‘0‘);
temp.append(x);
return temp;
}比较精彩的是模拟两个string加减的操作.有了前面几个方法做铺垫,实现起来就不困难了.其中,
Add操作模仿的是到10进1
Minus操作模仿的是减时不够高位来补
细节一定要注意,否则bug很难看出来.
string add(string x, string y){
/*
* Description: Add two string
* Input: Two strings
* Output: Return their sum
*/
int i, more = 0, tempSum = 0;
x = reverseString(x);
y = reverseString(y);
int maxSize = Max(x.size(), y.size());
string s(maxSize + 1, ‘0‘);
for(i = 0; i < x.size() && i < y.size(); ++i){
tempSum = x[i] - ‘0‘ + y[i] - ‘0‘ + more;
s[i] = tempSum % 10 + ‘0‘;
more = tempSum / 10;
}
if(i != y.size()){
for(; i < y.size(); ++i){
tempSum = y[i] - ‘0‘ + more;
s[i] = tempSum % 10 + ‘0‘;
more = tempSum / 10;
}
}else if(i != x.size()){
for(; i < x.size(); ++i){
tempSum = x[i] - ‘0‘ + more;
s[i] = tempSum % 10 + ‘0‘;
more = tempSum / 10;
}
}
if(more != 0){
s[i] += more;
}else{
s.pop_back();
}
s = reverseString(s);
return s;
}
string Minus(string x, string y){
/*
* Description: Minus between strings
* Input: Two strings
* Output: Return their difference
*/
int i;
x = reverseString(x);
y = reverseString(y);
string s(x.size(), ‘0‘);
for(i = 0; i < y.size(); ++i){
if(x[i] < y[i]){
x[i] += 10;
x[i + 1] -= 1;
}
s[i] = x[i] - y[i] + ‘0‘;
}
for(; i < x.size(); ++i){
s[i] = x[i];
}
for(i = x.size() - 1; i > 0; --i){
if(s[i] == ‘0‘){
s.pop_back();
}else{
break;
}
}
s = reverseString(s);
return s;
}有了前面的这些,multi()写起来就很简单了,这里要注意的是数字位数为奇数时的处理.
string multiply(string x, string y){
/*Description: Multiply between two strings
*Input: Two strings, represents two positive integers
*Output: Return product of x and y
*/
int xSize = x.length();
int ySize = y.length();
int n = Max(xSize, ySize);
if(n == xSize){
y = addPreZero(y, n - ySize);
}else{
x = addPreZero(x, n - xSize);
}
if(n == 1){
return simplyMultiply(x, y);
}
string xLeft = x.substr(0, n / 2);
string xRight = x.substr(n / 2);
string yLeft = y.substr(0, n / 2);
string yRight = y.substr(n / 2);
string p1 = multiply(xLeft, yLeft);
string p2 = multiply(xRight, yRight);
string p3 = multiply(add(xLeft, xRight), add(yLeft, yRight));
string p4 = Minus(Minus(p3, p1), p2);
string result = add(add(addZero(p1, 2 * (n - n / 2)),
addZero(p4, n - n / 2)), p2);
return result;
}现在,可以尽情的相乘了,两个64位数也可以.
代码在这里:大数相乘
总结:以前很少考虑过两个数是怎么相乘的,写在程序里,也许只是一个符号而已,不知道这中间,发生了这么多的故事.现在我们时常面临着的,不是缺乏工具,而是工具封装的太好,程序员都喜欢偷懒,但是要想获得真正的提高,那个盒子,是迟早要打开看看的.我觉得这是数据结构和算法课,交给我的很重要的东西,这种底层的思维习惯,很重要.
时间： 2024-10-10 06:25:39