Công cụ bảo vệ mã nguồn .NET mạnh nhất, không thể unpack, miễn phí cho các khách hàng đầu tiên đăng ký.
Từ 1 tới 4 trên tổng số 4 kết quả

Đề tài: Thao tác trên số nguyên lớn (cộng, trừ, nhân) bằng C++. Các anh chị góp ý nhé!

  1. #1
    Ngày gia nhập
    10 2007
    Bài viết
    5

    Mặc định Thao tác trên số nguyên lớn (cộng, trừ, nhân) bằng C++. Các anh chị góp ý nhé!

    Em đang làm bài tập thao tác trên số nguyên lớn gồm

    1)tính tổng
    2)tính hiệu
    3)nhân

    Anh chị xem code va góp ý nha:

    C++ Code:
    1.  
    2. #include<conio.h>
    3. #include<stdio.h>
    4. #include<iostream.h>
    5. #include<stdlib.h>
    6. #include<string.h>
    7.  
    8. typedef long KieuDL;
    9. typedef struct NUT
    10. {
    11.     struct NUT(long dl)
    12.     {
    13.         this->duLieu=dl;
    14.         this->tiep=NULL;
    15.         this->truoc=NULL;
    16.     }
    17.     KieuDL duLieu;
    18.     struct NUT* tiep;
    19.     struct NUT* truoc;
    20. }NUT;
    21. class DSLKK
    22. {
    23.     private:
    24.         int sign;
    25.         NUT *dau;
    26.         NUT *cuoi;
    27.     public:
    28.          
    29.         DSLKK();
    30.         ~DSLKK();
    31.         void themNutOCuoi(KieuDL);
    32.         void themNutPOCuoi(NUT *);
    33.         void themNutODau(KieuDL);
    34.         void themNutPODau(NUT *);
    35.         void themNutPTruocQ(NUT *,NUT *);
    36.         void themNutPSauQ(NUT *,NUT *);
    37.         KieuDL demNut(NUT *);
    38.         NUT *timNut(KieuDL);
    39.         NUT *nutMin();
    40.         void layNutP(NUT *);
    41.         void xoaNutP (NUT *);
    42.         void duyetDSLKKthuan();
    43.         void duyetDSLKKnghich();
    44.         void huyDSLKK();
    45.         bool DSLKKRong();
    46.         void quickSort();
    47.         void chuyen(char st[]);
    48.         void xuat();
    49. friend DSLKK* tongDuong(DSLKK *,DSLKK *);
    50. friend DSLKK* hieuDuong(DSLKK *,DSLKK *);
    51. friend DSLKK* tich_tam(DSLKK*,NUT *);
    52. friend DSLKK* tong(DSLKK *,DSLKK *,int );
    53. friend DSLKK* hieu(DSLKK *,DSLKK *,int);
    54. friend DSLKK* tich(DSLKK *,DSLKK *,int);
    55.  
    56. };
    57. int so_sanh_tam(char st1[],char st2[]);
    58. int so_sanh(char st1[],char st2[]);  
    59.  
    60. ////////////////////////////////////////////////////////////////////////////////////
    61. DSLKK::DSLKK()
    62. {    dau=cuoi=NULL;}
    63. /////////////////////////////////////////////////////////////////////////////////////
    64. void DSLKK::huyDSLKK()
    65. {
    66.     NUT *p;
    67.     while (dau!=NULL)
    68.     {
    69.         p=dau;
    70.         dau=dau->tiep;
    71.         dau->truoc=NULL;
    72.         delete p;
    73.     }
    74.     cuoi=dau=NULL;
    75. }
    76. /////////////////////////////////////////////////////////////////////////////////////
    77. DSLKK::~DSLKK()
    78. { huyDSLKK();}
    79. /////////////////////////////////////////////////////////////////////////////////////
    80. bool DSLKK::DSLKKRong()
    81. {    return (dau==NULL ? true:false);  }
    82. /////////////////////////////////////////////////////////////////////////////////////
    83.  
    84. void DSLKK::duyetDSLKKthuan()
    85. {
    86.     NUT *p=dau;
    87.     while(p!=NULL)
    88.     {
    89.         cout<<p->duLieu<<"  ";
    90.         p=p->tiep;
    91.     }
    92. }
    93. /////////////////////////////////////////////////////////////////////////////////////
    94. void DSLKK::duyetDSLKKnghich()
    95. {
    96.     NUT *p=cuoi;
    97.     while(p!=NULL)
    98.     {
    99.         cout<<p->duLieu<<"  ";
    100.         p=p->truoc;
    101.     }
    102. }
    103. /////////////////////////////////////////////////////////////////////////////////////    
    104. void DSLKK::themNutOCuoi(KieuDL duLieu)
    105. {
    106.     NUT *p=new NUT(duLieu);
    107.     if(DSLKKRong())
    108.         dau=cuoi=p;
    109.     else
    110.     {
    111.         cuoi->tiep=p;
    112.         p->truoc=cuoi;
    113.         cuoi=p;
    114.     }
    115. }
    116. /////////////////////////////////////////////////////////////////////////////////////
    117. void DSLKK::themNutODau(KieuDL duLieu)
    118. {
    119.     NUT *p=new NUT(duLieu);
    120.     if(DSLKKRong())
    121.         dau=cuoi=p;
    122.     else
    123.     {
    124.         p->tiep=dau;
    125.         dau->truoc=p;
    126.         dau=p;
    127.     }
    128. }
    129. /////////////////////////////////////////////////////////////////////////////////////
    130. //chuyen tu mang kieu char vao DSLKK
    131. void DSLKK::chuyen(char st[])
    132. {    
    133.     int i;
    134.     if(st[0]=='-')
    135.     {
    136.         this->sign=-1;
    137.         i=1;
    138.     }
    139.     else
    140.     {
    141.         this->sign=1;
    142.         i=0;
    143.     }    
    144.     while(st[i]!='\0')
    145.     {
    146.         char x=st[i];
    147.         KieuDL tam=atoi(&x);
    148.         this->themNutOCuoi(tam);
    149.         i++;
    150.     }
    151. }
    152. /////////////////////////////////////////////////////////////////////////////////////
    153. void DSLKK::xuat()
    154. {
    155.     if(this->sign==-1)
    156.         cout<<"-";
    157.     NUT *p;
    158.     NUT *q=this->dau;
    159.     while(q!=NULL&&q->duLieu==0)
    160.         q=q->tiep;
    161.     if(q==NULL)
    162.         cout<<0;
    163.     for(p=q;p!=NULL;p=p->tiep)
    164.         cout<<p->duLieu;
    165.     cout<<endl;
    166. }
    167. /////////////////////////////////////////////////////////////////////////////////////
    168. DSLKK * tongDuong(DSLKK *l1,DSLKK *l2)
    169. {
    170.     NUT *p=l1->cuoi;
    171.     NUT *q=l2->cuoi;
    172.     DSLKK *l;
    173.     l=new DSLKK();  
    174.     int s1,s2,sonho=0;
    175.     while(p!=NULL && q!=NULL)
    176.     {
    177.         s1=p->duLieu + q->duLieu+ sonho;
    178.         s2=s1%10;
    179.         if(p==l1->dau && q==l2->dau)
    180.         {
    181.             l->themNutODau(s1);
    182.         }
    183.         else
    184.         {
    185.             l->themNutODau(s2);
    186.         }
    187.         sonho=s1/10;
    188.         p=p->truoc;
    189.         q=q->truoc;
    190.     }
    191.     while(p!=NULL)
    192.     {
    193.         s1=p->duLieu+sonho;
    194.         s2=s1%10;
    195.         if(p==l1->dau)
    196.         {
    197.             l->themNutODau(s1);
    198.         }
    199.         else
    200.         {
    201.             l->themNutODau(s2);
    202.         }
    203.         sonho=s1/10;
    204.         p=p->truoc;
    205.     }
    206.     while(q!=NULL)
    207.     {
    208.         s1=q->duLieu+sonho;
    209.         s2=s1%10;
    210.         if(q==l2->dau)
    211.         {
    212.             l->themNutODau(s1);
    213.         }
    214.         else
    215.         {
    216.             l->themNutODau(s2);
    217.         }
    218.         sonho=s1/10;
    219.         q=q->truoc;
    220.     }
    221.     l->sign=1;
    222.     return l;
    223. }
    224. /////////////////////////////////////////////////////////////////////////////////////
    225.  
    226. DSLKK * hieuDuong(DSLKK *l1,DSLKK *l2)
    227. {
    228.     DSLKK *l=new DSLKK();
    229.     int g,h=0;
    230.     NUT *p=l1->cuoi;
    231.     NUT *q=l2->cuoi;
    232.     while(p!=NULL && q!=NULL)
    233.     {
    234.         g=p->duLieu - h- q->duLieu;
    235.         if(g<0)
    236.         {
    237.             l->themNutODau(10+g);
    238.             h=1;
    239.         }
    240.         else
    241.         {
    242.             l->themNutODau(g);
    243.             h=0;
    244.         }
    245.         p=p->truoc;
    246.         q=q->truoc;
    247.     }
    248.     while(p!=NULL)
    249.     {
    250.         g=p->duLieu-h;
    251.         if(g<0)
    252.         {
    253.             l->themNutODau(10+g);
    254.             h=1;
    255.         }
    256.         else
    257.         {
    258.             l->themNutODau(g);
    259.             h=0;
    260.         }
    261.         p=p->truoc;
    262.     }
    263.     return l;
    264. }
    265. /////////////////////////////////////////////////////////////////////////////////////
    266. DSLKK * tong(DSLKK *l1,DSLKK *l2,int SST)
    267. {
    268.     DSLKK *l=new DSLKK();
    269.     if(l1->sign==-1 &&l2->sign==-1)
    270.     {
    271.         l=tongDuong(l1,l2);
    272.         l->sign=-1;
    273.     }
    274.     if(l1->sign==1 && l2->sign==1)
    275.     {
    276.         l=tongDuong(l1,l2);
    277.         l->sign=1;
    278.     }
    279.     if(l1->sign==1 && l2->sign==-1)
    280.     {
    281.         if(SST==1)
    282.         {
    283.             l=hieuDuong(l1,l2);
    284.             l->sign=1;
    285.         }
    286.         else  
    287.             if(SST==-1)
    288.             {    
    289.                 l=hieuDuong(l2,l1);
    290.                 l->sign=-1;
    291.             }
    292.             else  
    293.                 if(SST==0)
    294.                 {            
    295.                     l->sign=1;
    296.                     l=hieuDuong(l1,l2);
    297.                 }
    298.     }
    299.     if(l1->sign==-1 && l2->sign==1)
    300.     {
    301.         if(SST==1)
    302.         {
    303.             l=hieuDuong(l1,l2);
    304.             l->sign=-1;
    305.         }
    306.         else  
    307.         {                        
    308.             l=hieuDuong(l2,l1);
    309.             l->sign=1;
    310.         }
    311.     }
    312.     return l;  
    313. }
    314. /////////////////////////////////////////////////////////////////////////////////////
    315. DSLKK * hieu(DSLKK *l1,DSLKK *l2,int SST)
    316. {    
    317.     DSLKK *l=new DSLKK();
    318.     DSLKK *l3=new DSLKK();
    319.     NUT *p;
    320.     int sign;
    321.     sign=l2->sign;
    322.     for(p=l2->cuoi;p!=NULL;p=p->truoc)
    323.         l3->themNutODau(p->duLieu);
    324.     l3->sign=-sign;
    325.     l=tong(l1,l3,SST);
    326.     return l;
    327. }
    328. /////////////////////////////////////////////////////////////////////////////////////
    329. DSLKK * tich_tam(DSLKK *l,NUT *A)
    330. {
    331.     int h=0,t;
    332.     DSLKK *lst=new DSLKK();
    333.     NUT *p;
    334.     for(p=l->cuoi;p!=NULL;p=p->truoc)
    335.     {
    336.         t=p->duLieu* A->duLieu+ h;
    337.         lst->themNutODau(t%10);
    338.         h=t/10;
    339.     }
    340.     if(h!=0)
    341.     {
    342.         lst->themNutODau(h);
    343.     }
    344.     lst->sign=1;
    345.     return lst;
    346. }
    347. /////////////////////////////////////////////////////////////////////////////////////
    348. DSLKK * tich(DSLKK *l1,DSLKK *l2,int SST)
    349. {
    350.     DSLKK *lst=new DSLKK();
    351.     DSLKK *temp=new DSLKK();
    352.     NUT *run;
    353.     NUT *k;
    354.     for(k=l2->cuoi;k!=NULL;k=k->truoc)
    355.     {
    356.         run=l2->cuoi;
    357.         temp=tich_tam(l1,k);
    358.         while(run!=k)
    359.         {
    360.             temp->themNutOCuoi(0);
    361.             run=run->truoc;
    362.         }
    363.         lst=tongDuong(lst,temp);
    364.     }
    365.     if((l1->sign*l2->sign)==1)
    366.         lst->sign=1;
    367.     else
    368.         lst->sign=-1;
    369.     return lst;
    370. }
    371. /////////////////////////////////////////////////////////////////////////////////////
    372. int so_sanh_tam(char st1[],char st2[])
    373. {
    374.     int len1,len2,i=0,j=0;
    375.     if(st1[0]=='-')
    376.         i=1;
    377.     if(st2[0]=='-')
    378.         j=1;
    379.     len1=strlen(st1)-i;
    380.     len2=strlen(st2)-j;
    381.     if(len1>len2)
    382.         return 1;
    383.     else
    384.         if(len1<len2)
    385.             return -1;
    386.         else
    387.         {
    388.             for(int k=0;k<len1;k++)
    389.                 if(atoi(&st1[k+i])>atoi(&st2[k+j]))
    390.                     return 1;
    391.                 else
    392.                     if(atoi(&st1[k+i])<atoi(&st2[k+j]))
    393.                         return -1;            
    394.             return 0;
    395.         }
    396. }
    397. /////////////////////////////////////////////////////////////////////////////////////
    398. int so_sanh(char st1[],char st2[])
    399. {    
    400.     if(st1[0]!='-' && st2[0]=='-')
    401.         return 1;
    402.     if(st1[0]=='-' && st2[0]!='-')
    403.         return -1;
    404.     if(st1[0]=='-' && st2[0]=='-')
    405.     {
    406.         if(so_sanh_tam(st1,st2)==1)
    407.             return -1;
    408.         else  
    409.             if(so_sanh_tam(st1,st2)==0)
    410.                 return 0;
    411.             else
    412.                 if(so_sanh_tam(st1,st2)==-1)
    413.                     return 1;
    414.     }        
    415.     if(st1[0]!='-' &&st2[0]!='-')
    416.     {
    417.         if(so_sanh_tam(st1,st2)==1)
    418.             return 1;
    419.         else if(so_sanh_tam(st1,st2)==0)
    420.             return 0;
    421.         else if(so_sanh_tam(st1,st2)==-1)
    422.             return -1;
    423.     }        
    424.     return 0;
    425. }  
    426.  
    427. void main()
    428. {
    429.     DSLKK *l1=new DSLKK();
    430.     DSLKK *l2=new DSLKK();
    431.     DSLKK *l=new DSLKK();
    432.     char st1[1001],st2[1001];
    433. //  Nhap:
    434.         cout<<"Nhap so nguyen thu nhat: ";
    435.         cin>>st1;
    436.         cout<<"Nhap so nguyen thu hai:  ";
    437.         cin>>st2;
    438.         int ssc=so_sanh_tam(st1,st2);
    439.         int ss=so_sanh(st1,st2);
    440.         l1->chuyen(st1);
    441.         cout<<"Nhap so thu nhat: ";
    442.         l1->xuat();
    443.         l2->chuyen(st2);
    444.         cout<<"Nhap so thu hai:  ";
    445.         l2->xuat();
    446.         int k=-1;
    447.     while(k<5)
    448.     {
    449.         cout<<"Chon tu 1 den 5"<<endl;
    450.         cout<<"1:Cong"<<endl;
    451.         cout<<"2:Tru"<<endl;
    452.         cout<<"3:Nhan"<<endl;
    453.         cout<<"4:So sanh"<<endl;
    454.         cout<<"5:Thoat"<<endl;
    455.         cout<<"Ban chon:";
    456.         cin>>k;
    457.         switch(k)
    458.         {
    459.         case 1:
    460.             {
    461.                 cout<<"    Tong hai so la:";
    462.                 l=tong(l1,l2,ssc);
    463.                 l->xuat();
    464.             }
    465.             break;
    466.         case 2:
    467.             {
    468.                 cout<<"    Hieu hai so la:";
    469.                 l=hieu(l1,l2,ssc);
    470.                 l->xuat();
    471.             }
    472.             break;
    473.         case 3:
    474.             {
    475.                 cout<<"    Tich hai so la:";
    476.                 l=tich(l1,l2,ssc);
    477.                 l->xuat();
    478.             }
    479.             break;
    480.         case 4:
    481.             {
    482.                 if(ss==1)
    483.                     cout<<"    So thu nhat > so thu hai";
    484.                 if(ss==-1)
    485.                     cout<<"    So thu nhat < so thu hai";
    486.                 if(ss==0)
    487.                     cout<<"    So thu nhat = so thu hai";
    488.                 cout<<endl;
    489.             }    
    490.             break;
    491.         }
    492.     }
    493.     getch();
    494. }
    Công cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.
    Đã được chỉnh sửa lần cuối bởi changtrai050188 : 13-12-2007 lúc 08:02 PM. Lý do: đưa code vào tagcode

  2. #2
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Code rất rõ ràng, tuy nhiên thiếu toán tử = và copy constructor nên bổ sung thêm.!

  3. #3
    Ngày gia nhập
    10 2008
    Bài viết
    9

    bạn có thể nói luôn cách giải hay thuật toán để chia và % 2 số nguyên lớn được không????
    Tôi nghĩ mãi không biết làm thế nào....
    hic
    thạnks
    Đã được chỉnh sửa lần cuối bởi mmtvvt : 01-01-2009 lúc 04:48 PM.

  4. #4
    Ngày gia nhập
    11 2008
    Bài viết
    21

    Trích dẫn Nguyên bản được gửi bởi mmtvvt Xem bài viết
    bạn có thể nói luôn cách giải hay thuật toán để chia và % 2 số nguyên lớn được không????
    Tôi nghĩ mãi không biết làm thế nào....
    hic
    thạnks
    Phép chia trên xâu ký tự thì mình làm thế này:

    Khởi tạo thương = 0

    1.Xét 2 số vd 14235236346 và 42324
    Thấy chênh nhau 6 chữ số: thêm 6 số 0 vào sau số thứ 2 => 42324000000
    So sánh thấy lớn hơn 14235236346
    => bỏ bớt 1 số 0 (còn 5 số 0)
    2.Tính 14235236346 - 4232400000 = 1002836346
    3.Tăng thương lên 10^5.

    Lặp lại bước 1 với 1002836346 và 42324
    ...

    => thực hiện tối đa 9n phép trừ ( n là số chữ số ) ngoài ra thêm 1 vài phép so sánh ( vẫn còn chậm lắm )

    Còn trên DSLK thì bạn tham khảo phép chia đa thức.
    Công cụ bảo vệ mã nguồn .NET mạnh nhất hiện tại, miễn phí cho các khách hàng đầu tiên đăng ký.
    Đã được chỉnh sửa lần cuối bởi regist : 03-05-2009 lúc 05:55 PM.

Các đề tài tương tự

  1. Khai báo class số nguyên sử dụng con trỏ. Mọi người góp ý!!!
    Gửi bởi davidpuskin trong diễn đàn Thảo luận, góp ý code C/C++ của bạn
    Trả lời: 5
    Bài viết cuối: 03-04-2012, 08:39 PM
  2. Cách tính lãi xuất trả góp trên ASP.NET?
    Gửi bởi daovthinh trong diễn đàn Thắc mắc lập trình ASP.NET
    Trả lời: 0
    Bài viết cuối: 07-06-2011, 01:13 PM
  3. Đố:một vài thú vị về thứ tự các số và phép toán trên kiểu số nguyên
    Gửi bởi Anonymous trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 6
    Bài viết cuối: 23-04-2011, 05:46 PM
  4. Lớp tính toán với số nguyên lớn bằng C++. Mong mọi người đóng góp ý kiến nhé
    Gửi bởi thangit trong diễn đàn Thảo luận, góp ý code C/C++ của bạn
    Trả lời: 14
    Bài viết cuối: 20-09-2008, 08:36 PM
  5. Các thao tác trên số nguyên trong lập trình C
    Gửi bởi PoPoPoPo trong diễn đàn Thủ thuật, Tutorials CTDL & Giải thuật
    Trả lời: 7
    Bài viết cuối: 11-10-2006, 01:42 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn