高精度算法

简介

高精度算法（High Accuracy Algorithm）是处理大数字的数学计算方法。在一般的科学计算中，会经常算到小数点后几百位或者更多，当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数，高精度算法是用计算机对于超大数据的一种模拟加，减，乘，除，乘方，阶乘，开方等运算。对于非常庞大的数字无法在计算机中正常存储，于是，将这个数字拆开，拆成一位一位的，或者是四位四位的存储到一个数组中， 用一个数组去表示一个数字，这样这个数字就被称为是高精度数。高精度算法就是能处理高精度数各种运算的算法，但又因其特殊性，故从普通数的算法中分离，自成一家。

高精度加法

    //高精度加法
    public static String high_precision_addition(String s1, String s2) {
        StringBuffer sb = new StringBuffer();
        int len1 = s1.length();
        int len2 = s2.length();
        //将字符串转换为数字,并且将字符转置便于计算.
        int[] a1 = new int[len1];
        for (int i = len1 - 1; i >= 0; i--) {
            a1[len1 - i - 1] = s1.charAt(i) - '0';
        }
        int[] a2 = new int[len2];
        for (int i = len2 - 1; i >= 0; i--) {
            a2[len2 - i - 1] = s2.charAt(i) - '0';
        }
        
        //数组ans用来保存相加后的结果
        int[] ans = new int[Math.max(len1, len2) + 1];
        int i = 0;
        for (; i < len1 && i < len2; i++) {
            int temp = a1[i] + a2[i] + ans[i];
            ans[i] = temp % 10;
            ans[i + 1] += temp / 10;
        }
        while (i < len1) {
            int temp = ans[i] + a1[i];
            ans[i] = temp % 10;
            ans[i + 1] += temp / 10;
            i++;
        }
        while (i < len2) {
            int temp = ans[i] + a2[i];
            ans[i] = temp % 10;
            ans[i + 1] += temp / 10;
            i++;
        }
        for (int j = ans.length - 1; j >= 0; j--) {
            //删除前导0;
            if (j == ans.length - 1 && ans[ans.length - 1] == 0) {
                continue;
            }
            sb.append(ans[j]);
        }
        return sb.toString();
    }

高精度减法:

提前比较两个字符串的大小，如果字符串1小于字符串2，那么两者进行交换，从而保证了字符串1是最大

 //高精度减法
    public static String high_precision_subtraction(String s1, String s2) {

        int aa = 0;
        if (!compare(s1, s2)) {
            String temp = s1;
            s1 = s2;
            s2 = temp;
            aa = 1;
        }
        StringBuffer sb = new StringBuffer();
        int len1 = s1.length();
        int len2 = s2.length();
        //将字符串转换为数字,并且将字符转置便于计算.
        int[] a1 = new int[len1];
        for (int i = len1 - 1; i >= 0; i--) {
            a1[len1 - i - 1] = s1.charAt(i) - '0';
        }
        int[] a2 = new int[len2];
        for (int i = len2 - 1; i >= 0; i--) {
            a2[len2 - i - 1] = s2.charAt(i) - '0';
        }

        int[] ans = new int[len1 + 1];

        int i = 0;
        for (; i < len1 && i < len2; i++) {
            int temp = a1[i] - a2[i] + ans[i];
            if (temp < 0) {
                ans[i + 1] -= 1;
                ans[i] = temp + 10;
            } else {
                ans[i] = temp;
            }
        }
        while (i < len1) {
            int temp = a1[i] + ans[i];
            if (temp < 0) {
                ans[i + 1] = -1;
                ans[i] = temp + 10;
            } else {
                ans[i] = temp;
            }
            i++;
        }
        //两个字符串都已经遍历完了之后，将判断最高位是否是小于等于0的数，如果是，那么将其去掉
        int max = len1;
        while (max >= 0 && ans[max] == 0) {
            max--;
        }
        //如果s1比s2小,则要提前加负数
        if (aa == 1) sb.append("-");
        
        for (int j = max; j >= 0; j--) {
            sb.append(ans[j]);
        }
        return sb.toString();


    }

    //比较两个字符串，如果str1 >= str2，返回true;否则返回false;
    private static boolean compare(String str1, String str2) {
        int len1 = str1.length();
        int len2 = str2.length();
        if (len1 != len2) return len1 > len2;
        for (int i = 0; i < len1; i++) {
            if (str1.charAt(i) != str2.charAt(i)) {
                return str1.charAt(i) > str2.charAt(i);
            }
        }
        return true;
    }

    public String substring (String num1, String num2) {
        if (lessThan(num1, num2)) {
            return "-" + sub(num2, num1);
        }
        return sub(num1, num2);
    }
    
    private String sub(String num1, String num2) {
        int borrow = 0;
        int i = num1.length() - 1, j = num2.length() - 1;
        StringBuilder builder = new StringBuilder();
        while (i >= 0 || j >= 0) {
            int a = i < 0 ? 0 : num1.charAt(i) - '0';
            int b = j < 0 ? 0 : num2.charAt(j) - '0';
            //借1当10
            int sub = (a - b - borrow + 10) % 10;
            borrow = a - b - borrow < 0 ? 1 : 0;
            builder.append((char) ('0' + sub));
            i--;
            j--;
        }
        String res = builder.reverse().toString();
        //删除前导0, 循环结束条件是res.length()-1是为防止"0000"的情况
        int k;
        for (k = 0; k < res.length() - 1; ++k) {
            if (res.charAt(k) != '0') {
                break;
            }
        }
        return res.substring(k);
    }
    
    private boolean lessThan(String a, String b) {
        if (a.length() == b.length()) {
            return a.compareTo(b) < 0;
        }
        return a.length() < b.length();
    }

高精度乘法:

具体步骤如下图:

代码如下:

public String high_precision_multiply(String num1, String num2) {
        if ( "0".equals(num1) ||"0".equals(num2)) return "0";
        StringBuffer sb = new StringBuffer();
        int n = num1.length();
        int m = num2.length();
        int[] nums = new int[m + n];
        for (int i = n - 1; i >= 0; i--) {
            for (int j = m - 1; j >= 0; j--) {
                int temp = (n - 1 - i) + (m - 1 - j);
                nums[temp] += (num1.charAt(i) - '0') * (num2.charAt(j) - '0');
            }
        }
        int temp = 0;
        for (int i = 0; i < nums.length; i++) {
            nums[i] += temp;
            temp = nums[i] / 10;
            nums[i] = nums[i] % 10;
            if(i==nums.length-1&&nums[i]==0){
                continue;
            }
            sb.insert(0,nums[i]);
        }

        return sb.toString();
    }
}

高精度除法:

高精度除法又可以分为两种:

高精度 除以 低精度:

//高精度除法:
    public static String high_precision_division(String A, int b) throws Exception {

        if (b == 0) {
            throw new Exception("除数不能为0!!!");
        }
        List<Integer> list = new ArrayList<Integer>();
        int len = A.length();
        for (int i = 0; i < len; i++) {
            list.add(Integer.parseInt(String.valueOf(A.charAt(i))));
        }
        List<Integer> ans = new ArrayList<Integer>();
        int r = 0;
        for (int i = 0; i < len; i++) {
            r = r * 10 + list.get(i);
            ans.add(r / b);
            r %= b;
        }
        //删除前导0
        int index = 0;
        while (ans.get(index) == 0) {
            index++;
        }
        StringBuffer sb = new StringBuffer();
        for (int i = index; i < ans.size(); i++) {
            sb.append(ans.get(i));
        }

        return sb.toString();

    }