java语言BigInteger减法模拟实现

在Java BigInteger 减法他们虽然用的是比较高级的一些算法，但我们可以实现像数学的日常使用的减法法则；

不过代码有点过于长，需要注意很多细节；

算法流程如下；

我用的虽然是自己构造的MyBigInteger 类但你们可以通过String类来进行减法；

1，我们有两个String来存储我们想要的大数；

2，然后最前面要判断是否期中一个String是为空？

若是         

        那么把结果给期中不为空的那一个

若不是

        那么要看两个String的长度哪一个比较长如果a的长度小于b或b小于a那么；

     比如 ；a =  234 b = 1234 那么要在a前面补零，因为我们需要从最后低位开始进行减法

在这个例子   0234 - 1234 从 4 开始减；所以补零很重要，否子我们的减法有问题

如果长度相等那么正好不需要补零；

然后需要把两个String 反过来，因为从最后一位开始减；

然后开始一位一位的减；

        有个函数判断a是大于小于还是等于b，

若 大于那么直接减

若等于那么

对应的结果 0

若小于

那么需要处理一下，我们可以以十进制为主来做一下操作

比如  a = 7 - b = 8 那么 a 先判断前面是否还有数

如果没有那么直接减

        如果有那么借以

a+=10；

a = 17；

a-b = 9；

carry = 1；

然后每次a 需要减一个 carry 

我们这样的思路可以实现BigInteger 的减法操作；

代码很多地方可以优化的，你们自己仔细看；

public String subtract(MyBigInteger s) {
        String sign = "+";
        int tmp[] = new int[this.SIZE + s.SIZE];
        int actualSize = 0;
        if (this.SIZE != 0 && s.SIZE == 0) {
            return this.toString();
        } else if (this.SIZE == 0 && s.SIZE != 0)
            return s.toString();
        else {
            int carry = 0;
            if (this.SIZE >= s.SIZE) {
                int i;
                for (i = 0; i < this.SIZE && i < s.SIZE; i++) {
                    int a = this.arr[i] - carry;
                    int b = s.arr[i];
                    if (bigSmallEqual(a, b) == 1) {
                        tmp[actualSize++] = a - b;
                        carry = 0;
                    } else if (bigSmallEqual(a, b) == -1) {
                        if (i < s.SIZE - 1) {
                            a += 10;  //需要从下一个数借1
                            carry = 1; //下次运算要减去carry
                            tmp[actualSize++] = a - b;
                        } else {
                            sign = "-";
                            tmp[actualSize++] = b - a;
                        }
                    } else {
                        carry = 0;
                        tmp[actualSize++] = 0;
                    }

                }
            } else if (this.SIZE - 1 < s.SIZE - 1) {
                sign = "-";

                int len = s.SIZE-this.SIZE;

                int []tp = new int[s.SIZE];
                int k;
                for(k = 0;k<len;k++){
                    tp[k] = 0;
                }
                for(int t = this.SIZE-1;t>=0;t--){
                    tp[k++] = this.arr[t];
                }

                reverseArr(tp);

                int i;
                for (i = 0; i < tp.length && i < s.SIZE; i++) {
                    int b  = tp[i];
                    int a = s.arr[i] - carry;
                    if (bigSmallEqual(a, b) == 1) {
                        tmp[actualSize++] = a - b;
                        carry = 0;
                    } else if (bigSmallEqual(a, b) == -1) {
                        if (i < this.SIZE - 1) {
                            a += 10;  //需要从下一个数借1
                            carry = 1; //下次运算要减去carry
                            tmp[actualSize++] = a - b;
                        } else {
                            sign = "-";
                            tmp[actualSize++] = b - a;
                        }
                    } else {
                        tmp[actualSize++] = 0;
                        carry = 0; //当两个都相等那么减法后是0不需要存储到数组
                    }

                }
            }
            
            String n = "";
            if (sign.charAt(0) == '-') //如果符号是-那么给他负数
                n += '-';

            int flag = 1;
            for (int i = actualSize - 1; i >= 0; i--) { //把开头的0去掉
                if(tmp[i]==0&&flag!=0){
                    while(tmp[i]==0)
                        i--;
                    flag=0;
                }
                n = n + "" + tmp[i];
            }

            return n;
        }
    }