使用链表实现高精度整数加减法运算(JAVA)

naeb

使用链表实现高精度整数加减法运算
输入数据可以采用每三位整数一组（中间加逗号），也可以不加逗号（比如： 100000000）。
（1）0；0；+ ，输出“0”。
（2）100，100，100；100，100，100，+，输出：200，200，200
（4）自选数据



问两个问题，我输入两个相同的数字后就会报错。另外我想要输入的数据中间加逗号要怎么改动？


请输入a：0
请输入b：0
请输入运算符：+
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: begin -3, end 0, length 0
        at java.base/java.lang.String.checkBoundsBeginEnd(String.java:3319)
        at java.base/java.lang.String.substring(String.java:1874)
        at test.CopyOfIntegerAddSub.displayWithComma(CopyOfIntegerAddSub.java:229)
        at test.CopyOfIntegerAddSub.main(CopyOfIntegerAddSub.java:33)

1. package test;
   
2. 
   
3. 
   
4. import java.util.HashMap;
   
5. import java.util.LinkedList;
   
6. import java.util.Map;
   
7. import java.util.Scanner;
   
8. 
   
9. public class CopyOfIntegerAddSub {
   
10. 
    
11.     public static void main(String[] args) {
    
12.         Scanner scan = new Scanner(System.in);
    
13.         System.out.print("请输入a：");
    
14.         String str_a = scan.next();
    
15.         LinkedList list_a = Str2List(str_a);
    
16.         System.out.print("请输入b：");
    
17.         String str_b = scan.next();
    
18.         LinkedList list_b = Str2List(str_b);
    
19.         System.out.print("请输入运算符：");
    
20.         String str_s = scan.next();
    
21.         String str_pd = check(str_a, str_b, str_s); // 检查
    
22.         Map map = Compare(list_a, list_b);
    
23. 
    
24.         LinkedList max = (LinkedList) map.get("max");
    
25.         LinkedList min = (LinkedList) map.get("min");
    
26.         LinkedList flag = (LinkedList) map.get("flag");
    
27.         //System.out.println(flag);
    
28. 
    
29.         if (str_pd.length() > 0) {
    
30.             System.out.println(str_pd);
    
31.         } else {
    
32.             if (str_s.equals("+")||max != min) {
    
33.                 String result_add = displayWithComma(add(max,min));
    
34.                 System.out.println("加法结果为：" + result_add);
    
35.             } else if (str_s.equals("-")||max!=min) {
    
36.                 String result_sub = displayWithComma(sub(max, min));
    
37.                 if(flag.getFirst().equals("-")){
    
38.                     result_sub = "-" + result_sub;
    
39.                 }
    
40.                 System.out.println("减法结果为：" + result_sub);
    
41.             }
    
42.         }
    
43. 
    
44.     }
    
45. 
    
46. 
    
47.     /**
    
48.      * 加法
    
49.      *
    
50.      * @param a
    
51.      * @param b
    
52.      * @return
    
53.      */
    
54.     private static String add(LinkedList max, LinkedList min) {
    
55.         int carry = 0; // 是否进位，1为进位
    
56.         int r = 0; // 每位相加的结果
    
57.         LinkedList result = new LinkedList();
    
58. 
    
59.         int size_max = max.size(); // 链表a的长度
    
60.         int size_min = min.size(); // 链表b的长度
    
61. 
    
62.         for (int i = 0; i < size_max; i++) {
    
63.             int max_i = Integer.parseInt(max.get(i).toString());
    
64.             int min_i;
    
65.             if (i < size_min) {
    
66.                 min_i = Integer.parseInt(min.get(i).toString());
    
67.             } else {
    
68.                 min_i = 0;
    
69.             }
    
70.             r = max_i + min_i + carry;
    
71.             if (r < 10) {
    
72.                 result.addFirst(r);
    
73.                 carry = 0;
    
74.             } else {
    
75.                 result.addFirst(r % 10);
    
76.                 carry = 1;
    
77.                 if (i == size_max - 1) { // 控制最后一次循环；如果不加，最后一位相加时，不会把1存入链表
    
78.                     result.addFirst(carry);
    
79.                 }
    
80.             }
    
81.         }
    
82. 
    
83.         String str = "";
    
84.         for (int i = 0; i < result.size(); i++) {
    
85.             str = str + result.get(i).toString();
    
86.         }
    
87.         return str;
    
88.     }
    
89. 
    
90. 
    
91.     /**
    
92.      * 减法
    
93.      *
    
94.      * @param a
    
95.      * @param b
    
96.      * @return
    
97.      */
    
98.     private static String sub(LinkedList max, LinkedList min) {
    
99.         int borrow = 0; // 是否借位 1借
    
100.         int r = 0; // 每位相减的结果
     
101.         LinkedList result = new LinkedList();
     
102. 
     
103.         int size_max = max.size(); // 链表a的长度
     
104.         int size_min = min.size(); // 链表b的长度
     
105. 
     
106.         for (int i = 0; i < size_max; i++) {
     
107.             int max_i = Integer.parseInt(max.get(i).toString());
     
108.             int min_i;
     
109.             if (i < size_min) {
     
110.                 min_i = Integer.parseInt(min.get(i).toString());
     
111.             } else {
     
112.                 min_i = 0;
     
113.             }
     
114.             r = max_i - min_i - borrow;
     
115.             if (r < 0) {
     
116.                 result.addFirst(r + 10);
     
117.                 borrow = 1;
     
118.             } else {
     
119.                 if (i == size_max - 1 && r == 0) { // 控制最后一次循环，两数相减如果为0，不显示0
     
120.                     break;
     
121.                 }
     
122.                 result.addFirst(r);
     
123.                 borrow = 0;
     
124.             }
     
125.         }
     
126. 
     
127.         String str = "";
     
128.         for (int i = 0; i < result.size(); i++) {
     
129.             str = str + result.get(i).toString();
     
130.         }
     
131.         return str;
     
132.     }
     
133. 
     
134. 
     
135.     /**
     
136.      * 比较大小
     
137.      * @param a
     
138.      * @param b
     
139.      * @return
     
140.      */
     
141.     private static Map<String, LinkedList> Compare(LinkedList a, LinkedList b) {
     
142. 
     
143.         Map<String, LinkedList> map = new HashMap<String, LinkedList>(); // 为了可以返回多个值
     
144. 
     
145.         int size_a = a.size(); // 链表a的长度
     
146.         int size_b = b.size(); // 链表b的长度
     
147. 
     
148.         LinkedList max = new LinkedList();
     
149.         LinkedList min = new LinkedList();
     
150. 
     
151.         LinkedList flag = new LinkedList();
     
152. 
     
153.         if (size_a > size_b) {
     
154.             max = a;
     
155.             min = b;
     
156.             flag.addFirst("+");
     
157.         } else if (size_a < size_b) {
     
158.             max = b;
     
159.             min = a;
     
160.             flag.addFirst("-");
     
161.         } else {
     
162.             for (int i = 0; i < size_a; i++) {
     
163.                 int a_i = Integer.parseInt(a.get(size_a - 1 - i).toString());
     
164.                 int b_i = Integer.parseInt(b.get(size_b - 1 - i).toString());
     
165.                 if (a_i == b_i) {
     
166.                     continue;
     
167.                 } else if (a_i < b_i) {
     
168.                     flag.addFirst("-");
     
169.                     max = b;
     
170.                     min = a;
     
171.                     break;
     
172.                 } else {
     
173.                     flag.addFirst("+");
     
174.                     max = a;
     
175.                     min = b;
     
176.                     break;
     
177.                 }
     
178.             }
     
179. 
     
180.         }
     
181.         map.put("max", max);
     
182.         map.put("min", min);
     
183.         map.put("flag", flag);
     
184.         return map;
     
185.     }
     
186. 
     
187. 
     
188.     /**
     
189.      * 把字符串传入链表
     
190.      *
     
191.      * @param str
     
192.      * @return
     
193.      */
     
194.     private static LinkedList Str2List(String str) {
     
195.         LinkedList<Character> list = new LinkedList<Character>();
     
196.         for (int i = 0; i < str.length(); i++) {
     
197.             char c = str.charAt(i);
     
198.             list.addFirst(c);
     
199. 
     
200.         }
     
201.         // System.out.println("输出："+list);
     
202.         return list;
     
203.     }
     
204. 
     
205. 
     
206.     /**
     
207.      * 处理字符串，每3位一格
     
208.      *
     
209.      * @param str
     
210.      * @return
     
211.      */
     
212.     public static String displayWithComma(String str) {
     
213.         str = new StringBuffer(str).reverse().toString(); // 先将字符串颠倒顺序
     
214.         String str2 = "";
     
215. 
     
216.         int size = (str.length() % 3 == 0) ? (str.length() / 3)
     
217.                 : (str.length() / 3 + 1); // 每三位取一长度
     
218. 
     
219.         /*
     
220.          * 比如把一段字符串分成n段,第n段可能不是三个数,有可能是一个或者两个,
     
221.          * 现将字符串分成两部分.一部分为前n-1段,第二部分为第n段.前n-1段，每一段加一",".而第n段直接取出即可
     
222.          */
     
223. 
     
224.             for (int i = 0; i < size - 1; i++) { // 前n-1段
     
225.                 str2 += str.substring(i * 3, i * 3 + 3) + ",";
     
226.             }
     
227. 
     
228.             for (int i = size - 1; i < size; i++) { // 第n段
     
229.                 str2 += str.substring(i * 3, str.length());
     
230.             }
     
231. 
     
232.             str2 = new StringBuffer(str2).reverse().toString();
     
233. 
     
234.             return str2;
     
235.         }
     
236. 
     
237. 
     
238.     /**
     
239.      * 判断是否为数字
     
240.      * @param str
     
241.      * @return
     
242.      */
     
243.     public static boolean isNumeric(String str) {
     
244.         for (int i = str.length(); --i >= 0;) {
     
245.             if (!Character.isDigit(str.charAt(i))) {
     
246.                 return false;
     
247.             }
     
248.         }
     
249.         return true;
     
250.     }
     
251. 
     
252. 
     
253.     /**
     
254.      * 检查合法性
     
255.      * @param str_a
     
256.      * @param str_b
     
257.      * @param str_s
     
258.      * @return
     
259.      */
     
260.     private static String check(String str_a, String str_b, String str_s) {
     
261.         boolean result = true;
     
262.         String str = "";
     
263.         if ( isNumeric(str_a) == false) {
     
264.             str = str + " a 为非法数值";
     
265.         }
     
266.         if (isNumeric(str_b) == false) {
     
267.             str = str + " b 为非法数值";
     
268.         }
     
269.         if (!((str_s.equals("+")) || (str_s.equals("-")))) {
     
270.             str = str + " 非法运算符";
     
271.         }
     
272.         return str;
     
273.     }
     
274. }

复制代码

isdkz

问题1：输入两个相同的数字后就会报错。
问题2：想要输入的数据中间加逗号要怎么改动？

首先，问题1是因为在 displayWithComma 函数中，当输入的字符串长度为 0 时，会导致计算 size 的逻辑出现问题。可以对此情况进行特殊处理，避免这个问题。问题2的话，我们可以在 Str2List 函数中先处理输入的字符串，去除其中的逗号。

解决方法如下：

修改 displayWithComma 函数，在开头添加对长度为 0 的特殊处理：

1. public static String displayWithComma(String str) {
   
2.     if (str.length() == 0) {
   
3.         return "0";
   
4.     }
   
5.     // 其余代码保持不变
   
6. }

复制代码

修改 Str2List 函数，在开始时添加一段代码以删除输入字符串中的逗号：

1. private static LinkedList Str2List(String str) {
   
2.     str = str.replace(",", ""); // 增加这一行，删除字符串中的逗号
   
3.     LinkedList<Character> list = new LinkedList<Character>();
   
4.     // 其余代码保持不变
   
5. }

复制代码

这样，问题1和问题2都应该得到解决。现在您可以输入带有逗号的数字，例如 "100,000,000"，程序也能正确处理。同时，输入两个相同的数字不再报错。

naeb

isdkz 发表于 2023-3-19 19:11
问题1：输入两个相同的数字后就会报错。
问题2：想要输入的数据中间加逗号要怎么改动？

改完后输入其他的数据输出结果都显示0，加入逗号后还是和以前一样会显示非法数值