【东华大学oj】单链表ADT模板应用算法设计：长整数加法运算（使用单链表存储计算结果）

单链表ADT模板应用算法设计：长整数加法运算（使用单链表存储计算结果）

时间限制: 1s

类别: DS：线性表->线性表应用

晚于 2024-05-08 23:59:00 后提交分数乘系数50%

截止日期：2024-05-11 23:59:00

问题描述

目的：使用C++模板设计单链表的抽象数据类型（ADT）。并在此基础上，使用单链表ADT的基本操作，设计并实现单链表的应用算法设计。

内容：（1）请使用模板设计单链表的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。）

（2）ADT的应用：使用该ADT设计并实现单链表应用场合的算法设计。

应用：假设2个任意长度的整数x、y分别由带头结点的单链表A和B存储，现要求设计一个算法，实现任意长的整数进行加法运算，计算结果存储在带头结点的单链表C中。

参考函数原型：

template<class ElemType>

void Long_Int_Add( LinkList<ElemType> &A, LinkList<ElemType> &B, LinkList<ElemType> &C, const int &len_A, const int &len_B );

辅助函数原型：

（1）从长整数的低位开始拆分（4位为一组，即不超过9999的非负整数），依次存放在单链表的每个结点的数据域中；头结点的数据域存放正负数标志（正数或0：1，负数：-1）。

template<class ElemType> 

void Input_Int_Division( LinkList<ElemType> &L, string &str, int &length );  （length：长整数分割后的block数，恰为存储用单链表的长度）

（2）计算结果中间位格式控制

string Int_String( int result, int &num );

（3）两个长整数的绝对值大小比较（x>y 返回值为1；x<y 返回值为2；x=y 返回值为0；）

template<class ElemType>

int Two_LongNum_Compare( LinkList<ElemType> &A, LinkList<ElemType> &B, const int &len_A, const int &len_B );

（4）单链表ADT基本操作：单链表的逆置（实际计算时，鉴于单链表的顺序查找的特性，存储在单链表中的长整数需逆置，由原始的高位到低位排列，逆置为低位到高位降序排列。）

template<class ElemType>

void LinkList<ElemType>::ListReverse();

（5）单链表格式遍历：按照长整数的格式（4位为一组，组与组之间用，分隔）

template<class ElemType>

bool ListTraverse(LinkList<ElemType> &C)

输入说明

第一行：长整数x

第二行：长整数y

输出说明

第一行：格式化后的长整数x（从低位到高位每4位用","分开）

第二行：格式化后的长整数y（从低位到高位每4位用","分开）

第三行：空行

第四行：格式化后的计算结果（通过对结果单链表C的遍历得到，从低位到高位每4位用","分开）

（输入与输出之间用一空行分隔）

#include<bits/stdc++.h>
#include<cstring>
#include<cstdio> // Include for printf and scanf
using namespace std;

struct LinkNode
{
    int data;
    struct LinkNode *next, *prior;
};

class LinkList
{
private:
    LinkNode *head, *tail;
    int len;

public:
    int GetLength();
    void push(int n);
    LinkList();
    void input(const char* str);
    void display();
    LinkNode* GetHead();
    LinkNode* GetTail();
    void operator=(const LinkList *s)
    {
        head = s->head;
        tail = s->tail;
        len = s->len;
    }
    friend void Cout(int n);
};

LinkList::LinkList()
{
    head = new LinkNode;
    head->next = nullptr;
    tail = head;
    len = 0;
}

LinkNode* LinkList::GetHead()
{
    return head;
}

LinkNode* LinkList::GetTail()
{
    return tail;
}

int LinkList::GetLength()
{
    return len;
}

void LinkList::push(int n)
{
    LinkNode *p = new LinkNode;
    if(head->next)
    {
        p->data = n;
        p->next = head->next;
        p->prior = head;
        head->next->prior = p;
        head->next = p;
    }
    else
    {
        p->data = n;
        p->next = nullptr;
        p->prior = head;
        head->next = p;
        tail = p;
    }
    len++;
}

void LinkList::input(const char* str)
{
    int end = 0;
    if(str[0] == '-')
    {
        this->head->data = -1;
        end = 1;
    }
    else this->head->data = 1;

    int str_len = strlen(str), cot = 0, sum = 0;
    for(int i = str_len - 1; i >= end; --i)
    {
        int val = str[i] - '0';
        sum += val * pow(10, cot);
        cot++;
        if(cot == 4 || i == end)
        {
            push(sum);
            cot = 0;
            sum = 0;
        }
    }
}

void Cout(int n)
{
    printf("%04d", n);
}

void LinkList::display()
{
    if(head->data == -1)
        printf("-");

    LinkNode *p = head->next;
    if(p)
    {
        printf("%d", p->data);
        p = p->next;
    }
    while(p)
    {
        printf(",%04d", p->data);
        p = p->next;
    }
}

// ... Rest of the LinkList and Long_Int_Add functions ...
LinkList Long_Int_Add(LinkList list1,LinkList list2)
{
    LinkList list3;
    if(list1.GetHead()->data==list2.GetHead()->data)
    {
        if(list2.GetHead()->data==1)
        {
            list3.GetHead()->data = 1;
        }
        else list3.GetHead()->data=-1;

        LinkNode *t1=list1.GetTail(),*t2=list2.GetTail();
        int val,jin;
        jin=0;
        while(t1!=list1.GetHead()&&t2!=list2.GetHead())
        {
            val=t1->data+t2->data+jin;
            if(val<10000)
            {
                list3.push(val);
                jin=0;
            }
            else
            {
                jin=1;
                val-=10000;
                list3.push(val);
            }
            t1=t1->prior;
            t2=t2->prior;
        }
        while(t1!=list1.GetHead())
        {
            val = t1->data+jin;
            list3.push(val);
            t1 = t1->prior;
            jin=0;
        }
        while(t2!=list2.GetHead())
        {
            val=t2->data+jin;
            list3.push(val);
            t2=t2->prior;
            jin=0;
        }
        if(t1==list1.GetHead()&&t2==list2.GetHead()&&jin)
        {
            list3.push(jin);
        }
    }
    else
    {
        if(list2.GetHead()->data==1)
        {
            if(list2.GetLength()>list1.GetLength())
                list3.GetHead()->data=1;
            else if (list2.GetLength()<list1.GetLength())
                list3.GetHead()->data=-1;
            else if(list2.GetHead()->next->data>list1.GetHead()->next->data)
                list3.GetHead()->data=1;
            else if(list2.GetHead()->next->data<list1.GetHead()->next->data)
                list3.GetHead()->data=-1;
            else
            {
                list3.GetHead()->data=1;
                list3.push(0);
                return list3;
            }
        }
        else
        {
            if(list2.GetLength()>list1.GetLength())
                list3.GetHead()->data=-1;
            else if(list2.GetLength()<list1.GetLength())
                list3.GetHead()->data=1;
            else if(list2.GetHead()->next->data>list1.GetHead()->next->data)
                list3.GetHead()->data=-1;
            else if(list2.GetHead()->next->data<list1.GetHead()->next->data)
                list3.GetHead()->data=1;
            else
            {
                list3.GetHead()->data=1;
                list3.push(0);
                return list3;
            }
        }
        LinkNode *t1=list1.GetTail(),*t2=list2.GetTail();
        LinkList *list4,*list5;
        if(list3.GetHead()->data==list1.GetHead()->data)
        {
            list4=&list1;
            list5=&list2;
        }
        else
        {
            list4=&list2;
            list5=&list1;
        }
        int val,jin=0;
        LinkNode *t4=list4->GetTail(),*t5=list5->GetTail();
        while(t4!=list4->GetHead()&&t5!=list5->GetHead())
        {
            val=t4->data-t5->data+jin;
            if(val>=0)
            {
                jin=0;
                list3.push(val);
            }
            else
            {
                jin=-1;
                val=10000+val;
                list3.push(val);
            }
            t4=t4->prior;
            t5=t5->prior;
        }
        while(t4!=list4->GetHead())
        {
            val=t4->data+jin;
            if(val==0&&t4==list4->GetHead()->next);
            else
                list3.push(val);
            t4=t4->prior;
            jin=0;
        }
        while(t5!=list5->GetHead())
        {
            val=t5->data+jin;
            if(val==0&&t5==list5->GetHead()->next);
            else
                list5->push(val);
            t5=t5->prior;
            jin=0;
        }

    }
    return list3;

}
int main()
{
    LinkList list1, list2, list3;
    char str1[10005]; // Assuming the input numbers will not be longer than 10000 digits
    char str2[10005];

    scanf("%s", str1);
    scanf("%s", str2);
    list1.input(str1);
    list1.display();
    printf("\n");
    list2.input(str2);
    list2.display();
    printf("\n\n");
    list3 = Long_Int_Add(list1, list2);
    list3.display();
    return 0;
}