大整数处理

2019年12月7日 331次阅读

处理两大数相乘，以下为Java代码：

 
 
    
  
  
  1. public class BigInt { 
    2. 
  
  
  2.  
    3. 
  
  
  3.     /** 
    4. 
  
  
  4.      * @param args 
    5. 
  
  
  5.      */ 
    6. 
  
  
  6.     public static void main(String[] args) { 
    7. 
  
  
  7.         String num1 = "1234" ; 
    8. 
  
  
  8.         String num2 = "56789" ; 
    9. 
  
  
  9.          
    10. 
  
  
  10.         mult(num1, num2) ; 
    11. 
  
  
  11.     } 
    12. 
  
  
  12.      
    13. 
  
  
  13.     /** 
    14. 
  
  
  14.      * 直接输出任意两数相乘 
    15. 
  
  
  15.      * @param n1 
    16. 
  
  
  16.      * @param n2 
    17. 
  
  
  17.      */ 
    18. 
  
  
  18.     public static void mult(String n1, String n2) { 
    19. 
  
  
  19.         int[] result = new int[n1.length()+n2.length()] ; // 这里为存放两数相乘后的得数。这个可以动态规划 
    20. 
  
  
  20.          
    21. 
  
  
  21.         // 字符串转数字数组处理，算法的效率就是在这些地方浪费的 
    22. 
  
  
  22.         int[] num1 = new int[n1.length()] ; 
    23. 
  
  
  23.         int[] num2 = new int[n2.length()] ; 
    24. 
  
  
  24.         for(int i = 0; i < n1.length(); i++) { 
    25. 
  
  
  25.             num1[i] = Character.getNumericValue(n1.charAt(i)) ; 
    26. 
  
  
  26.         } 
    27. 
  
  
  27.         for(int i = 0; i < n2.length(); i++) { 
    28. 
  
  
  28.             num2[i] = Character.getNumericValue(n2.charAt(i)) ; 
    29. 
  
  
  29.         } 
    30. 
  
  
  30.          
    31. 
  
  
  31.         // 核心代码，其实简单来说就是我们笔算怎么算，代码就怎么算，这样无论多大的数，都是可以算的 
    32. 
  
  
  32.         // 里面稍微做了些细致的处理，认真看很容易就能明白 
    33. 
  
  
  33.         int tempNum ; 
    34. 
  
  
  34.         int tt ; 
    35. 
  
  
  35.         for(int i = num1.length-1; i >= 0; i--) { 
    36. 
  
  
  36.             for(int j = num2.length-1; j >= 0; j--) { 
    37. 
  
  
  37.                 tempNum = num1[i] * num2[j] ; 
    38. 
  
  
  38.                 tt = result.length - (num1.length-i) - (num2.length-j) ; 
    39. 
  
  
  39.                 if(tempNum >= 10) { 
    40. 
  
  
  40.                     f(result, tt, tempNum % 10) ; 
    41. 
  
  
  41.                     f(result, tt-1, tempNum / 10) ; 
    42. 
  
  
  42.                 }else { 
    43. 
  
  
  43.                     f(result, tt, tempNum) ; 
    44. 
  
  
  44.                 } 
    45. 
  
  
  45.                  
    46. 
  
  
  46.             } 
    47. 
  
  
  47.         } 
    48. 
  
  
  48.  
    49. 
  
  
  49.         // 输出，这仅仅只是将数组前面的0去掉，去实际的答案 
    50. 
  
  
  50.         boolean found = false ; 
    51. 
  
  
  51.         for(int t : result) { 
    52. 
  
  
  52.             if(t != 0 && found == false) { 
    53. 
  
  
  53.                 System.out.print(t) ; 
    54. 
  
  
  54.                 found = true ; 
    55. 
  
  
  55.             }else if(found == true) { 
    56. 
  
  
  56.                 System.out.print(t) ; 
    57. 
  
  
  57.             } 
    58. 
  
  
  58.         } 
    59. 
  
  
  59.         System.out.println() ; 
    60. 
  
  
  60.          
    61. 
  
  
  61.     } 
    62. 
  
  
  62.      
    63. 
  
  
  63.     /** 
    64. 
  
  
  64.      * 相乘后相加处理，有关于两数相加后>=10的时候应该怎么进一位的处理， 
    65. 
  
  
  65.      * 知道不在有进一位为止 
    66. 
  
  
  66.      * @param result 
    67. 
  
  
  67.      * @param tTe 
    68. 
  
  
  68.      * @param tempNum1 
    69. 
  
  
  69.      */ 
    70. 
  
  
  70.     public static void f(int[] result, int tTe, int tempNum1) { 
    71. 
  
  
  71.         int t ; 
    72. 
  
  
  72.         while(true) { 
    73. 
  
  
  73.             if(result[tTe+1] + tempNum1 >= 10) { 
    74. 
  
  
  74.                 t = result[tTe+1] ; 
    75. 
  
  
  75.                 result[tTe+1] = (result[tTe+1] + tempNum1) % 10 ;  
    76. 
  
  
  76.                 tTe-- ; 
    77. 
  
  
  77.                 tempNum1 = (t + tempNum1) / 10 ; 
    78. 
  
  
  78.             }else { 
    79. 
  
  
  79.                 result[tTe+1] += tempNum1 ; 
    80. 
  
  
  80.                 break ; 
    81. 
  
  
  81.             } 
    82. 
  
  
  82.         } 
    83. 
  
  
  83.     } 
    84. 
  
  
  84.  
    85. 
  
  
  85. } 
    86. 
 
 

虽说类库里面有大数处理类，但为了提高算法水平，还是自己写了下，希望对大家学习有帮助。
 
点赞