AI 助理
备案控制台
开发者社区 人工智能 文章 正文

大数乘法的几种算法分析及比较（2014腾讯南京笔试题）

2024-03-14 55
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 大数乘法的几种算法分析及比较（2014腾讯南京笔试题）

1.题目

      编写两个任意位数的大数相乘的程序，给出计算结果。

2.题目分析

      该题相继被ACM、华为、腾讯等选作笔试、面试题，若无准备要写出这种程序，还是要花一定的时间的。故，觉得有必要深入研究一下。搜索了网上的大多数该类程序和算法，发现，大数乘法主要有模拟手工计算的普通大数乘法，分治算法和FFT算法。其中普通大数乘法占据了90%以上，其优点是空间复杂度低，实现简单，时间复杂度为O（N²），分治算法虽然时间复杂度降低为,  

       普通大数乘法算法，主要有逐位相乘处理进位法、移位进位法，下面对其进行介绍并优化。

3.题目解答

3.1 逐位相乘处理进位法

       参考博客4的思路

      乘积是逐位相乘，也就是aibj，结果加入到积C的第i+j位，最后处理进位即可，例如：A =17 = 1*10 + 7 = （7,1）最后是十进制的幂表示法，幂次是从低位到高位，以下同。B=25 = 2*10 + 5 = (5, 2);C = A * B = (7 * 5, 1 * 5 + 2 * 7, 1 * 2) = (35, 19, 2) = (5, 22, 2) = (5, 2. 4)=425。

原博客的思路为：
（1）转换并反转，字符串转换为数字并将字序反转；

（2）逐位相乘，结果存放在result_num[i+j]中；

（3）处理进位，消除多余的0；

（4）转换并反转，将计算结果转换为字符串并反转。

    原博客中采用指针参数传递，字符串长度有限制，改为通过string传参数，按原思路编程如下：

头文件和数据结构：

[cpp]  view plain copy

  1. #include <iostream>  
  2. #include <string>  
  3. #include <vector>  
  4. #include <stdlib.h>  
  5. using namespace std;  
  6. struct bigcheng  
  7. {  
  8.    vector<int> a;  
  9.    vector<int> b;  
  10.    string result_str;  
  11. };  
  12. void chartonum(string a,string b,bigcheng &tempcheng);//字符串转换为数字并反转  
  13. void multiply(bigcheng &tempchengh,vector<int> &result_num);//逐位相乘,处理进位消除多余的0  
  14. void numtochar(bigcheng &tempcheng,vector<int> &result_num);//将计算结果转换为字符串并反转  

（1）转换并反转，字符串转换为数字并将字序反转；

[cpp]  view plain copy

  1. void chartonum(string a,string b,bigcheng &tempcheng)  
  2. {  
  3.    int size_a=a.size();  
  4.    int size_b=b.size();  
  5.    for (int i=size_a-1;i>=0;i--)  
  6.    {  
  7.        tempcheng.a.push_back(a[i]-'0');  
  8.    }  
  9.    for (int i=size_b-1;i>=0;i--)  
  10.    {  
  11.        tempcheng.b.push_back(b[i]-'0');  
  12.    }  
  13. }  

（2）逐位相乘，结果存放在result_num[i+j]中；

（3）处理进位，消除多余的0；代码为：

[cpp]  view plain copy

  1. void multiply(bigcheng &tempcheng,vector<int> &result_num)  
  2. {  
  3.    for (unsigned int i=0;i<tempcheng.a.size();i++)  
  4.    {  
  5.        for (unsigned int j=0;j<tempcheng.b.size();j++)  
  6.        {  
  7.            result_num[i+j]+=(tempcheng.a[i])*(tempcheng.b[j]);  
  8.        }  
  9.    }  
  10.    for (int i=result_num.size()-1;i>=0;i--)  
  11.    {  
  12.        if (result_num[i]!=0)  
  13.        {  
  14.            break;  
  15.        }  
  16.        else  
  17.            result_num.pop_back();  
  18.    }  
  19.    int c=0;  
  20.    for (unsigned int i=0;i<result_num.size();i++)//处理进位  
  21.    {  
  22.        result_num[i]+=c;  
  23.        c=result_num[i]/10;  
  24.        result_num[i]=result_num[i]%10;  
  25.    }  
  26.    if (c!=0)  
  27.    {  
  28.        result_num.push_back(c);  
  29.    }  
  30. }  

（4）转换并反转，将计算结果转换为字符串并反转。

[cpp]  view plain copy

  1. void numtochar(bigcheng &tempcheng,vector<int> &result_num)  
  2. {   int size=result_num.size();  
  3.    for (unsigned int i=0;i<result_num.size();i++)  
  4.    {  
  5.        tempcheng.result_str.push_back(char(result_num[size-1-i]+'0'));  
  6.    }  
  7. }  

主函数为：

[cpp]  view plain copy

  1. int main()  
  2. {  
  3.       bigcheng tempcheng;  
  4.    string a,b;  
  5.    cin>>a>>b;  
  6.    chartonum(a,b,tempcheng);  
  7.    vector<int> resultnum(a.size()+b.size(),0);  
  8.    multiply(tempcheng,resultnum);  
  9.    numtochar(tempcheng,resultnum);  
  10.    cout<<tempcheng.result_str<<endl;  
  11.    system("pause");  
  12.    return 0;  
  13. }  

    上面的思路还是很清晰的，但代码有些过长，考虑优化如下：

（1）上述思路是先转换反转，其实无需先将全部字符串转换为数字的，可即用即转，节约空间；

（2）无需等到逐位相乘都结束，才处理进位，可即乘即进；

（3）无需等到所有结果出来后，将结果转换为字符，可即乘即转。

    优化后时间复杂度不变，但节省了空间，代码更简洁。如下：

头文件和数据结构：

[cpp]  view plain copy

  1. #include <iostream>  
  2. #include <string>  
  3. #include <vector>  
  4. #include <stdlib.h>  
  5. #include <assert.h>  
  6. using namespace std;  
  7. struct bigcheng2  
  8. {  
  9.    string a;  
  10.    string b;  
  11.    string result_str;  
  12. };  
  13. void reverse_data( string &data)；//字符串反转  
  14. void multiply2(bigcheng2 &tempcheng2);//字符串模拟相乘  

字符串反转：

[cpp]  view plain copy

  1. void reverse_data( string &data)  
  2. {  
  3.    char temp = '0';  
  4.    int start=0;  
  5.    int end=data.size()-1;  
  6.    assert( data.size()&& start <= end );  
  7.    while ( start < end )  
  8.    {  
  9.        temp = data[start];  
  10.        data[start++] = data[end];  
  11.        data[end--] = temp;  
  12.    }  
  13. }  

两数相乘：

[cpp]  view plain copy

  1. void multiply2(bigcheng2 &tempcheng2)  
  2. {  
  3.    reverse_data(tempcheng2.a);//字符串反转  
  4.    reverse_data(tempcheng2.b);  
  5.    int c=0;  
  6.    string temp(tempcheng2.a.size()+tempcheng2.b.size(),'0');//将temp全部初始化为0字符  
  7.    for (unsigned int i=0;i<tempcheng2.a.size();i++)  
  8.    {  
  9.        unsigned int j;  
  10.        for (j=0;j<tempcheng2.b.size();j++)  
  11.        {  
  12.            c+=temp[i+j]-'0'+(tempcheng2.a[i]-'0')*(tempcheng2.b[j]-'0');//注意temp[i+j]可能保存有上一次计算的结果  
  13.            temp[i+j]=(c%10)+'0';//将结果转换为字符  
  14.            c=c/10;  
  15.        }  
  16.        while(c)  
  17.        {  
  18.            temp[i+j++]+=c%10;//temp里已存字符  
  19.            c=c/10;  
  20.        }  
  21.    }  
  22.    for (int i=temp.size()-1;i>=0;i--)  
  23.    {  
  24.        if (temp[i]!='0')  
  25.            break;  
  26.        else  
  27.            temp.pop_back();  
  28.    }  
  29.    reverse_data(temp);//结果?字Á?符¤?串ä?反¤¡ä转Áa  
  30.    tempcheng2.result_str=temp;  
  31. }  

主函数：

[cpp]  view plain copy

  1. int main()  
  2. {  
  3.       bigcheng2 tempcheng2;  
  4.       string a,b;  
  5.       cin>>a>>b;  
  6.       tempcheng2.a=a;  
  7.       tempcheng2.b=b;  
  8.       multiply2(tempcheng2);  
  9.       cout<<tempcheng2.result_str<<endl;  
  10.       system("pause");  
  11.       return 0;  
  12. }  

3.2 移位进位法

      移位进位法也是普通的大数相乘算法，其时间复杂度也为O（N²）其基本思路参考博客5，简述如下：

　　按照乘法的计算过程来模拟计算：

　　　　   1 2

　　　　× 3 6

　　 ---------- ---- 其中，上标数字为进位数值。

　　　　　71 2  --- 在这个计算过程中，2×6=12。本位保留2，进位为1.这里是一个简单的计算过程，如果在高位也需要进位的情况下，如何处理？

　　　　3 6

　   -----------

　　　　413  2

       其代码优化如下：

[cpp]  view plain copy

  1. #include <iostream>  
  2. #include <string>  
  3. #include <vector>  
  4. #include <stdlib.h>  
  5. #include <assert.h>  
  6. using namespace std;  
  7. void reverse_data( string &data);//字符串反转  
  8. void compute_value( string lhs,string rhs,string &result );  
  9. void reverse_data( string &data)  
  10. {  
  11.    char temp = '0';  
  12.    int start=0;  
  13.    int end=data.size()-1;  
  14.    assert( data.size()&& start <= end );  
  15.    while ( start < end )  
  16.    {  
  17.        temp = data[start];  
  18.        data[start++] = data[end];  
  19.        data[end--] = temp;  
  20.    }  
  21. }  
  22. void compute_value( string lhs,string rhs,string &result )  
  23. {  
  24.    reverse_data(lhs);  
  25.    reverse_data(rhs);  
  26.    int i = 0, j = 0, res_i = 0;  
  27.    int tmp_i = 0;  
  28.    int carry = 0;  
  29.  
  30.    for ( i = 0; i!=lhs.size(); ++i, ++tmp_i )  
  31.    {  
  32.        res_i = tmp_i;  //在每次计算时，结果存储的位需要增加  
  33.        for ( j = 0; j!= rhs.size(); ++j )  
  34.        {  
  35.            carry += ( result[res_i] - '0' )+(lhs[i] - '0') * (rhs[j] - '0');//此处注意，每次计算并不能保证以前计算结果的进位都消除， 并且以前的计算结果也需考虑。  
  36.            result[res_i++] = ( carry % 10 + '0' );  
  37.            carry /= 10;  
  38.        }  
  39.        while (carry)//乘数的一次计算完成，可能存在有的进位没有处理  
  40.        {  
  41.            result[res_i++] = (carry % 10 + '0');  
  42.            carry /= 10;  
  43.        }  
  44.    }  
  45.    for (int i=result.size()-1;i>=0;i--)  
  46.    {  
  47.        if (result[i]!='0')  
  48.            break;  
  49.        else  
  50.            result.pop_back();  
  51.    }  
  52.        reverse_data(result);  
  53. }  
  54. int main()  
  55. {  
  56.    string a,b;  
  57.    cin>>a>>b;  
  58.    string result(a.size()+b.size(),'0');  
  59.    compute_value(a,b,result);  
  60.    cout<<result<<endl;  
  61.    system("pause");  
  62.    return 0;  
  63. }  

3.3大数相乘优化

3.2 移位进位法中的反转字符串其实不必要的，只需从数组的后面开始计算存储即可，下面实现代码：

[cpp]  view plain copy

  1. char* bigcheng1(char *p1,char *p2)  
  2. {  
  3.    if (check(p1)||check(p2))  
  4.        throw exception("Invalid input!");  
  5.    int index1=strlen(p1)-1,index2=strlen(p2)-1,index3,carry=0;  
  6.    char *p3=new char[index1+index2+3];  
  7.    memset(p3,'0',index1+index2+2);  
  8.    p3[index1+index2+2]='\0';  
  9.    for (;index2>=0;--index2)  
  10.    {  
  11.        for (index1=strlen(p1)-1;index1>=0;--index1)  
  12.        {  
  13.            int num=p3[index1+index2+1]-'0'+(p1[index1]-'0')*(p2[index2]-'0')+carry;//p3[index1+index2+1]-'0',注意都是数字参与运算  
  14.            p3[index1+index2+1]=num%10+'0';  
  15.            carry=num/10;  
  16.        }  
  17.        int i=0;  
  18.        while(carry)  
  19.        {  
  20.            p3[index1+index2+1+(i--)]+=(carry%10);//注意字符和字符串的不同  
  21.            carry/=10;  
  22.        }  
  23.        index3=index1+index2+1+i;  
  24.    }  
  25.    while(index3>=0)  
  26.        p3[index3--]='0';  
  27.    return p3;  
  28. }  



或者下面这样，其实是一样的，下面的相加、相减、相除一样的思路啦


[cpp]  view plain copy

  1. char* bigcheng(char *p1,char *p2)  
  2. {  
  3.    if (check(p1)||check(p2))  
  4.        throw exception("Invalid input!");  
  5.    int index1=strlen(p1)-1,index2=strlen(p2)-1,index3,carry=0;  
  6.    char *p3=new char[index1+index2+3];  
  7.    memset(p3,'0',index1+index2+2);  
  8.    p3[index1+index2+2]='\0';  
  9.    for (;index2>=0;--index2)  
  10.    {  
  11.        for (index1=strlen(p1)-1;index1>=0;--index1)  
  12.        {  
  13.            int num=p3[index1+index2+1]-'0'+(p1[index1]-'0')*(p2[index2]-'0')+carry;//p3[index1+index2+1]-'0',注意都是数字参与运算  
  14.            if (num>=10)  
  15.            {  
  16.                carry=num/10;  
  17.                num%=10;  
  18.            }  
  19.            else carry=0;  
  20.            p3[index1+index2+1]=num+'0';  
  21.        }  
  22.        int i=0;  
  23.        while(carry)  
  24.        {  
  25.            p3[index1+index2+1+(i--)]+=(carry%10);//注意字符和字符串的不同  
  26.            carry/=10;  
  27.        }  
  28.        index3=index1+index2+1+i;  
  29.    }  
  30.    while(index3>=0)  
  31.        p3[index3--]='0';  
  32.    return p3;  
  33. }  



3.4运行结果

       运行结果如图1、图2所示

 

                   图1    

                                                                   图2

3.5 大数相加

check合法性校验，校验字符串中是否有非数字。

[cpp]  view plain copy

  1. bool check(char *p)  
  2. {  
  3.    if (!p)  
  4.    {  
  5.        return 1;  
  6.    }  
  7.    int i=0;  
  8.    while(p[i]!='\0')  
  9.    {  
  10.        if (p[i]<'0'||p[i]>'9')  
  11.        {  
  12.            return 1;  
  13.        }  
  14.        else ++i;  
  15.    }  
  16.    return 0;//合法  
  17. }  


[cpp]  view plain copy

  1. char* bigadd(char *p1,char *p2)  
  2. {  
  3.    if (check(p1)||check(p2))  
  4.    {  
  5.        throw exception("Invalid input!");  
  6.    }  
  7.    int len1=strlen(p1);  
  8.    int len2=strlen(p2);  
  9.    int len3=max(len1,len2)+1;  
  10.    char *p3=new char[len3+1];  
  11.    memset(p3,'0',len3);  
  12.    p3[len3]='\0';  
  13.    int index1=len1-1,index2=len2-1,index3=len3-1;  
  14.    int carry=0;  
  15.    while(index1>=0&&index2>=0)  
  16.    {  
  17.        int num=p1[index1--]-'0'+p2[index2--]-'0'+carry;  
  18.        if (num>=10)  
  19.        {  
  20.            carry=1;  
  21.            num-=10;  
  22.        }  
  23.        else  
  24.            carry=0;  
  25.        p3[index3--]=num+'0';  
  26.    }  
  27.    while(index1>=0)  
  28.    {  
  29.        int num=p1[index1--]-'0'+carry;  
  30.        if (num>=10)  
  31.        {  
  32.            carry=1;  
  33.            num-=10;  
  34.        }  
  35.        else  
  36.            carry=0;  
  37.        p3[index3--]=num+'0';  
  38.    }  
  39.    while(index2>=0)  
  40.    {  
  41.        int num=p1[index2--]-'0'+carry;  
  42.        if (num>=10)  
  43.        {  
  44.            carry=1;  
  45.            num-=10;  
  46.        }  
  47.        else  
  48.            carry=0;  
  49.        p3[index3--]=num+'0';  
  50.    }  
  51.    p3[index3]=carry?'1':'0';  
  52.    return p3;  
  53. }  



3.6大数相减

[cpp]  view plain copy

  1. char* bigminus(char *p1,char *p2,bool &flag)  
  2. {  
  3.    if (check(p1)||check(p2))  
  4.    {  
  5.        throw exception("Invalid input!");  
  6.    }  
  7.    flag=0;//正数默认  
  8.    if (strlen(p1)<strlen(p2))  
  9.    {  
  10.        flag=1;  
  11.        char *tmp=p1;  
  12.              p1=p2;  
  13.              p2=tmp;  
  14.    }  
  15.    else if (strlen(p1)==strlen(p2))  
  16.    {  
  17.        if (strcmp(p1,p2)<0)  
  18.        {  
  19.            flag=1;  
  20.            char *tmp=p1;  
  21.            p1=p2;  
  22.            p2=tmp;  
  23.        }  
  24.    }  
  25.    int index1=strlen(p1)-1,index2=strlen(p2)-1,index3=strlen(p1);  
  26.    char *p3=new char[strlen(p1)+2];  
  27.    memset(p3,'0',index3+1);  
  28.    p3[index3+1]='\0';  
  29.    int carry=0;  
  30.    while(index1>=0&&index2>=0)  
  31.    {  
  32.        int num=p1[index1--]-p2[index2--]-carry;  
  33.        if (num<0)  
  34.        {  
  35.            carry=1;  
  36.            num+=10;  
  37.        }  
  38.        else carry=0;  
  39.        p3[index3--]=num+'0';  
  40.    }  
  41.    while(index1>=0)  
  42.    {  
  43.        int num=p1[index1--]-'0'-carry;  
  44.        if (num<0)  
  45.        {  
  46.            carry=1;  
  47.            num+=10;  
  48.        }  
  49.        else carry=0;  
  50.        p3[index3--]=num+'0' ;  
  51.    }  
  52.        int i=0;  
  53.        while(p3[i]=='0') ++i;  
  54.        if (flag)  
  55.        {  
  56.          p3[i-1]='-';  
  57.        }  
  58.    return p3;  
  59. }  



3.7大数相除

[cpp]  view plain copy

  1. char* bigchu(char *p1,char *p2)//大数除，有问题，但思想是对的，关键怎么处理前面多样的0  
  2. {  
  3.    bool flag=0;  
  4.    char *tmp1=new char[strlen(p2)-strlen(p2)+1];  
  5.    char *tmp0=tmp1,*p3,*p4;  
  6.    memset(tmp1,'0',strlen(p2)-strlen(p2));  
  7.    tmp1[strlen(p2)-strlen(p2)]='\0';  
  8.    char *tmp2=bigminus(p1,p2,flag);  
  9.          p1=tmp2;  
  10.    while(!flag)  
  11.    {  
  12.  
  13.        p3=bigadd(tmp0,"1");  
  14.        tmp1=tmp0;  
  15.        tmp0=p3;          
  16.        delete []tmp1;  
  17.  
  18.        tmp2=bigminus(p1,p2,flag);  
  19.        p4=p1;  
  20.        p1=tmp2;  
  21.        delete []p4;  
  22.    }  
  23.    return tmp0;  
  24.      
  25. }  


3.8主函数测试

[cpp]  view plain copy

  1. int _tmain(int argc, _TCHAR* argv[])  
  2. {  
  3.    string a,b;  
  4.    while(1)  
  5.    {  
  6.        cin>>a>>b;  
  7.        char *p1=const_cast<char *>(a.c_str());  
  8.        char *p2=const_cast<char *>(b.c_str());  
  9.        bool flag=0;  
  10.        char *p3=bigadd(p1,p2);  
  11.        char *p4=bigminus(p1,p2,flag);  
  12.        char *p5=bigcheng1(p1,p2);  
  13.        //char *p6=bigchu(p1,p2);  
  14.  
  15.        //cout<<p3<<endl<<endl<<p4<<endl<<endl<<p5<<endl<<endl;  
  16.        cout<<p1<<endl<<"bigadd"<<endl<<p2<<endl<<"equal: ";  
  17.        printnum(p3);  
  18.        cout<<endl;  
  19.        cout<<p1<<endl<<"bigminus"<<endl<<p2<<endl<<"equal: ";  
  20.        printnum(p4);  
  21.        cout<<endl;  
  22.        cout<<p1<<endl<<"bigcheng1"<<endl<<p2<<endl<<"equal: ";  
  23.        printnum(p5);  
  24.        cout<<endl;  
  25.    }  
  26.    system("pause");  
  27.    return 0;  
  28. }  


测试结果如下：

文章标签：
C++
算法
存储
人工智能
BI
关键词：
算法分析
算法腾讯
算法笔试题
大数乘法算法分析腾讯南京
我是夜阑的狗
目录
相关文章
众所周知
|
1月前
|
机器学习/深度学习 算法 搜索推荐
从理论到实践，Python算法复杂度分析一站式教程，助你轻松驾驭大数据挑战！
【10月更文挑战第4天】在大数据时代，算法效率至关重要。本文从理论入手，介绍时间复杂度和空间复杂度两个核心概念，并通过冒泡排序和快速排序的Python实现详细分析其复杂度。冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)；快速排序平均时间复杂度为O(n log n)，空间复杂度为O(log n)。文章还介绍了算法选择、分而治之及空间换时间等优化策略，帮助你在大数据挑战中游刃有余。
众所周知
58 4
java冯坚持
|
1月前
|
算法 前端开发 Java
数据结构与算法学习四：单链表面试题，新浪、腾讯【有难度】、百度面试题
这篇文章总结了单链表的常见面试题，并提供了详细的问题分析、思路分析以及Java代码实现，包括求单链表中有效节点的个数、查找单链表中的倒数第k个节点、单链表的反转以及从尾到头打印单链表等题目。
java冯坚持
32 1
数据结构与算法学习四：单链表面试题，新浪、腾讯【有难度】、百度面试题
aliyun0942992302
|
23天前
|
并行计算 算法 IDE
【灵码助力Cuda算法分析】分析共享内存的矩阵乘法优化
本文介绍了如何利用通义灵码在Visual Studio 2022中对基于CUDA的共享内存矩阵乘法优化代码进行深入分析。文章从整体程序结构入手，逐步深入到线程调度、矩阵分块、循环展开等关键细节，最后通过带入具体值的方式进一步解析复杂循环逻辑，展示了通义灵码在辅助理解和优化CUDA编程中的强大功能。
aliyun0942992302
70 2
梦笔生花伟
|
29天前
|
算法
PID算法原理分析
【10月更文挑战第12天】PID控制方法从提出至今已有百余年历史，其由于结构简单、易于实现、鲁棒性好、可靠性高等特点，在机电、冶金、机械、化工等行业中应用广泛。
梦笔生花伟
34 0
众所周知
|
2月前
|
算法 搜索推荐 开发者
别再让复杂度拖你后腿！Python 算法设计与分析实战，教你如何精准评估与优化！
在 Python 编程中，算法的性能至关重要。本文将带您深入了解算法复杂度的概念，包括时间复杂度和空间复杂度。通过具体的例子，如冒泡排序算法 (`O(n^2)` 时间复杂度，`O(1)` 空间复杂度)，我们将展示如何评估算法的性能。同时，我们还会介绍如何优化算法，例如使用 Python 的内置函数 `max` 来提高查找最大值的效率，或利用哈希表将查找时间从 `O(n)` 降至 `O(1)`。此外，还将介绍使用 `timeit` 模块等工具来评估算法性能的方法。通过不断实践，您将能更高效地优化 Python 程序。
众所周知
57 4
梦笔生花伟
|
1月前
|
算法
PID算法原理分析及优化
【10月更文挑战第6天】PID控制方法从提出至今已有百余年历史，其由于结构简单、易于实现、鲁棒性好、可靠性高等特点，在机电、冶金、机械、化工等行业中应用广泛。
梦笔生花伟
30 0
东方睿赢
|
2月前
|
算法 程序员 Python
程序员必看！Python复杂度分析全攻略，让你的算法设计既快又省内存！
在编程领域，Python以简洁的语法和强大的库支持成为众多程序员的首选语言。然而，性能优化仍是挑战。本文将带你深入了解Python算法的复杂度分析，从时间与空间复杂度入手，分享四大最佳实践：选择合适算法、优化实现、利用Python特性减少空间消耗及定期评估调整，助你写出高效且节省内存的代码，轻松应对各种编程挑战。
东方睿赢
41 1
软件算法开发
|
2月前
|
算法 数据可视化
基于SSA奇异谱分析算法的时间序列趋势线提取matlab仿真
奇异谱分析（SSA）是一种基于奇异值分解（SVD）和轨迹矩阵的非线性、非参数时间序列分析方法，适用于提取趋势、周期性和噪声成分。本项目使用MATLAB 2022a版本实现从强干扰序列中提取趋势线，并通过可视化展示了原时间序列与提取的趋势分量。代码实现了滑动窗口下的奇异值分解和分组重构，适用于非线性和非平稳时间序列分析。此方法在气候变化、金融市场和生物医学信号处理等领域有广泛应用。
软件算法开发
121 19
子午s
|
2月前
|
机器学习/深度学习 存储 人工智能
文本情感识别分析系统Python+SVM分类算法+机器学习人工智能+计算机毕业设计
使用Python作为开发语言，基于文本数据集（一个积极的xls文本格式和一个消极的xls文本格式文件），使用Word2vec对文本进行处理。通过支持向量机SVM算法训练情绪分类模型。实现对文本消极情感和文本积极情感的识别。并基于Django框架开发网页平台实现对用户的可视化操作和数据存储。
子午s
50 0
文本情感识别分析系统Python+SVM分类算法+机器学习人工智能+计算机毕业设计
糜终
|
1月前
|
算法 安全 Go
Python与Go语言中的哈希算法实现及对比分析
Python与Go语言中的哈希算法实现及对比分析
糜终
40 0

热门文章

最新文章

  • 1
    OneMob（一体传媒）：大数据算法 让营销更精准
  • 2
    算法学习之顺序结构
  • 3
    泛型KMP算法
  • 4
    【算法】算法之美—Fire Net
  • 5
    【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
  • 6
    字符串相似度算法 递归与动态规划求解分析
  • 7
    Node.js使用jsrsasign实现SHA256withRSA加密算法
  • 8
    【算法研究】Bresenham画线算法
  • 9
    梯度下降算法详解（从下山比喻、数学推导到代码实现）
  • 10
    【编程练习】收集的一些c++代码片，算法排序，读文件，写日志，快速求积分等等
  • 1
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    98
  • 2
    【redis源码学习】持久化机制，java程序员面试算法宝典pdf
    77
  • 3
    对标腾讯T9架构师的 Android 面试题新鲜出炉，算法真的太重要了
    52
  • 4
    【机器学习】K-means算法与PCA算法之间有什么联系？
    265
  • 5
    【机器学习】维度灾难问题会如何影响K-means算法？
    299
  • 6
    【数据结构与算法 11，高并发系统基础篇
    41
  • 7
    sass 公用10个mixins代码块，算法太TM重要了，前端开发要求
    46
  • 8
    前端开发者必知的缓存淘汰策略：LRU算法解析与实践
    203
  • 9
    2024最新Android算法相关面试大全，请查收
    37
  • 10
    【机器学习】聚类算法中，如何判断数据是否被“充分”地聚类，以便算法产生有意义的结果？
    138

    • 相关课程

    更多
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台

    • 相关实验场景

    更多
  • 推荐系统入门之使用ALS算法实现打分预测
  • 欧拉图的构造性证明与算法实现
  • RSA密码算法设计与实现
  • RSA非对称加密算法
  • 使用Swing算法实现商品推荐
    • 下一篇
    阿里云OSS设置跨域访问