链表问题——长整数加法运算题解【双向链表】

长整数加法运算

链表问题——长整数加法运算题解【双向链表】_第1张图片

问题描述

假设2个任意长度的整数x、y分别用链表A和B存储,现要求设计一个算法,实现x+y。计算结果存储在链表C中。

说明:

链表A、B、C可以是单向链表或双向链表,但由于A和B输出时需要从头至尾遍历,而做加法时需要从尾至头遍历,因此推荐使用双向链表存储。

链表的每个结点的数据域可以选择以下三种设计方式:

(1)链表的每个结点存储长整数的一位(不推荐);

(2)链表的每个结点从长整数的低位开始拆分(4位为一组,存到一个结点中,即结点的数据域为不超过9999的非负整数),依次存放在链表的每个结点;

(3)链表的每个结点从长整数的低位开始拆分(4位为一组,存到一个结点中,即结点的数据域为1-4位字符串),依次存放在链表的每个结点。

可利用头结点的数据域存放正负数标志(正数或0:1(“1”),负数:-1(“-1”))。

输入说明

第一行:长整数x

第二行:长整数y

输出说明

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

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

第三行:空行

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

(输入与输出之间用一空行分隔)

输入范例

-53456467576846547658679870988098
435643754856985679

输出范例

-5345,6467,5768,4654,7658,6798,7098,8098
43,5643,7548,5698,5679

-5345,6467,5768,4611,2014,9250,1400,2419

题解

思路

  • 输出43,5643,7548,5698,5679样式用string拼接实现。
  • 在计算中,关键是如何判断最终结果的负号,或者说A,B到底哪一个绝对值更大,这将决定异号时谁减谁。

我的做法:

  • A、B逆序模拟加减法计算,结果头插到新链表

  • 分步完成计算,第一步,A、B每个结点分别添置符号先不考虑进位,暴力相加(减法转为加负数,允许结果绝对值超过 1w)

  • 根据结果头部4位数去决定符号【头部的数字最大,如何借位进位都不可能改变正负】,--,++,+-,-+四种情况统一了,第二步如下两条:

  • 在同号相加计算中,考虑进位溢出,更要考虑头部4位是否溢出(>=10000

  • 在异号相加【减法】计算中,考虑与头部符号异号的那组数的符号纠正,考虑向前借位。

  • 在输出中,关键是如何判断,是否需要添有效0,比如:1,0000,避免无效0的出现,比如:0001000,0000,0000

代码实现

#include
#include
#include
#include

using namespace std;

const int W =10000;
typedef struct node
{
    int data;
    struct node *next;
    struct node* pre;
} link;
int main()
{
    string a,b;
    cin>>a>>b;
    // 预处理,补齐符号位,便于开头逗号处理。 比如正好四位数 会遇到 “,1234”开头添置逗号的情况。
    if(a[0] != '-')a ="+"+a;
    if(b[0] != '-')b ="+"+b;
    string new_a="",new_b="";
    int ct =0;
    for(int i=a.length()-1; i>=0; i--)
    {
        if(a[i] >='0' && a[i]<= '9')
        {
            new_a =to_string(a[i])+new_a;
            ct++;
            if(ct == 4)
            {
                new_a =","+new_a;
                ct =0;
            }

        }
        else // meet + 、-
        {
            if(new_a[0] ==',')new_a.erase(0,1);
            if(a[i] == '-')new_a =to_string(a[i])+new_a;

        }

    }
    cout<<new_a<<endl;
    ct=0;
    for(int i=b.length()-1; i>=0; i--)
    {
        if(b[i] >='0' && b[i]<= '9')
        {
            new_b =to_string(b[i]) + new_b;
            ct++;
            if(ct == 4)
            {
                new_b ="," +new_b;
                ct =0;
            }
        }
        else
        {
            if(new_b[0] ==',')new_b.erase(0,1);//去掉开头误加上的逗号。
            if(b[i] == '-')new_b =to_string(b[i])+new_b;//符号位打印只需要负号
        }

    }

    cout<<new_b<<endl;
    cout<<endl;
    //
    link* A,*B;
    A = new link;
    B = new link;
    create_dob_link(A,new_a);
    create_dob_link(B,new_b);
    // calculate A + B
    link *C = new link;
    C->next = NULL;
    C->pre = NULL;

    calculate(A,B,C);
    print_link(C);
}

创建双向链表函数

void create_dob_link(link *head,string data)
{

    link *tail =head;
    tail->next = NULL;
    tail->pre = NULL;
    //judge + -
    if(data[0] == '-')
    {
        head->data  =-1;
        data.erase(0,1);

    }
    else head->data = 1;
    //additional ','
    data +=",";

    //
    int res=0;
    for(int i=0; i<data.length(); i++)
    {
        if(data[i] >='0' && data[i]<='9')//condition: number
        {
            res =res*10 + data[i]-'0';

        }
        else  //condition:,
        {

            link * p = new link;
            p->data = res;
            p->next = tail->next;
            tail->next = p;
            p->pre =tail;
            tail = p;
            //initial
            res =0;
        }
    }
}

char to string 函数(挺笨的,但有效)

string只能拼接字符串,无法拼接字符。

string to_string(char x)
{
    string res;
    if(x == '0')res="0";
    else if(x == '1')res="1";
    else if(x == '2')res="2";
    else if(x == '3')res="3";
    else if(x == '4')res="4";
    else if(x == '5')res="5";
    else if(x == '6')res="6";
    else if(x == '7')res="7";
    else if(x == '8')res="8";
    else if(x == '9')res="9";
    else if(x == '-')res="-";

    return res;
}

头插法构建结果链表

void head_insert_link(link *C,int data)
{
    link * p = new link;
    p->data = data;
    p->next = C->next;
    C->next = p;
    p->pre = C;
    if(p->next)p->next ->pre = p;

}

结果打印函数(※)

void print_link(link *head)
{

    int f=false;//判断是否遇到了有效数字
    int ff =false;//判断当前的0是否为有效数字
    link *p=head->next;
    if(head->data < 0)cout<<"-";
    while(p)
    {
        if(p->data != 0)
        {
            //print
            if(ff)cout<<setfill('0')<<setw(4)<<abs(p->data);
            else cout<<abs(p->data);//condition: 1,0001  需要补有效0 
            f =true;
        }
        else   //condition: 1,0000,0000 需要补有效0 
        {
            if(f ==true && p->data == 0)cout<<"0000";
        }
//
        if(f && p->next)
        {
            cout<<",";
            //只要有逗号,0左侧一定会有数,后面遇到的数就是需要有效0。
            ff =true;
        }
        p=p->next;
    }
    //condition: 000,0000 纯零结果
    if(f == false)cout<<"0";
    cout<<endl;
}

长整数加减计算函数(※※※)

void calculate(link * A, link * B,link * C)
{
// part 1:先不考虑进位
    link *pa=A->next, * pb=B->next;
    while(pa->next)pa = pa->next;
    while(pb->next)pb = pb->next;

    while(pa !=A && pb != B)
    {
        //with +- maybe out range
        int res = pa->data * A->data + pb->data * B->data;
        head_insert_link(C,res);
        //next
        pa=pa->pre;
        pb=pb->pre;
    }

    while(pa != A)
    {
        int res = pa->data * A->data ;
        head_insert_link(C,res);
        pa=pa->pre;
    }
    while(pb != B)
    {
        int res = pb->data * B->data;
        head_insert_link(C,res);
        pb=pb->pre;

    }
//part 2:
//由顶部四位决定最终取值正负
    link * p =C->next;
    while(p->next)p=p->next;

    if(p && p->data < 0)C->data =-1;
    else C->data =1;
    while(p->pre != C)
    {
		//消除异号
        if(p->data * C->data < 0)
        {
            if(p->data <0)
            {
                p->data +=W;
                p->pre->data -=1;//头部为正值,借位,前面少了个1
            }
            else if(p->data >0)
            {
                p->data -=W;
                p->pre->data+=1;//头部为负值,借位,前面少了个-1,  对负数来说+1就是少了。
            }
           // else 0000 pass.
        }
		//同号进位,(未考虑头部溢出),while(p->pre != C) 就决定了 p是处理不到头部4位就结束了。下面补上了这个溢出处理。
        if(abs(p->data)>= W )
        {
            if(p->data > 0)
            {
                p->data -=W;
                p->pre->data +=1;
            }
            else
            {
                p->data +=W;
                p->pre->data +=-1;
            }
        }
        p=p->pre;
    }
    if(abs(p->data)>=W)//补充,考虑头部溢出
    {
        p->data %=W;
        head_insert_link(C,1);

    }

}

你可能感兴趣的:(C/C++,链表,数据结构)