大整数相乘

自己想的，有些乱，理解简单，写的繁琐

思路是模拟小学算术，先将数字1的每一位乘以数字2的每一位，乘完后最大是11位，乘10次，所以用了char sResultnum[10][30]数组存放

然后根据位数补零

由于乘完后数字太大，我想的是用类似大数相乘的方法把它们相加

  1 #include <iostream>
  2 #include <windows.h>
  3 #include <WinNT.h>
  4 //int转char
  5 #define chartonumber(x) (x-'0')
  6 
  7 //大数相乘
  8 int mynum()
  9 {
 10     //数字1
 11     char sNum1[11] = "3216549873";
 12     //数字2
 13     char sNum2[11] = "3789465123";
 14     //数字1 的长度
 15     int num1len = strlen(sNum1);
 16     //数字二的长度
 17     int num2len = strlen(sNum2);
 18     //存放乘完结果
 19     char sResultnum[10][30] = { 0 };
 20     //存放加完结果
 21     char sjResultnum[21];
 22     memset(sjResultnum, '0', sizeof(sjResultnum));
 23     //结果数组的下标
 24     int order = 0;
 25     //乘法进位
 26     int carry = 0;
 27     //加法进位
 28     int jcarry = 0;
 29     //乘法过程
 30     for (int i = num2len - 1; i >= 0; i--)
 31     {
 32         //数字2的每一位
 33         int nNum2 = chartonumber(sNum2[i]);
 34         sResultnum[i][0] = '0';
 35         //新的一位，进位归零
 36         carry = 0;
 37         for (int j = num1len - 1; j >= 0; j--)
 38         {
 39             //数字1的每一位
 40             int nNum1 = chartonumber(sNum1[j]);
 41             //分别相乘
 42             int nResultnum = nNum2*nNum1;
 43             //上次运算是否有进位
 44             if (carry != 0)
 45             {
 46                 nResultnum += carry;
 47                 carry = 0;
 48             }
 49             //用来存放每一位相乘的结果
 50             char s[3] = { 0 };
 51             //int转char
 52             sprintf(s, "%d", nResultnum);
 53             //如果需要进位
 54             if (nResultnum >= 10)
 55             {
 56                 if (j == 0)
 57                 {
 58                     sResultnum[i][j] = s[0];
 59                 }
 60                 //把个位放入结果组
 61                 sResultnum[i][j + 1] = s[1];
 62                 carry = nResultnum / 10;
 63             }
 64             else
 65             {
 66                 sResultnum[i][j + 1] = s[0];
 67             }
 68         }    
 69         //乘出后的数字根据位数补零
 70         if (i < num2len - 1)
 71         {
 72             int x = strlen(sResultnum[i]);
 73             for (int k = x; k < x + (num2len - 1-i); k++)
 74             {
 75                 sResultnum[i][k] = '0';
 76             }
 77         }
 78     }
 79     //想来想去，到最后还是要用到大数相加，待补
 80 
 81     for (int i = 9; i >=0; i--)
 82     {
 83         int lennumber = sizeof(sjResultnum);
 84         int lennumber2 = strlen(sResultnum[i]);
 85         jcarry = 0;
 86         //608274935
 87         for (int j = lennumber2 - 1; j >= 0; j--)
 88         {
 89             lennumber--;
 90             //数字1的每一位
 91             int nNum1 = chartonumber(sjResultnum[lennumber]);
 92             int nNum2 = chartonumber(sResultnum[i][j]);
 93             //分别相加
 94             int jnResultnum = nNum2+nNum1;
 95             //上次运算是否有进位
 96             if (jcarry != 0)
 97             {
 98                 jnResultnum += jcarry;
 99                 jcarry = 0;
100             }
101             //用来存放每一位相加的结果
102             char s[3] = { 0 };
103             //int转char
104             sprintf(s, "%d", jnResultnum);
105             //如果需要进位
106             if (jnResultnum >= 10)
107             {
108                 if (j == 0)
109                 {
110                     sjResultnum[lennumber - 1] = s[0];
111                 }
112                 //把个位放入结果组
113                 sjResultnum[lennumber] = s[1];
114                 jcarry = jnResultnum / 10;
115             }
116             else
117             {
118                 sjResultnum[lennumber] = s[0];
119             }
120         
121         }
122     }
123     return 0;
124 }

 

下面是老师的方法，更加简便，示例

 

 1 #include "pch.h"
 2 #include"stdio.h"
 3 
 4 
 5 char *BigDataMutliply(char *DataA, char *DataB)
 6 {
 7     int alen = strlen(DataA);
 8     int blen = strlen(DataB);
 9     size_t size = sizeof(int)*(alen + blen);
10     int *TempResult = (int *)malloc(size);
11 
12     char *Result = (char *)malloc(sizeof(char)*(alen + blen + 1))
13         ;
14     memset(TempResult, 0, size);
15     //multiplicative  
16     //第一字符长度 123* 456
17     // 3* 456     == 
18     // 2* 456*10
19     // 1* 456*100
20 
21 
22     // temp[1] +=  3*6
23     // temp[2] +=  3*5
24     // temp[3] +=  3*4
25     // temp[2] +=  2*6
26     // temp[3] +=  2*5
27     // temp[3] +=  2*4
28     // temp[3] +=  1*6
29     // temp[4] +=  1*5
30     // temp[5] +=  1*4
31 
32     for (int i = 0; i < alen; i++)
33     {
34         //第二个字符长度
35         for (int j = 0; j < blen; j++)
36         {
37             TempResult[i + j + 1] += (DataA[i] - '0')*(DataB[j] - '0');
　　　　　　　　　//[1],[2],[3],[2],[3]...

38         }
39     }
40     //进位的地方
41     for (int i = alen + blen - 1; i > 0; i--)
42     {
43         if (TempResult[i] >= 10)
44         {
45             TempResult[i - 1] += TempResult[i] / 10;
46             TempResult[i] %= 10;
47         }
48     }
49     //获取结果最高位的下标
50     int i = 0;
51     while (TempResult[i] == 0)
52     {
53         i++;
54     }
55     int j;
56     for (j = 0; i < alen + blen; j++, i++)
57     {
58         Result[j] = TempResult[i] + '0';
59     }
60     Result[j] = '\0';
61     return Result;
62 }
63 
64 int main()
65 {
66     char a = '1';
67     char z = '0';
68 
69     int r = a - z;
70     char *A = "123";
71     char *B = "456";
72     char *res = BigDataMutliply(A, B);
73     printf_s("res=%s\n", res);
74     system("pause");
75     return 0;
76 }

 

转载于:https://www.cnblogs.com/mtbook/p/10628523.html