单链表ADT模板应用算法设计：长整数加法运算

最新推荐文章于 2023-04-26 15:58:44 发布

椰子橙子李子

最新推荐文章于 2023-04-26 15:58:44 发布

阅读量410

点赞数 3

文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/rc85qbte/article/details/130304490

版权

原始代码（相当麻烦，敲得时候也相当迷糊，重复性代码数量大）

现在代码

新的总代码

题目描述

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

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

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

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

参考函数原型：

template<class ElemType>

void Long_Int_Add( LinkList<ElemType> &A, LinkList<ElemType> &B, string &result, 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 );

（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> &LInt)

输入输出要求与范例

输入说明 :

第一行：长整数x

第二行：长整数y

输出说明 :

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

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

第三行：空行

第四行：格式化后的计算结果（从低位到高位每4位用","分开）

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

输入范例 :-534564675768465476586798709880985345646757684654765867987098809853456467576846547658679870988098534564675768465476586798709880985345646757684654765867987098809853456467576846547658679870988098534564675768465476586798709880985345646757684654765867987098809853456467576846547658679870988098534564675768465476586798709880985345646757684654765867987098809853456467576846547658679870988098
435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679435643754856985679

输出范例 :

-5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098
4356,4375,4856,9856,7943,5643,7548,5698,5679,4356,4375,4856,9856,7943,5643,7548,5698,5679,4356,4375,4856,9856,7943,5643,7548,5698,5679,4356,4375,4856,9856,7943,5643,7548,5698,5679,4356,4375,4856,9856,7943,5643,7548,5698,5679,4356,4375,4856,9856,7943,5643,7548,5698,5679,4356,4375,4856,9856,7943,5643,7548,5698,5679

-5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,6467,5768,4654,7658,6798,7098,8098,5345,2111,1392,9797,7801,8855,1455,0549,9647,0788,1412,0279,2801,6941,9155,2454,7797,0769,0089,0298,3283,1941,7242,0154,9701,8919,0069,8975,3302,2423,2241,8241,7402,0823,8219,8956,1979,2442,2723,3241,5488,8524,0124,7106,1960,1119,2742,3723,0488,6610,7824,9011,0110,1100,1419,3742,0970,1610,5911,6711,2014,9250,1400,2419

思路与代码

思路

把节点定义为结构体，把链表定义为类，在类中实现链表输出，链表加减法运算等行为。

难点

如何尽量的缩减代码长度

如何实现进位，借位等等

如何合理的规范输出格式

代码对比与进步

原始代码（相当麻烦，敲得时候也相当迷糊，重复性代码数量大）

不建议观看，没啥用，徒浪费时间。

#include<bits/stdc++.h>
#include<cstring>
#include<stdio.h>
#include<iostream>

using namespace std;
struct ListNode {
    int num;
    ListNode *next;
};
int getlength(ListNode *head)//计算并返回有头节点的链表的长度
{
    int len = 0;
    ListNode *p = head->next;
    while (p) {
        len++;
        p = p->next;
    }
    return len;
}
ListNode *createListNode() {
    ListNode *head;
    head = new ListNode;
    head->next = nullptr;
    char ch;
    string s;//用来储存字符串，是输入数字的绝对值
    ListNode *p;
    ch=cin.get();//先把首个字符录入
    int shouwei=1;
    p = head;
    if (ch == '-')head->num = -1;
    else {
        head->num = 1;
        shouwei = ch-'0';
    }//如果是正数的话先把最高位存起来
//分别对于正的和负的进行不同的处理
    if (shouwei == 0)//先考虑到这个数是0的情况并单独的挑出来处理
    {
        ListNode *q = new ListNode;
        q->num = 0;
        q->next = p->next;
        p->next = q;
        return head;
    } else {//正数和负数的情况
        getline(cin, s);
        int len = s.size();
        for (int i = len - 1; i >= 0; )//通过在循环内部对于i进行计算从而实现一个结点一个大循环
        {
            ListNode *q = new ListNode;
            q->next = p->next;
            p->next = q;
            q->num=0;
            int k;
            for (k = 1; k <= 4&&i>=0; k++) //这个k表示的就是第几位
            {
                switch (k % 4)//通过k与i的转换实现了从低位到高位储存进链表，以防止有的节点不足四位
                {
                    case 1:
                        q->num += (s[i]-'0');
                        break;
                    case 2:
                        q->num += (10 * (s[i]-'0'));
                        break;
                    case 3:
                        q->num += (100 * (s[i]-'0'));
                        break;
                    case 0:
                        q->num += (1000 * (s[i]-'0'));
                        break;
                }
                i--;
            }
            p = q;
        }//这个循环实现了这个长整数纯存进链表的操作，但是最高位没有处理
        //这个循环怎么看怎么拧巴，其实主要是想要让链表把这个长整数从个位到高位存入链表
        if (ch != '-' && p->num < 1000)//再去把受位上的数字加上去
           if(len%4==0||p->num>=1000){
               ListNode *q = new ListNode;
               q->num = shouwei;
               q->next = p->next;
               p->next = q;
               p = q;//这个时候p是链表的最后一个结点
           }else
           if(p->num<10) {
               p->num += shouwei * 10;
           }
        else if(p->num<100){
            p->num+=shouwei*100;
        }
        else if(p->num<1000){
            p->num+=shouwei*1000;
        }//这个时候p指向的结点是链表的最后一个
        else ;
        else if (ch == '-')
        //循环完了这几行是为了处理最高位的
       {
            ListNode *q = head->next;
            while (q){q->num = 0 - q->num;q=q->next;}
        }//如果是负数的话，对于后面的所有节点把他们全变成负的
        return head;
    }
}

ListNode *he(ListNode *head1, ListNode *head2)//这个函数相对来说就省事了，因为上一个函数考虑了正负号问题，这个函数只需要一通加
{//必须要提前知道求完和以后那个数是正的还是负的才能继续接下来的运算
    ListNode *p1 = head1->next;
    ListNode *p2 = head2->next, *lc, *p3, *p4,*t1,*t2;
    lc = new ListNode;
    lc->next = nullptr;
    p3 = lc;
    int cot = 0, len1, len2;
    len1 = getlength(head1);
    len2 = getlength(head2);
    t1=head1->next;
    t2=head2->next;
    while(t1->next){
        t1=t1->next;
    }
    while(t2->next)
    {
        t2=t2->next;
    }
    if (head1->num == head2->num) {//这种情况是两个长整数同号的情况
        while (p1 && p2) {
            p4 = new ListNode;
            p4->num = p1->num + p2->num;
            p4->num += cot;//cot用来存储上一个节点余出来的
            if (p4->num >= 10000) {//能大于1000肯定都是正的
                cot = 1;
                p4->num -= 10000;
            } else if (p4->num <= -10000) {//能小于-10000肯定都是负的
                cot = -1;
                p4->num += 10000;
            }
            p4->next = p3->next;
            p3->next = p4;
            p3 = p4;//这三行是插入操作
            p1 = p1->next;
            p2 = p2->next;//两个指针统统后移
        }
        if (p1 != nullptr) {
            ListNode *p5=new ListNode,*p8;
            p5->next= nullptr;
            p8=p5;
            while(p1)
            {
                ListNode *p6=new ListNode;
                p6->next=p8->next;
                p6->num=p1->num;
                p8->next=p6;
                p8=p6;//这几行代码是赋值并插入临时链表
                p1=p1->next;
            }
            p5=p5->next;
            //这几行是把没走完的链表剩余部分复制到新链表上。
            p3->next = p5;//把原来没有建立完的链表的最后一个节点和没有数完的第一个结点连起来
            while (p3) {
                p3->num += cot;
                if (p3->num >= 10000) {
                    cot = 1;
                    p3->num -= 10000;
                } else if (p3->num <= -10000) {
                    cot = -1;
                    p3->num += 10000;
                }
            }
        }
        if (p2 != nullptr) {
            ListNode *p5=new ListNode,*p8;
            p5->next= nullptr;
            p8=p5;
            while(p2)
            {
                ListNode *p6=new ListNode;
                p6->next=p8->next;
                p6->num=p2->num;
                p8->next=p6;
                p8=p6;//这几行代码是赋值并插入临时链表
                p2=p2->next;
            }
            p5=p5->next;
            //这几行是把没走完的链表剩余部分复制到新链表上。
            p3->next = p5;//把原来没有建立完的链表的最后一个节点和没有数完的第一个结点连起来
            while (p3) {
                p3->num += cot;
                if (p3->num >= 10000) {
                    cot = 1;
                    p3->num -= 10000;
                } else if (p3->num <= -10000) {
                    cot = -1;
                    p3->num += 10000;
                }
            }
        }
        if(p2== nullptr&&p1== nullptr)
        {
            if(cot){
            ListNode *p4=new ListNode;
            p4->num=0;
            p4->num+=cot;
            p4->next= nullptr;
            p3->next=p4;}
        }
    } else//这是两个链表异号的时候
    {
        if ((len1 > len2 && head1->num == -1) || (len1 < len2 && head1->num == 1)||(len1==len2&&head1->num==-1&&((0-t1->num)>t2->num))||(len1==len2&&head1->num==1&&(t1->num<(0-t2->num))))
            //这个是负的长
        {

            lc->num = -1;
            while (p1 && p2) {
                p4 = new ListNode;
                p4->num = p1->num + p2->num;
                p4->num += cot;//cot用来存储上一个节点余出来的
                cot=0;
                if (p4->num > 0) {
                    cot =1;
                    p4->num -= 10000;
                } else if (p4->num <= -10000) {
                    cot = -1;
                    p4->num += 10000;
                }
                p4->next = p3->next;
                p3->next = p4;

                p3 = p4;//这三行是插入操作
                p1 = p1->next;
                p2 = p2->next;//两个指针统统后移
            }
            if (p1!= nullptr) {//这里相当于p1不等于null也就相当于第一个链表没有走完
                ListNode *p5=new ListNode,*p7=p1,*p8;
                p5->next= nullptr;
                p8=p5;
                while(p1)
                {
                    ListNode *p6=new ListNode;
                    p6->next=p8->next;
                    p6->num=p1->num;
                    p8->next=p6;
                    p8=p6;//这几行代码是赋值并插入临时链表
                    p1=p1->next;
                }
                p5=p5->next;
                //这几行是把没走完的链表剩余部分复制到新链表上。
                 p3->next = p5;//把原来没有建立完的链表的最后一个节点和没有数完的第一个结点连起来
                while (p3) {
                    p3->num+=cot;
                    cot=0;
                    if (p3->num > 0) {
                        cot = 1;
                        p3->num -= 10000;
                    } else if (p3->num <= -10000) {
                        cot = -1;
                        p3->num += 10000;
                    }
                    p3=p3->next;
                }
            }
           else  if (p2 != nullptr) {
                ListNode *p5=new ListNode,*p8;
                p5->next= nullptr;
                p8=p5;
                while(p2)
                {
                    ListNode *p6=new ListNode;
                    p6->next=p8->next;
                    p6->num=p2->num;
                    p8->next=p6;
                    p8=p6;//这几行代码是赋值并插入临时链表
                    p2=p2->next;
                }
                p5=p5->next;
                //这几行是把没走完的链表剩余部分复制到新链表上。
                p3->next = p5;//把原来没有建立完的链表的最后一个节点和没有数完的第一个结点连起来
                while (p3) {
                    p3->num += cot;
                    if (p3->num > 0) {
                        cot = 1;
                        p3->num -= 10000;
                    } else if (p3->num <= -10000) {
                        cot = -1;
                        p3->num += 10000;
                    }
                }
            }
            else if(p2== nullptr&&p1== nullptr)
            {
                if(cot){
                ListNode *p4=new ListNode;
                p4->num=0;
                p4->num+=cot;
                p4->next= nullptr;
                p3->next=p4;}
            }
        } else //这个是正的长
        {
            lc->num = 1;
            while (p1 && p2) {
                p4 = new ListNode;
                p4->num = p1->num + p2->num;
                p4->num += cot;//cot用来存储上一个节点余出来的
                if (p4->num <0) {
                    cot = -1;
                    p4->num += 10000;
                } else if (p4->num >= 10000) {
                    cot = 1;
                    p4->num -= 10000;
                }
                p4->next = p3->next;
                p3->next = p4;
                p3 = p4;//这三行是插入操作
                p1 = p1->next;
                p2 = p2->next;//两个指针统统后移
            }
            if (p1 != nullptr) {
                ListNode *p5=new ListNode,*p8;
                p5->next= nullptr;
                p8=p5;
                while(p1)
                {
                    ListNode *p6=new ListNode;
                    p6->next=p8->next;
                    p6->num=p1->num;
                    p8->next=p6;
                    p8=p6;//这几行代码是赋值并插入临时链表
                    p1=p1->next;
                }
                p5=p5->next;
                //这几行是把没走完的链表剩余部分复制到新链表上。
                p3->next = p5;//把原来没有建立完的链表的最后一个节点和没有数完的第一个结点连起来
                while (p3) {
                    p3->num += cot;
                    if (p3->num < 0) {
                        cot =-1;
                        p3->num += 10000;
                    } else if (p3->num >= 10000) {
                        cot = 1;
                        p3->num -= 10000;
                    }
                }
            }
           else  if (p2 != nullptr) {
                ListNode *p5=new ListNode,*p8;
                p5->next= nullptr;
                p8=p5;
                while(p2)
                {
                    ListNode *p6=new ListNode;
                    p6->next=p8->next;
                    p6->num=p2->num;
                    p8->next=p6;
                    p8=p6;//这几行代码是赋值并插入临时链表
                    p2=p2->next;
                }
                p5=p5->next;
                //这几行是把没走完的链表剩余部分复制到新链表上。
                p3->next = p5;//把原来没有建立完的链表的最后一个节点和没有数完的第一个结点连起来
                while (p3) {
                    p3->num += cot;
                    if (p3->num < 0) {
                        cot =-1;
                        p3->num += 10000;
                    } else if (p3->num >= 10000) {
                        cot = 1;
                        p3->num -= 10000;
                    }
                }
            }
           else  if(p2== nullptr&&p1== nullptr)
            {
               if(cot){
                  ListNode *p4=new ListNode;
                  p4->num=0;
                  p4->num+=cot;
                  p4->next= nullptr;
                  p3->next=p4;}
               else ;
            }
        }
    }
return lc;
}
ListNode *invertListNode(ListNode*head)//有头节点的链表进行逆置
{
    ListNode *p,*s;
    p=head->next;
    head->next= nullptr;
    while(p)
    {
        s=p;
        p=p->next;
        s->next=head->next;
        head->next=s;
    }
    return head;
}
void coutListNode(ListNode *head) {
head= invertListNode(head);//先进行逆置以便于输出
if(head->num==-1) {
    cout << '-';
    ListNode *p = head->next;
    while (p) {
        p->num=0-p->num;
        p=p->next;
    }
    p=head->next;
    while(p)
    {if(p==head->next&&p->next){
        cout<<p->num<<",";
    }
        else if(p->next== nullptr&&p==head->next)
            cout<<p->num;
        else if(p->next== nullptr)
             if(p->num<10)cout<<"000"<<p->num;
            else if(p->num<100)cout<<"00"<<p->num;
            else if(p->num<1000)cout<<"0"<<p->num;
            else cout<<p->num;
        else if(p->num<10)cout<<"000"<<p->num<<",";
        else if(p->num<100)cout<<"00"<<p->num<<",";
        else if(p->num<1000)cout<<"0"<<p->num<<",";
        else cout<<p->num<<",";
        p=p->next;
    }
}
else
{
    ListNode *p = head->next;
    p=head->next;
    if(p->num==0)
        cout<<0;
    else
    while(p)
    {if(p==head->next&&p->next){
        cout<<p->num<<",";
    }
        else if(p->next== nullptr&&p==head->next)
            cout<<p->num;
        else if(p->next== nullptr)
            if(p->num<10)cout<<"000"<<p->num;
            else if(p->num<100)cout<<"00"<<p->num;
            else if(p->num<1000)cout<<"0"<<p->num;
            else cout<<p->num;
        else if(p->num<10)cout<<"000"<<p->num<<",";
        else if(p->num<100)cout<<"00"<<p->num<<",";
        else if(p->num<1000)cout<<"0"<<p->num<<",";
        else cout<<p->num<<",";
        p=p->next;
    }
}
}
int main() {
    ListNode *x,*y,*z;
    x=createListNode();
    y=createListNode();
    z=he(x,y);
    coutListNode(x);
    cout<<endl;
    coutListNode(y);
    cout<<endl;
    cout<<endl;
    coutListNode(z);
    return 0;
}

现在代码

铺垫类操作

#include<bits/stdc++.h>
#include<cstring>
#include<stdio.h>
#include<iostream>
using namespace std;
struct LinkNode//一个节点
{
    int data;
    struct LinkNode *next,*piror;
};
class LinkList//一个链表
{
private:
    LinkNode *head,*tail;
    int len;
public:
    int GetLength();
    void push(int n);//在开头，头节点后面插入节点
    LinkList();//链表的初始化
    void input(string str);//把字符串的数字存储在单链表中
    void display();//链表的输出
    LinkNode* GetHead();
    LinkNode* GetTail();
    void operator=(const LinkList *s)
    {
        head=s->head;
        tail=s->tail;
        len=s->len;
    }
    void friend 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->piror=head;
    head->next->piror=p;
    head->next=p;}
    else
    {
        p->data=n;
        p->next= head->next;
        p->piror=head;
        head->next=p;
    }
}
void LinkList::input(string str) {//把字符串的数字存储在单链表中，也算是构造函数，构造的是双向链表
    int end=0;
    if(str[0]=='-'){
        this->head->data=-1;
        end=1;
    }
    else this->head->data=1;
    int len=str.size(),cot=0,sum=0;//cot数到4就push
    for(int i=len-1;i>=end;i--)
    {
        int val;
        if(cot==0){
            val=str[i]-'0';
            cot++;
            sum+=val;
        }
        else if(cot==1){
            val=10*(str[i]-'0');
            cot++;
            sum+=val;
        }
        else if(cot==2)
        {
            val=100*(str[i]-'0');
            cot++;
            sum+=val;
        }
        else if(cot==3)
        {
            val=1000*(str[i]-'0');
            cot=0;
            sum+=val;
            push(sum);
            this->len++;
            if(this->len==1)tail=head->next;
            sum=0;
            val=0;
        }
        if(i==end&&val){
            push(sum);
            this->len++;
            if(this->len==1)tail=head->next;
        }
    }
}
void Cout(int n)
{
    if(n<10000&&n>1000)cout<<n;
    else if(n<1000&&n>100)cout<<"0"<<n;
    else if(n<100&&n>10)cout<<"00"<<n;
    else if(n<10&&n>0)cout<<"000"<<n;
    else if(n==0)cout<<"0000";
}
void LinkList::display() {//输出链表
    if(head->data==1);//是个正数
    else  cout<<'-';
    LinkNode *p=head->next;
    while(p)
    {
        if(p==head->next)
            cout<<p->data;
        else
        {
            cout<<',';
            Cout(p->data);
        }
        p=p->next;
    }
}

关键性函数

LinkList yunsuan(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->piror;
           t2=t2->piror;
       }
           while(t1!=list1.GetHead()) {//如果这个链表还没走完
               val = t1->data+jin;
               list3.push(val);
               t1 = t1->piror;
               jin=0;
           }
          while(t2!=list2.GetHead())//如果这个链表还没走完
          {
              val=t2->data+jin;
              list3.push(val);
              t2=t2->piror;
              jin=0;
          }
          if(t1==list1.GetHead()&&t2==list2.GetHead()&&jin)//考虑到加完以后结点相对于之前的链表中最长链表延长了
          {
              list3.push(jin);
          }
   }
       else//异号
   {
           //对于符号进行处理
        if(list2.GetHead()->data==1)//2是正的
        {
            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//2是负的
        {
            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;
        }
        //这样一来，list4永远是被减数，list5永远是减数，
       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->piror;
            t5=t5->piror;
        }
        while(t4!=list4->GetHead())
        {
            val=t4->data+jin;
            if(val==0&&t4==list4->GetHead()->next);//考虑到最高一位被减没了的情况
            else
            list3.push(val);
            t4=t4->piror;
            jin=0;
        }
        while(t5!=list5->GetHead())
        {
            val=t5->data+jin;
            if(val==0&&t5==list5->GetHead()->next);//考虑到最高一位被减没了的情况
            else
            list5->push(val);
            t5=t5->piror;
            jin=0;
        }

   }
       return list3;

}

新的总代码

#include<bits/stdc++.h>
#include<cstring>
#include<stdio.h>
#include<iostream>
using namespace std;
struct LinkNode//一个节点
{
    int data;
    struct LinkNode *next,*piror;
};
class LinkList//一个链表
{
private:
    LinkNode *head,*tail;
    int len;
public:
    int GetLength();
    void push(int n);//在开头，头节点后面插入节点
    LinkList();//链表的初始化
    void input(string str);//把字符串的数字存储在单链表中
    void display();//链表的输出
    LinkNode* GetHead();
    LinkNode* GetTail();
    void operator=(const LinkList *s)
    {
        head=s->head;
        tail=s->tail;
        len=s->len;
    }
    void friend 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->piror=head;
    head->next->piror=p;
    head->next=p;}
    else
    {
        p->data=n;
        p->next= head->next;
        p->piror=head;
        head->next=p;
    }
}
void LinkList::input(string str) {//把字符串的数字存储在单链表中，也算是构造函数，构造的是双向链表
    int end=0;
    if(str[0]=='-'){
        this->head->data=-1;
        end=1;
    }
    else this->head->data=1;
    int len=str.size(),cot=0,sum=0;//cot数到4就push
    for(int i=len-1;i>=end;i--)
    {
        int val;
        if(cot==0){
            val=str[i]-'0';
            cot++;
            sum+=val;
        }
        else if(cot==1){
            val=10*(str[i]-'0');
            cot++;
            sum+=val;
        }
        else if(cot==2)
        {
            val=100*(str[i]-'0');
            cot++;
            sum+=val;
        }
        else if(cot==3)
        {
            val=1000*(str[i]-'0');
            cot=0;
            sum+=val;
            push(sum);
            this->len++;
            if(this->len==1)tail=head->next;
            sum=0;
            val=0;
        }
        if(i==end&&val){
            push(sum);
            this->len++;
            if(this->len==1)tail=head->next;
        }
    }
}
void Cout(int n)
{
    if(n<10000&&n>1000)cout<<n;
    else if(n<1000&&n>100)cout<<"0"<<n;
    else if(n<100&&n>10)cout<<"00"<<n;
    else if(n<10&&n>0)cout<<"000"<<n;
    else if(n==0)cout<<"0000";
}
void LinkList::display() {//输出链表
    if(head->data==1);//是个正数
    else  cout<<'-';
    LinkNode *p=head->next;
    while(p)
    {
        if(p==head->next)
            cout<<p->data;
        else
        {
            cout<<',';
            Cout(p->data);
        }
        p=p->next;
    }
}
LinkList yunsuan(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->piror;
           t2=t2->piror;
       }
           while(t1!=list1.GetHead()) {//如果这个链表还没走完
               val = t1->data+jin;
               list3.push(val);
               t1 = t1->piror;
               jin=0;
           }
          while(t2!=list2.GetHead())//如果这个链表还没走完
          {
              val=t2->data+jin;
              list3.push(val);
              t2=t2->piror;
              jin=0;
          }
          if(t1==list1.GetHead()&&t2==list2.GetHead()&&jin)//考虑到加完以后结点相对于之前的链表中最长链表延长了
          {
              list3.push(jin);
          }
   }
       else//异号
   {
           //对于符号进行处理
        if(list2.GetHead()->data==1)//2是正的
        {
            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//2是负的
        {
            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;
        }
        //这样一来，list4永远是被减数，list5永远是减数，
       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->piror;
            t5=t5->piror;
        }
        while(t4!=list4->GetHead())
        {
            val=t4->data+jin;
            if(val==0&&t4==list4->GetHead()->next);//考虑到最高一位被减没了的情况
            else
            list3.push(val);
            t4=t4->piror;
            jin=0;
        }
        while(t5!=list5->GetHead())
        {
            val=t5->data+jin;
            if(val==0&&t5==list5->GetHead()->next);//考虑到最高一位被减没了的情况
            else
            list5->push(val);
            t5=t5->piror;
            jin=0;
        }

   }
       return list3;

}
int main() {
    LinkList list1,list2,list3;
    string str1,str2;
    getline(cin,str1);
    getline(cin,str2);
    list1.input(str1);
    list1.display();
    cout<<endl;
    list2.input(str2);
    list2.display();
    cout<<endl;cout<<endl;
    list3=yunsuan(list1,list2);
    list3.display();
    return 0;
}

椰子橙子李子

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
单链表ADT模板应用算法设计：长整数加法运算

（1）从长整数的低位开始拆分（4位为一组，即不超过9999的非负整数），依次存放在单链表的每个结点的数据域中；（4）单链表ADT基本操作：单链表的逆置（实际计算时，鉴于单链表的顺序查找的特性，存储在单链表中的长整数需逆置，由原始的高位到低位排列，逆置为低位到高位降序排列。应用：假设2个任意长度的整数x、y分别由带头结点的单链表A和B存储，现要求设计一个算法，实现任意长的整数进行加法运算，运算结果存储在字符串中。（5）单链表格式遍历：按照长整数的格式（4位为一组，组与组之间用，分隔）如何合理的规范输出格式。
复制链接

扫一扫