C++链表大数加减

已于 2022-03-24 22:17:07 修改
阅读量680 收藏 13
点赞数 4
文章标签： 链表 c++ 数据结构
于 2022-02-04 11:07:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60368041/article/details/122781750
版权

用链表实现大整数相加减（C++大作业）

题目要求：
在这里插入图片描述
代码实现：

#include <cstdio>
#include <cstdlib>
constexpr bool Positive = 0;
constexpr bool Negative = 1;
template <typename DataType>
struct Node
{
    DataType data;
    Node* prev;
    Node* next;
    Node(DataType data = DataType(), Node* prev = nullptr, Node* next = nullptr) : data(data), prev(prev), next(next) {}
};
template <typename DataType>
class List
{
public:
    List() : symbol(Positive), size(0)
    {
        header = new Node<DataType>;
        tailer = new Node<DataType>;
        header->next = tailer;
        tailer->prev = header;
    }
    void readInteger()
    {
        header = new Node<int>;
        tailer = new Node<int>;
        header->next = tailer;
        tailer->prev = header;
        Node<int>* current = header;
        char ch = 0;
        ch = getchar();
        if (ch == '-')
        {
            symbol = Negative;
            ch = getchar();
        }
        while (ch != '\n')
        {
            if (ch == ',')
            {
                ch = getchar();
                continue;
            }
            Node<int>* node = new Node<int>(ch - '0', current, tailer);
            current->next = node;
            tailer->prev = node;
            current = node;
            ch = getchar();
            ++size;
        }
    }
    bool sign()
    {
        return this->symbol;
    }
    int length()
    {
        return this->size;
    }
    Node<DataType>* cbegin()
    {
        return this->header;
    }
    Node<DataType>* cend()
    {
        return this->tailer;
    }
    void setSign(bool symbol)
    {
        this->symbol = symbol;
        return;
    }
    void setLength(int size)
    {
        this->size = size;
        return;
    }
    void setHead(Node<DataType>* header)
    {
        this->header = header;
        return;
    }
    void setTail(Node<DataType>* tailer)
    {
        this->tailer = tailer;
        return;
    }
private:
    bool symbol;
    int size;
    Node<DataType>* header;
    Node<DataType>* tailer;
};
class BigInteger
{
public:
    BigInteger(bool symbol = Positive, int size = 1) : symbol(symbol), size(size)
    {
        header = new Node<int>;
        tailer = new Node<int>;
        header->next = tailer;
        tailer->prev = header;
        Node<int>* node = new Node<int>(0, header, tailer);
        header->next = node;
        tailer->prev = node;
    }
    BigInteger(bool symbol, int size, Node<int>* header, Node<int>* tailer) : symbol(symbol), size(size), header(header), tailer(tailer) {}
    BigInteger(List<int> list) : symbol(list.sign()), size(list.length()), header(list.cbegin()), tailer(list.cend()) {}
    bool sign()
    {
        return this->symbol;
    }
    int length()
    {
        return this->size;
    }
    Node<int>* cbegin()
    {
        return this->header;
    }
    Node<int>* cend()
    {
        return this->tailer;
    }
    void setSign(bool symbol)
    {
        this->symbol = symbol;
        return;
    }
    void setLength(int size)
    {
        this->size = size;
        return;
    }
    void setHead(Node<int>* header)
    {
        this->header = header;
        return;
    }
    void setTail(Node<int>* tailer)
    {
        this->tailer = tailer;
        return;
    }
    void print()
    {
        if (header != nullptr && header->next != nullptr)
        {
            Node<int>* current = header->next;
            int sum = symbol + size;
            int tmp = sum;
            if (symbol == Negative)
            {
                putchar('-');
                --sum;
            }
            while (sum)
            {
                if (sum % 3 == 0 && sum != tmp)
                {
                    putchar(',');
                }
                putchar(current->data + '0');
                current = current->next;
                --sum;
            }
            putchar('\n');
        }
    }
    void print(Node<int>* head)
    {
        while (head != nullptr)
        {
            printf("%d", head->data);
            head = head->next;
        }
        printf("\n");
        return;
    }
    void print(Node<int>* tail, int val)
    {
        while (tail != nullptr)
        {
            printf("%d", tail->data);
            tail = tail->prev;
        }
        printf("\n");
        return;
    }
    void print(BigInteger bigInteger)
    {
        if (bigInteger.cbegin() != nullptr && bigInteger.cbegin()->next != nullptr)
        {
            Node<int>* current = bigInteger.cbegin()->next;
            int sum = bigInteger.sign() + bigInteger.length();
            int tmp = sum;
            if (bigInteger.sign())
            {
                putchar('-');
                --sum;
            }
            while (sum)
            {
                if (sum % 3 == 0 && sum != tmp)
                {
                    putchar(',');
                }
                putchar(current->data + '0');
                current = current->next;
                --sum;
            }
            putchar('\n');
        }
    }
private:
    bool symbol;
    int size;
    Node<int>* header;
    Node<int>* tailer;
};
class Calculation
{
public:
    void print(BigInteger bigInteger)
    {
        if (bigInteger.cbegin() != nullptr && bigInteger.cbegin()->next != nullptr)
        {
            Node<int>* current = bigInteger.cbegin()->next;
            int sum = bigInteger.sign() + bigInteger.length();
            int tmp = sum;
            if (bigInteger.sign())
            {
                putchar('-');
                --sum;
            }
            while (sum)
            {
                if (sum % 3 == 0 && sum != tmp)
                {
                    putchar(',');
                }
                putchar(current->data + '0');
                current = current->next;
                --sum;
            }
            putchar('\n');
        }
    }
    BigInteger add(BigInteger bigInteger1, BigInteger bigInteger2)
    {
        if (bigInteger1.sign() == Positive && bigInteger2.sign() == Positive)
        {
            Node<int>* node1 = new Node<int>;
            Node<int>* node2 = new Node<int>;
            Node<int>* head = new Node<int>;
            Node<int>* tail = new Node<int>;
            head->next = tail;
            tail->prev = head;
            Node<int>* curr = tail;
            if (bigInteger1.cend() != nullptr && bigInteger1.cend()->prev != nullptr)
            {
                node1 = bigInteger1.cend()->prev;
            }
            if (bigInteger2.cend() != nullptr && bigInteger2.cend()->prev != nullptr)
            {
                node2 = bigInteger2.cend()->prev;
            }
            int carry = 0;
            int sum = 0;
            int size = 0;
            while (node1 != bigInteger1.cbegin() || node2 != bigInteger2.cbegin() || carry > 0)
            {
                sum = (node1 == bigInteger1.cbegin() ? 0 : node1->data) + (node2 == bigInteger2.cbegin() ? 0 : node2->data) + carry;
                carry = sum / 10;
                sum %= 10;
                Node<int>* node = new Node<int>(sum, head, curr);
                ++size;
                head->next = node;
                curr->prev = node;
                curr = node;
                node1 = node1 == bigInteger1.cbegin() ? bigInteger1.cbegin() : node1->prev;
                node2 = node2 == bigInteger2.cbegin() ? bigInteger2.cbegin() : node2->prev;
            }
            return BigInteger(Positive, size, head, tail);
        }
        if (bigInteger1.sign() == Negative && bigInteger2.sign() == Negative)
        {
            return opposite(add(opposite(bigInteger1), opposite(bigInteger2)));
        }
        if (bigInteger1.sign() == Positive && bigInteger2.sign() == Negative)
        {
            return sub(bigInteger1, opposite(bigInteger2));
        }
        if (bigInteger1.sign() == Negative && bigInteger2.sign() == Positive)
        {
            return add(bigInteger2, bigInteger1);
        }
        return BigInteger();
    }
    int compare(BigInteger bigInteger1, BigInteger bigInteger2)
    {
        if (bigInteger1.sign() == Positive && bigInteger2.sign() == Negative)
        {
            return 1;
        }
        if (bigInteger1.sign() == Negative && bigInteger2.sign() == Positive)
        {
            return -1;
        }
        if (bigInteger1.sign() == Positive && bigInteger2.sign() == Positive)
        {
            if (bigInteger1.length() > bigInteger2.length())
            {
                return 1;
            }
            if (bigInteger1.length() < bigInteger2.length())
            {
                return -1;
            }
            Node<int>* node1 = new Node<int>;
            Node<int>* node2 = new Node<int>;
            if (bigInteger1.cbegin() != nullptr && bigInteger1.cbegin()->next != nullptr)
            {
                node1 = bigInteger1.cbegin()->next;
            }
            if (bigInteger2.cbegin() != nullptr && bigInteger2.cbegin()->next != nullptr)
            {
                node2 = bigInteger2.cbegin()->next;
            }
            while (node1 != bigInteger1.cend())
            {
                if (node1->data > node2->data)
                {
                    return 1;
                }
                if (node1->data < node2->data)
                {
                    return -1;
                }
                node1 = node1->next;
                node2 = node2->next;
            }
            return 0;
        }
        if (bigInteger1.sign() == Negative && bigInteger2.sign() == Negative)
        {
            if (bigInteger1.length() > bigInteger2.length())
            {
                return -1;
            }
            if (bigInteger1.length() < bigInteger2.length())
            {
                return 1;
            }
            Node<int>* node1 = new Node<int>;
            Node<int>* node2 = new Node<int>;
            if (bigInteger1.cbegin() != nullptr && bigInteger1.cbegin()->next != nullptr)
            {
                node1 = bigInteger1.cbegin()->next;
            }
            if (bigInteger2.cbegin() != nullptr && bigInteger2.cbegin()->next != nullptr)
            {
                node2 = bigInteger2.cbegin()->next;
            }
            while (node1 != bigInteger1.cend())
            {
                if (node1->data > node2->data)
                {
                    return -1;
                }
                if (node1->data < node2->data)
                {
                    return 1;
                }
            }
            return 0;
        }
        return 0;
    }
    BigInteger sub(BigInteger bigInteger1, BigInteger bigInteger2)
    {
        if (bigInteger1.sign() == Positive && bigInteger2.sign() == Positive)
        {
            if (compare(bigInteger1, bigInteger2) == 1)
            {
                Node<int>* node1 = new Node<int>;
                Node<int>* node2 = new Node<int>;
                Node<int>* head = new Node<int>;
                Node<int>* tail = new Node<int>;
                head->next = tail;
                tail->prev = head;
                Node<int>* curr = tail;
                if (bigInteger1.cend() != nullptr && bigInteger1.cend()->prev != nullptr)
                {
                    node1 = bigInteger1.cend()->prev;
                }
                if (bigInteger2.cend() != nullptr && bigInteger2.cend()->prev != nullptr)
                {
                    node2 = bigInteger2.cend()->prev;
                }
                int carry = 0;
                int res = 0;
                int size = 0;
                while (node1 != bigInteger1.cbegin() || node2 != bigInteger2.cbegin())
                {
                    res = (node1 == bigInteger1.cbegin() ? 0 : node1->data) - (node2 == bigInteger2.cbegin() ? 0 : node2->data) - carry;
                    if (carry == 1)
                    {
                        carry = 0;
                    }
                    if (res < 0)
                    {
                        carry = 1;
                        res += 10;
                    }
                    Node<int>* node = new Node<int>(res, head, curr);
                    ++size;
                    head->next = node;
                    curr->prev = node;
                    curr = node;
                    node1 = node1 == bigInteger1.cbegin() ? bigInteger1.cbegin() : node1->prev;
                    node2 = node2 == bigInteger2.cbegin() ? bigInteger2.cbegin() : node2->prev;
                }
                while (head->next->data == 0)
                {
                    --size;
                    head = head->next;
                }
                return BigInteger(Positive, size, head, tail);
            }
            else if (compare(bigInteger1, bigInteger2) == -1)
            {
                return opposite(sub(bigInteger2, bigInteger1));
            }
            else
            {
                return BigInteger(Positive, 1);
            }
        }
        if (bigInteger1.sign() == Negative && bigInteger2.sign() == Negative)
        {
            return sub(opposite(bigInteger2), opposite(bigInteger1));
        }
        if (bigInteger1.sign() == Positive && bigInteger2.sign() == Negative)
        {
            return add(bigInteger1, opposite(bigInteger2));
        }
        if (bigInteger1.sign() == Negative && bigInteger2.sign() == Positive)
        {
            return opposite(add(opposite(bigInteger1), bigInteger2));
        }
        return BigInteger();
    }
    BigInteger opposite(BigInteger bigInteger)
    {
        return BigInteger(!bigInteger.sign(), bigInteger.length(), bigInteger.cbegin(), bigInteger.cend());
    }
};
int main()
{
    int n = 0;
    scanf_s("%d", &n);
    getchar();
    while (n--)
    {
        char c = 0;
        c = getchar();
        getchar();
        List<int> list1;
        list1.readInteger();
        List<int> list2;
        list2.readInteger();
        BigInteger bigInteger1(list1);
        BigInteger bigInteger2(list2);
        Calculation calculation;
        switch (c)
        {
        case '+':
            calculation.print(calculation.add(bigInteger1, bigInteger2));
            break;
        case '-':
            calculation.print(calculation.sub(bigInteger1, bigInteger2));
            break;
        default:
            break;
        }
    }
    return 0;
}
m0_60368041
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
数据结构：利用单链表实现大数运算（C++）
xiaosuqi1778的博客
10-06 765
利用单链表实现大数的+、-、*和阶乘（选做）
c++单链表实现大数的求和运算
_Findway的博客
11-03 4821
首先list.h #ifndef LIST_H #define LIST_H #include #include #include using namespace std; typedef struct NODE node; typedef struct NODE* nodeptr; typedef string::size_type size_type; struct NO
C语言加链表编写的大数减法
10-26
用C写的大数减法程序，整个程序用的是链表，有些不足之处请指教
C++之用链表实现大数的加减乘除
weixin_34247032的博客
02-25 1843
1.前言 实现大数的加减乘除是今年寒假C++的大作业，原本我是用字符串写的，但是后来看作业要求要用链表实现，于是我不情不愿的用链表的实现了一遍 2.Num类 2.1Node类 首先是内部的一个Node类用于建立单向链表，size用于计算大小方便Num对象之间做比较 class Node { public: int val; Node*next...
数据结构——链表相加（大数相加）
qq_29992017的博客
09-24 1693
输出：1 2 3 4 5 6 7 9 6 4 原因：1234567899+ 65 = 1234567964。本关任务：给出两个非空的链表用来表示两个非负的整数。我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。输出：1 0 1 2 0 0 原因：99999 + 1201 = 101200。其中标红数字为要输入的数据位数，例如输入520 输入案例是 3 5 2 0，在进行大数相加时，我们一般可以采用将数按位存储并按位相加的方法。开始你的任务吧，祝你成功！
单链表实现大整数相加
qq_62175345的博客
05-02 2067
C/C++语言中的int类型能表示的整数范围是-2^31~2^31-1,unsigned int类型能表示的整数范围是0~2^32-1, 即0~4 294 967 295，所以，int和unsigned int类型都不能存储超过10位的整数。有些问题需要处理的整数远远不止10位， 这种大整数用C/C++语言的基本数据类型无法直接表示。请编写算法，采用顺序表或者单链表实现两个大整数相加运算。 提示：将用户输入的十进制整数字符串转化为顺序表或者带头结点的单链表， 每个数据元素或每个结点中存放一个整数位，然...
c语言中int下小数求余大数,使用C++中string实现任意长度的正小数、整数之间加减法方法实例...
weixin_28965963的博客
05-17 851
一、概述C/C++中的int类型能表示的范围是-2E31－2E31–1。unsigned类型能表示的范围是0－2E32–1，即 0－4294967295。所以，int和unsigned类型变量，都不能保存超过10位的整数。有时我们需要参与运算的数，可能会远远不止10 位，例如，可能需要保留小数点后面100位(比如求π的值)，那么，即便使用能表示很大数值范围的double变量，但是由于double变...
数据结构实验一 用链表实现大整数加减法
m0_61506053的博客
03-31 4039
题目： 用链表实现大整数加减法操作： 32位机器直接操作的数据最大为32个bit，若超过32bit，则需要单独设计算法。在这里，可以用链表每个结点存储大整数的每一位的十进制数字，则可以进行大整数的算数运算，该实验仅实现加减法操作。 要求: 随机产生2个1~50位的数字串，并存储到2个链表中。 进行加法或减法操作，结果存储到新的链表中。 打印运算结果。 目录 BigInteger.h BigInteger.cpp function.h function.cpp main.cpp ..
11.用链表模拟大整数加法运算
huangxy10的专栏
09-24 3121
例如：9->9->9->NULL +                      1->NULL       1->0->0->0->NULL 思路： 使用递归，能够实现从前往后计算。 // LinkTable.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include using namespace s
数据结构：用链表实现大数运算（高精度）
pied_piperG的博客
05-23 962
采用链表实现大数运算 C++分为头文件程序和主体cpp函数 头文件函数如下： #include<iostream> using namespace std; template<class T> struct Node { T data; struct Node<T>*prior; struct Node<T>*next; }; template<class T> class Linklist { public: Linklist(
链表实现大整数 加减法 一个节点保存四位数字（C++实现）
mazamu的博客
09-16 361
可用来熟悉数据结构与C++语言内容。 #include<iostream> #include<vector> #include<algorithm> using namespace std; class node { public: node() { ch = ""; next = nullptr; } node(string a) { ch = a; next = nullptr;
leetcode-2、两数相加（c++)
weixin_42395736的博客
11-17 390
leetcode-2、两数相加（c++) 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807 来源：力扣（LeetCod
数据结构复习（再熟悉一下吧）
h13245的博客
03-11 733
数据结构 绪论 程序=数据结构+算法 数据结构是介于数学，计算机硬件和计算机软件三者之间的一门核心课程 勤于思考，多做练习，多上机，善于寻求帮助，不怕困难不放弃 具体问题抽象为数据模型（分析问题，提取操作对象，找出操作对象之间的关系，用数学语言描 述），设计算法，编程、调试、运行 增删改查 表，树，图 数据：能输入计算机且能被计算机处理的各种符号的集合。信息的载体，是对客观事物符号化的表示，能够...
数据结构课程设计-链表-大数运算-实现大数加法、大数减法、大数乘法、大数除法、大数乘方、大数取模、同时支持十进制大数和二进制大数运算
tomly2020的博客
12-16 4310
基于链表实现
【数据结构实验】用链表实现两个大整数的相加减
COFACTOR
10-12 4636
一、实验内容 【问题描述】 设计一个实现任意长的整数进行加法运算的演示程序 。 【基本要求】 利用双向链表实现长整数的存储，每个结点含一个整形变量。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。 【测试数据】 （1）0 0；应输出“0”。 （2）-2345,6789 -7654,3211；应输出“-1,0000,0000”。 （3）-9999,9999 1,0000,00...
C语言 双向链表处理大数加减
heng0123的博客
03-24 1626
处理无符号大数加减 处理有符号大数加减 处理有符号大数加减 1.定义的结构体 struct Node { int digit; //数字 struct Node *next, *prev; //前后指针 }; struct UBigNumber { int digitCount; //位数 struct Node *pHead, *pTail; //指向头结点和尾结点 }; 2.定义的函数： //动态分配1个结点，返回结点指针 //当分配失败时，简化程序，退出运行
C++ 链表 大数加减法
云帝的博客
06-07 2053
大数加法 #include <bits/stdc++.h> using namespace std; class Node { public: int data; Node *next; Node() { next = nullptr; } Node (int data) { this->data = data; } Node (const Node &temp) {
双向链表实现大数加减
最新发布
03-16
通过使用双向链表，我们可以实现大数的加减运算。 在双向链表中，每个节点表示一个数字位，从低位到高位排列。我们可以使用两个双向链表分别表示两个大数，然后从低位开始逐位相加或相减，并将结果保存在新的双向...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值