Java实现高精度加减法-数据结构综合设计实验一

已于 2024-06-24 10:42:45 修改
阅读量319 收藏 5
点赞数 7
文章标签： java 开发语言 数据结构 算法
于 2024-06-22 14:24:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_74368189/article/details/139882201
版权

目录

测试类（主类）

双向链表类

测试类（主类）

import java.util.Scanner;

public class BigInt {

    /**
     * 处理用户输入的字符串，并将字符串以链表形式倒序存储
     */
    public static DoublyListNode<Integer> createListFromString(String str) {
        DoublyListNode<Integer> list = new DoublyListNode<>();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            int num = Character.getNumericValue(c);
            list.addFirst(num);
        }
        return list;
    }

    /**
     * 比较两个链表的绝对值大小
     */
    public static int compare(DoublyListNode list11, DoublyListNode list22) {//0是相等  1是list1大  2是 list2大
        int len1 = list11.size();
        int len2 = list22.size();
        DoublyListNode list1 = list11;
        DoublyListNode list2 = list22;
        if (list1.size() > list2.size()) {
            return 1;
        } else if (list1.size() < list2.size()) {
            return 2;
        } else  {
            DoublyListNode.Node head1 = list1.find(0);
            DoublyListNode.Node head2 = list2.find(0);
            while (len1 > 0 && len2 > 0) {
                if (head1.val > head2.val) {
                    return 1;
                } else if (head1.val < head2.val) {
                    return 2;
                } else {
                    head1 = head1.next;
                    head2 = head2.next;
                    len1--;
                    len2--;
                }
            }
        }
        return 0;
    }

    /**
     * 给长度短的链表添0
     */
    public static Object addZero(DoublyListNode list, int max) {
        int rnd = max - list.size();
        while (rnd-- > 0) {
            list.addLast(0);
        }
        return list;
    }

    /**
     *将两个链表的长度对齐
     */
    public static void alignList(DoublyListNode list1, DoublyListNode list2) {
        if (list1.size() != list2.size()) {
            int max = list1.size() > list2.size() ? list1.size() : list2.size();
            if (max == list1.size()) {
                addZero(list2, max);
            } else if (max == list2.size()) {
                addZero(list1, max);
            }
        }
    }


    /**
     * 加法的进位运算
     */
    public static void add(DoublyListNode list1, DoublyListNode list2) {
        DoublyListNode result = new DoublyListNode();
        int carry = 0;
        alignList(list1,list2);
        DoublyListNode.Node head1 = list1.find(0);
        DoublyListNode.Node head2 = list2.find(0);

        while (head2.next != null) {
            int res = head1.val + head2.val + carry;
            if (res >= 10) {
                carry = 1;
                res = res % 10;
                result.addFirst(res);
            } else {
                carry = 0;
                result.addFirst(res);
            }
            head1 = head1.next;
            head2 = head2.next;
        }
        if (carry == 1) result.addFirst(1);
        result.printLink();
        //result.printLinkWithComma();
    }

    /**
     * 减法的借位运算
     */
    public static void sub(DoublyListNode list1, DoublyListNode list2) {
        DoublyListNode result = new DoublyListNode();
        alignList(list1,list2);
        DoublyListNode.Node head1 = list1.find(0);
        DoublyListNode.Node head2 = list2.find(0);
        while (head2.next != null) {
            int borrow = 10;
            if (head1.val > head2.val) {
                int res = head1.val - head2.val;
                result.addFirst(res);
            } else if (head1.val < head2.val) {
                int res = head1.val + borrow - head2.val;
                head1.next.val -= 1;
                result.addFirst(res);
            } else if (head1.val == head2.val) {
                result.addFirst(0);
            }
            head1 = head1.next;
            head2 = head2.next;
        }
        DoublyListNode.Node head = result.find(0);
        if (head.val == 0) {
            while (head.val == 0) {
                result.removeFirst();
                head = head.next;
            }
        }
        result.printLink();
        //result.printLinkWithComma();
    }

    /**
     *处理'+'(加号)运算，涉及|绝对值|与正负号
     */
    public static void performAddition(int sign1, int sign2, DoublyListNode list1, DoublyListNode list2) {
        if(sign1 == 0 && sign2 == 0) {//a+b
            add(list1, list2);
        } else if(sign1 == 0 && sign2 == 1) {//a-b
            if(compare(list1, list2) == 1) {  //|a|>|b|
                sub(list1, list2);
            } else if(compare(list1, list2) == 2) {// |b| > |a|
                System.out.print("-");
                sub(list2, list1);
            } else if(compare(list1, list2) == 0) {
                System.out.println("0");
            }
        } else if(sign1 == 1 && sign2 == 0) {//-a +b ; b - a
            if(compare(list1, list2) == 2) {//|b| > |a|
                sub(list2, list1);
            } else if(compare(list1, list2) == 1) {//|a| > |b|
                System.out.print("-");
                sub(list1, list2);
            } else if(compare(list1, list2) == 0) {
                System.out.println("0");
            }
        } else if(sign1 == 1 && sign2 == 1) {//-a + (-b)   -(a+b)
            System.out.print("-");
            add(list1, list2);
        }
    }

    /**
     *处理'-'(减号)运算，涉及|绝对值|与正负号
     */
    public static void performSubtraction(int sign1, int sign2, DoublyListNode list1, DoublyListNode list2) {
        if(sign1 == 0 && sign2 == 0) {//a-b
            if(compare(list1, list2) == 1) {  //|a|>|b|
                sub(list1, list2);
            } else if(compare(list1, list2) == 2) {  // b > a
                System.out.print("-");
                sub(list2, list1);
            } else if(compare(list1, list2) == 0) {
                System.out.println("0");
            }
        } else if(sign1 == 0 && sign2 == 1) {//a - -b;  a+b
            add(list1, list2);
        } else if(sign1 == 1 && sign2 == 0) {//-a - b ; -(a+b)
            System.out.print("-");
            add(list1, list2);
        } else if(sign1 == 1 && sign2 == 1) {//a-b
            if(compare(list1, list2) == 2) {//|b| > |a|
                sub(list2, list1);
            } else if(compare(list1, list2) == 1) {//|a| > |b|
                System.out.print("-");
                sub(list1, list2);
            } else if(compare(list1, list2) == 0) {
                System.out.println("0");
            }
        }
    }

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个运算数：");
        String str1 = sc.nextLine();
        System.out.println("请输入第二个运算数：");
        String str2 = sc.nextLine();
        System.out.println("请输入运算符:");
        String opr = sc.nextLine();

        char li1 = str1.charAt(0), li2 = str2.charAt(0);
        int sign1 = 0, sign2=0;
        if (li1 == '-') {
            sign1 = 1;
            str1 = str1.substring(1);
        }
        if (li2 == '-') {
            sign2 = 1;
            str2 = str2.substring(1);
        }

        DoublyListNode<Integer> list1 = createListFromString(str1);
        DoublyListNode<Integer> list2 = createListFromString(str2);

        switch(opr) {
            case "+":
                performAddition(sign1, sign2, list1, list2);
                break;
            case "-":
                performSubtraction(sign1, sign2, list1, list2);
                break;
        }
       
    }
}

双向链表类

public class DoublyListNode<T> {
    static class Node {
        Node prev;
        int val;
        Node next;

        public Node(Node prev, int val, Node next) {
            this.prev = prev;
            this.val = val;
            this.next = next;
        }
    }

    public Node head;
    public Node tail;

    public DoublyListNode() {
        head = new Node(null, 0, null);
        tail = new Node(null, 0, null);
        head.next = tail;
        tail.prev = head;
    }

    /**
     * 返回链表长度
     */
    public int size() {
        Node head = find(0);
        int i = 0;
        while (head.next != null) {
            i++;
            head = head.next;
        }
        return i;
    }

    /**
     *查找第index个节点
     */
    public Node find(int index) {
        int i = -1;
        for(Node n = head; n != tail; n = n.next, i++) {
            if(i == index) {
                return n;
            }
        }
        return null;
    }

    /**
     *插入节点
     */
    public void insert(int index, int val) {
        Node prev = find(index - 1);
        Node next = prev.next;
        Node inserted = new Node(prev, val, next);
        prev.next = inserted;
        next.prev = inserted;
    }

    /**
     *头插法
     */
    public void addFirst(int val) {
        insert(0, val);
    }

    /**
     *尾插法
     */
    public void addLast(int val) {
        Node last = tail.prev;
        Node added = new Node(last, val, tail);
        last.next = added;
        tail.prev = added;
    }

    /**
     *把链表中第index号元素删除
     */
    public void remove(int index) {
        Node prev = find(index - 1);
        Node removed = prev.next;
        Node next = removed.next;
        prev.next = next;
        next.prev = prev;
    }

    /**
     * 把链表中第一个元素删除
     */
    public void removeFirst() {
        remove(0);
    }


    /**
     * 反转链表
     */
    public void reverse() {
        Node current = head.next;
        Node previous = null;

        while (current != null) {
            Node next = current.next;
            current.next = previous;
            current.prev = next;
            previous = current;
            current = next;
        }
        Node temp = head;
        head = tail;
        tail = temp;
    }


    /**
     * 打印链表
     */
    public void printLink() {
        Node head = find(0);
        if(head == null) {
            System.out.println("链表不存在");
        }
        else {
            while(head.next != null) {
                System.out.print(head.val);
                head = head.next;
            }
        }
    }

    /**
     * 打印链表，每三位输出一个逗号
     */
    public void printLinkWithComma() {
        Node head = find(0);
        if (head == null) {
            System.out.println("链表不存在");
        } else {
            int index = 0;
            while (head.next != null) {
                head = head.next;
                index++;
            }
            head = find(0);
            int cou =  index % 3;
            int i = 0;
            switch (cou) {
                case 0:
                    while (head.next != null) {
                        System.out.print(head.val);
                        head = head.next;
                        i++;
                        if(i == 3 && head.next!=null) {
                            System.out.print(",");
                            i = 0;
                        }
                    }
                    break;
                case 1:
                    int case1 = 1;
                    while (head.next != null) {
                        System.out.print(head.val);
                        head = head.next;
                        i++;
                        if(i == case1 && head.next!=null) {
                            System.out.print(",");
                            case1 = -1;
                            i = 0;
                        }
                        if(i == 3 && head.next!=null) {
                            System.out.print(",");
                            i = 0;
                        }
                    }
                    break;
                case 2:
                    int case2 = 2;
                    while (head.next != null) {
                        System.out.print(head.val);
                        head = head.next;
                        i++;
                        if(i == case2 && head.next!=null) {
                            System.out.print(",");
                            case2 = -1;
                            i = 0;
                        }
                        if(i == 3 && head.next!=null) {
                            System.out.print(",");
                            i = 0;
                        }
                    }
                    break;
            }
        }
    }

}

实验结果：

如果您想让结果每三位用逗号分隔，将测试类中的add和sub方法中 printLinkWithComma的注释删除。

zip54876
关注
数据结构实验一 用链表实现大整数加减法
m0_61506053的博客
03-31 4128
题目： 用链表实现大整数加减法操作： 32位机器直接操作的数据最大为32个bit，若超过32bit，则需要单独设计算法。在这里，可以用链表每个结点存储大整数的每一位的十进制数字，则可以进行大整数的算数运算，该实验仅实现加减法操作。 要求: 随机产生2个1~50位的数字串，并存储到2个链表中。 进行加法或减法操作，结果存储到新的链表中。 打印运算结果。 目录 BigInteger.h BigInteger.cpp function.h function.cpp main.cpp ..
JAVA实现高精度整数加减乘
wayne_lee_lwc的博客
02-09 2599
首先，需要指出的是，java内的BigInteger类很好用，功能相当全面。像加减乘这样的基础操作都是可以胜任的。所以，在java中其实没有手动实现高精度的必要。 所以写下这篇博客的初衷并不是放在实际情况下使用，而是当做高精度算法的练习，也同时练习java编程能力。 封装类内容： 实现接口 克隆接口Cloneable，重写clone方法。便于复制 可比较接口Comparable，实现Compare...
高精度加减法（超详细）
s_m_c的博客
09-11 468
给定你一个长度为 n 的整数数列。请你使用快速排序对这个数列按照从小到大进行排序。并将排好序的数列按顺序输出。输入格式输入共两行，第一行包含整数 n。第二行包含 n 个整数（所有整数均在 1∼109 范围内），表示整个数列。输出格式输出共一行，包含 n 个整数，表示排好序的数列。数据范围1≤n≤100000输入样例：53 1 2 4 5输出样例：1 2 3 4 5。
java 模拟 减法 进位_JAVA实现高精度整数加减乘
weixin_36376879的博客
02-27 178
首先，需要指出的是，java内的BigInteger类很好用，功能相当全面。像加减乘这样的基础操作都是可以胜任的。所以，在java中其实没有手动实现高精度的必要。所以写下这篇博客的初衷并不是放在实际情况下使用，而是当做高精度算法的练习，也同时练习java编程能力。封装类内容：实现接口克隆接口Cloneable，重写clone方法。便于复制可比较接口Comparable，实现CompareTo方法，...
【算法】高精度减法（Java）
qq_53408145的博客
04-29 877
介绍 高精度减法：实现两个大整数相减，代码实现过程类似于纸上进行减法运算 实现思路 将两个整数按位存储到列表中，设置一个 t 进行借位标识，同时在运算之前要进行大小比较 举例 【题目描述】 给定两个正整数（不含先导0），计算它们的差，计算结果可能为负数 【输入格式】 共两行，每行包含一个整数 【输出格式】 共一行，表示所求的差 【数据范围】 1 ≤ 整数长度 ≤ 1e5 代码实现 import java.util.*; public class Main{ public static void
高精度实数计算（链表实现）
weixin_73620289的博客
12-04 1335
基础基础基础的高精度算法（目前包括加法，减法，乘法）
超长整型加减法报告
roc13718296531的博客
12-23 1291
使用链表完成超长整数加减法；java
11 -- 12. Java学习 -- 实用类介绍、异常、单列集合Collection、常见的数据结构
ACDBBB的博客
07-21 779
程序在执行过程中出现意外的情况，如果不处理程序就会卡住，而不再向下执行。Throwable()：创建一个描述信息为空的Throwable对象Throwable(String message)：创建一个指定描述信息Throwable对象toString()：获取Throwable对象的全限定名getMessage()：获取Throwable对象的描述信息printStackTrace()：在控制台打印异常的信息。
Java程序设计基础--------运算符
double_happy111的博客
01-13 3052
Java程序设计基础--------运算符 文章目录Java程序设计基础--------运算符1.算数运算符1.1一元运算符1.2二元运算符1.3算数赋值运算符2.赋值运算符3.逻辑运算符4.关系运算符5.自增自减运算符6.位运算符6.1位逻辑运算符6.2位与运算符6.3位或运算符6.4位异或运算符6.5位取反运算符6.6位移运算符6.7复合位赋值运算7.条件运算符8.运算符优先级9.直接量9.1...
高精度加减计算（链表）
05-12
总结一下，高精度加减计算的关键在于正确处理进位和借位，并有效地利用数据结构（如双向链表）来存储和操作大整数。虽然乘除法的实现更复杂，但基本思路相同，都是基于位操作和适当的算法。对于需要高精度计算的应用...
高精度运算_高精度运算_
09-29
综上所述，高精度运算是一门涵盖广泛计算理论和技术的学科，不仅涉及到基本的数学运算，还包括高效的算法设计、数据结构选择以及编程实现。理解和掌握这些知识点对于解决实际问题和开发相关应用至关重要。
GaoJingDu.rar_除法_高精度除法
09-24
在实现过程中，可以使用链表、数组或其他数据结构来存储这些位，并进行相应的操作。 二、高精度乘法 高精度乘法通常采用Karatsuba算法或Toom-Cook算法等高效算法。这些算法通过分治策略将两个大数的乘法转化为较小...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 414
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 757
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 518
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1202
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 790
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 320
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
高精度运算：实现加法、减法、乘法与除法
为了实现高精度运算，需要自定义数据结构和算法来模拟常规算术运算。 在给定的描述中，我们看到一个具体的高精度减法例子。这个例子展示了如何计算一个数减去它的平方的高精度结果。以下是详细步骤： 1. 初始化：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值