任意长整数.zip-任意长的整数加减法运算

1. 任意长的整数加减法运算
设计算法，实现一个任意长的整数进行加法、减法运算的演示程序。例如：1234，5123，4512，3451，2345与-1111，1111，1111，1111，1111的加法结果为：0123，4012，3401，2340，1234。基本要求如下：
（1）利用链表实现长整数的存储，每个节点含一个整型变量；
（2）整型变量的范围：-（2^15 -1）~（2^15 -1）；
（3）输入与输出形式每四位一组，组间用逗号分隔开。如：1986,8213,1935,2736,3299；
（4）界面友好，每步给出适当的操作提示，并且系统具有一定的容错能力。
至少给出下面的测试数据：
（1）0； 0
（2）-2345,6789； -7654,3211
（3）-9999,9999； 1,0000,0000,0000
（4）1,0001,0001； -1,0001,0001
（5）1,0001,0001； -1,0001,0000
（6）-9999,9999,9999； -9999,9999,9999
（7）1,0000,9999,9999； 1

#include 
#include 
#include 
const int N = 1e5+10;// 最长的整数长度
char A[N] B[N];
//循环链表结点
struct node
{
    int data;           // 数值域
    int len;           // 长度
    node* pre;    // 前驱
    node* next;  // 后继
};

typedef node* List;

void Type_char（List *L char *s）;//!字符串转换为链表
List add（List A List B）;//!计算A+B
List sub（List A List B）;//!计算A-B
void print（List a）;//!输出a链表
void Init（）;//!初始化操作包括输入
void menu（）;//!菜单
int main（）
{
    menu（）;
    return 0;
}
/*测试数据
（1）-23456789; -76543211; 输出 -1000000
（2）-99999999; 1000000000000; 输出 999900000001
（3）100010001; -100010001; 输出 0
（4）100010001; -100010000; 输出 1
（5）-999999999999; -999999999999; 输出 -1999999999998
（6）1000099999999; 1; 输出 1000100000000
*/





// 将字符串字转换成链表
//!头部是符号位
void Type_char（List *L char *s）
{
    List p q;
    （*L） = （List）malloc（sizeof（node））;
    （*L）->pre = NULL;
    （*L）->next = NULL;
    （*L）->data = ‘+‘;           // 默认符号位为‘+‘
    p = （*L）;
    int len = strlen（s）sum = 1Size = 0End = 0;
    if（s[0] == ‘-‘）
    {
        （*L）->data = ‘-‘;
        End = 1;    // 如果是符号“，“则从字符串第二个字符位置开始
    }
    for （int i = len-1; i >= End; --i）
    {
        if（sum % 5）
        {
            q = （List）malloc（sizeof（node））;
            q->data = s[i] - ‘0‘;         // 字符转换为整数
            q->pre = p;
            p->next = q;
            p = q;
            Size++;
        }
        sum++;
    }

    // 循环连接
    p->next = （*L）;
    （*L）->pre = p;
    （*L）->len = Size;                    // 记录链表的长度-1 ———— 不带符号位的长度
}

// 加法
List add（List A List B）
{
    int len1 = A->len;
    int len2 = B->len;
    List a b;        // a为较长的整数链表， b为较短的整数链表
    if（len1 > len2）
    {
        a = A;
        b = B;
    }
    else
    {
        a = B;
        b = A;
    }
    len1 = a->len;          // 较长链表长度
    len2 = b->len;          // 较短链表长度

    int sum = 0;
    int temp = 0;             // 保存进位值
    while （sum != len1）
    {
        a = a->next;
        b = b->next;

        if （sum >= len2） a->data = a->data + temp;//已经超过较短链表长度，所以不需要加b->data
        else a->data = a->data + b->data + temp;
        temp = 0;
        if （a->data >= 10） a->data -= 10 temp = 1;//超过10表示有进位值
        sum++;
    }
    if （temp）
    {
        // 如果最后一位还有进位则创建一个新的结点放到队头
        List p = （List）malloc（sizeof（node））;
        p->data = temp;
        p->next = a->next;
        a->next->pre = p;
        p->pre = a;
        a->next = p;
        a = p;
        len1++;
    }
    a = a->next;       // 回到符号位
    a->len = len1;      // 注意头部长度要变化
    return a;
}

// 减法
List sub（List A List B）
{
    int len1 = A->len;
    int len2 = B->len;
    List a b;        // a为较长的整数链表， b为较短的整数链表
    if（len1 > len2）
    {
        a = A;
        b = B;
    }
    else if（len1 < len2）
    {
        a = B;
        b = A;
    }
    else
    {
        List tmp1 = A tm

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     文件      619520  2019-10-24 16:57  《数据结构课程设计》——课程设计报告之任意长整数加法.doc
     文件       26173  2019-10-24 16:57  任意大数流程图.png
     文件        7022  2019-10-24 16:42  任意长的整数加法.cpp
     文件      189571  2019-10-24 16:05  长整数.png