[C语言]有符号大数的加减

有符号大数的加减，比较两个有符号大数的大小，并输出加法和减法的结果

 代码在最下方：

-123456789987654321
-987654321123456789

123456789987654321<987654321123456789
123456789987654321+987654321123456789=111111111111111110
123456789987654321-987654321123456789=7625472

-123456789987654321
-987654321123456789

-123456789987654321>-987654321123456789
-123456789987654321+-987654321123456789=-111111111111111110
-123456789987654321--987654321123456789=10443520

123456789987654321
-987654321123456789

123456789987654321>-987654321123456789
123456789987654321+-987654321123456789=-864197531135802468
123456789987654321--987654321123456789=111111111111111110

-123456789987654321
987654321123456789

-123456789987654321<987654321123456789
-123456789987654321+987654321123456789=064197531135802468
-123456789987654321-987654321123456789=-111111111111111110

#include 
#include 
#include 

//函数声明

//_createNew
struct Node *_createNew();

//_createUnBigNumber
struct unBigNumber *_createUnBigNumber();

//_input
struct unBigNumber *_input(struct unBigNumber *List);
//_compare比较两个有符号大数
int _compare(struct unBigNumber *List1, struct unBigNumber *List2);

//_add
struct unBigNumber *_add(struct unBigNumber *List1, struct unBigNumber *List2, struct unBigNumber *List3);

//_minus
struct unBigNumber *_minus(struct unBigNumber *List1, struct unBigNumber *List2, struct unBigNumber *List3);

//_print
void _print(struct unBigNumber *List);

//_destroy
void _destroy(struct unBigNumber *List);

//_compare
int _compare(struct unBigNumber *List1, struct unBigNumber *List2);

//_compareAbs
int _compareAbs(struct unBigNumber *List1, struct unBigNumber *List2);

//_printCompare
void _printCompare(struct unBigNumber *List1, struct unBigNumber *List2,int flag);

//结构体

//创建新节点
struct Node {
    int data;
    struct Node *next, *prev;
};

//建立有符号大数链表
struct unBigNumber {
    int digitCount;
    int sign;
    struct Node *phead, *ptail;
};


//main函数
int main()
{
    struct unBigNumber *List1, *List2, *List3, *List4;
    List1 = _createUnBigNumber();
    List2 = _createUnBigNumber();
    List3 = _createUnBigNumber();
    List4 = _createUnBigNumber();

    //输入数据
    List1 = _input(List1);
    List2 = _input(List2);

    //比较大小
    int flag;//作为比较后的返回值 0为相等 1为大于 -1为小于
    flag = _compare(List1,List2);
    //比较绝对值大小
    int flag2;//绝对值比较后的返回值 0为相等 1为大于 -1为小于
    flag2 = _compareAbs(List1,List2);

        //打印比较大小的值
        _printCompare(List1,List2,flag);
//printf("flag=%d flag2=%dn",flag,flag2);

//加法
    //一.同号加法
        //1.同正
    if(List1 -> sign == 0 && List2 -> sign == 0) {
        List3 = _add(List1,List2,List3);
        List3 -> sign = 0;
    }
        //2.同负
    else if(List1 -> sign == -1 && List2 -> sign == -1){
        List3 = _add(List1,List2,List3);
        List3 ->sign = -1;
    }
    //二.异号减法
        //3.正负
    else if(List1 -> sign == 0 && List2 -> sign == -1){
            //①绝对值 List1 > List2
        if(flag2 == 1) {
            List3 = _minus(List1,List2,List3);
            List3 -> sign = 0;
        }
            //②List1 < List2
        else if(flag2 == -1) {
            List3 = _minus(List2,List1,List3);
            List3 -> sign = -1;
        }
            //③List1 = List2
        else if(flag2 == 0) {
            List3 -> phead -> data = 0;
            List3 -> sign = 0;
        }
    }
        //4.负正
    else if(List1 -> sign == -1 && List2 -> sign == 0) {
            //①绝对值 List1 > List2
        if(flag2 == 1) {
            List3 = _minus(List1,List2,List3);
            List3 ->sign = -1;
        }
            //②List1 < List2
        else if(flag2 == -1) {
            List3 = _minus(List2,List1,List3);
            List3 -> phead -> data = 0;
        }
            //③List1 = List2
        else if(flag2 == 0) {
            List3 -> phead -> data = 0;
            List3 -> phead -> data = 0;

        }
    }

    //打印加法结果
    _print(List1);
    printf("+");
    _print(List2);
    printf("=");
    _print(List3);
    printf("n");

//进行减法运算
    //一、同正相减
    if(List1 -> sign == 0 && List2 -> sign == 0) {
        //1.绝对值 List1 > List2
        if(flag2 == 1) {
            List4 = _minus(List1,List2,List3);
            List4 -> sign = 0;
        }
        //2.绝对值 List1 < List2
        else if(flag2 == 1) {
            List4 = _minus(List2,List1,List3);
            List4 -> sign = -1;
        }
        //3.绝对值 List1 = List2
        else if(flag2 == 0)
            List4 -> phead -> data = 0;
            List4 -> sign = 0;
        }
    //二、同负相减
    else if(List1 -> sign == -1 && List2 -> sign == -1) {
        //1.绝对值 List1 > List2
        if(flag2 == 1) {
            List4 = _minus(List1,List2,List3);
            List4 -> sign = -1;
        }
        //2.绝对值 List1 < List2
        else if(flag2 == 1) {
            List4 = _minus(List2,List3,List3);
            List4 -> sign = 0;
        }
        //3.绝对值 List1 = List2
        else if(flag2 == 1) {
            List4 -> phead -> data = 0;
            List4 -> sign = 0;
        }

    }
    //三、正负
    else if(List1 -> sign == 0 && List2 -> sign == -1) {
        List4 = _add(List1,List2,List3);
        List4 -> sign = 0;
    }
    //四、负正
    else if(List1 -> sign == -1 && List2 -> sign == 0) {
        List4 = _add(List1,List2,List3);
        List4 -> sign = -1;
    }



    //打印减法结果
     _print(List1);
    printf("-");
    _print(List2);
    printf("=");
    _print(List4);
    printf("n");

    //销毁链表
    _destroy(List1);
    _destroy(List2);
    _destroy(List3);
    _destroy(List4);

    return 0;
}

//createNew
struct Node *_createNew() {
    struct Node *p;
    p = (struct Node *)malloc(sizeof(struct Node));
    p -> next = NULL;
    p -> prev = NULL;

    return p;
};

//_doublylink
struct unBigNumber *_doublylink(struct unBigNumber *List) {
    struct Node *pnew;
    pnew = _createNew();

    //将大数链表进行头尾节点以及位数的处理
    List -> phead = pnew;//建立头节点
    List -> ptail = pnew;//建立尾节点
    List -> digitCount = 0;//位数为0
    return List;
}
//_createUnBigNumber
struct unBigNumber *_createUnBigNumber() {
    struct unBigNumber *pnew;
    pnew = (struct unBigNumber *)malloc(sizeof(struct unBigNumber));

    struct Node *p;
    p = _createNew();
    pnew -> phead = p;
    pnew -> ptail = p;
    pnew -> sign = 0;
    return pnew;
};

//_appendSign
struct unBigNumber *_appendSign(struct unBigNumber *List,int ch) {
    List -> sign = ch;
    return List;
};
//_appendFront
struct unBigNumber *_appendFront(struct unBigNumber *List, int ch) {
    struct Node *pnew;
    pnew = _createNew();
    pnew -> data = ch;

    //进行插入
        //尾节点没有数据
    if(List -> digitCount == 0){
        List -> ptail = pnew;
        List -> phead = pnew;
    }
    else {
        //将头节点指向pnew
            //储存phead
        struct Node *temp;
        temp = _createNew();//避免空指针
        temp = List -> phead;

        //插入pnew
        List -> phead = pnew;
        pnew -> next = temp;
        temp -> prev = pnew;
    }

    //位数加一
    ++List -> digitCount;
    return List;
}
//_appendTail
struct unBigNumber *_appendTail (struct unBigNumber *List, int ch) {
    struct Node *pnew;
    pnew = _createNew();
    pnew -> data = ch;
    //如果未储存数字
    if(List -> digitCount == 0) {
        List -> phead = pnew;
        List -> ptail = pnew;
        //位数加一
        ++List -> digitCount;
    }
    //如果只有一个数字0那么位数不变
    else if(List -> digitCount == 1 && List -> ptail -> data == 0) {
        List -> ptail = pnew;
        List -> phead = pnew;
    }
    else {
        List -> ptail -> next  = pnew;
        pnew -> prev = List -> ptail;
        List -> ptail = List -> ptail -> next;
        //位数加一
        ++List -> digitCount;
    }
//printf("_appendTailedn");
    return List;
}

//_normalize
struct unBigNumber *_normalize(struct unBigNumber *List) {
    //如果位数为0即phead为空
    if(List -> digitCount == 0) {
        List = _appendTail(List,0);
    }

    //除去最高位数的0
    while(List -> phead -> data == 0 && List -> digitCount > 1) {
        struct Node *temp;
        temp = List -> phead;
        List -> phead = temp -> next;
        temp -> next -> prev = List -> phead;
        --List -> digitCount;
    }
//printf("normalizedn");
    return List;
}

//_input
struct unBigNumber *_input(struct unBigNumber *List) {
    List = _doublylink(List);

    //过滤掉非数
    char ch;
    do {
        ch = getchar();
        if(ch == '-') {
            List = _appendSign(List,-1);
        }
    }
    while(ch < '0' || ch > '9');


    //从最高位读取数字
    while(ch >= '0' && ch <= '9') {
        List = _appendTail(List,ch - '0');
        ch = getchar();
    }

    //规范化去掉最高位多余的0
    List = _normalize(List);
//printf("inputedn");
    return List;
}
//_compareAbs
int _compareAbs(struct unBigNumber *List1, struct unBigNumber *List2) {
    //比较位数
    int a, b;//记录List1，List2的位数
    a = 0;
    b = 0;
    struct Node *p1, *p2;//记录节点
    p1 = List1 -> phead;
    p2 = List2 -> phead;

    while(p1) {
        p1 = p1 -> next;
        a++;
    }
    while(p2) {
        p2 = p2 -> next;
        b++;
    }
    //绝对值List1 > List2
    if(a > b) {
        return 1;
    }
    else if(a < b) {
        return -1;
    }
    else if(a == b) {
        p1 = List1 -> phead;//重新指向头节点
        p2 = List2 -> phead;
        while(p1 && p2) {
            if(p1 -> data > p2 -> data) {
                return 1;
            }
            else if(p1 -> data < p2 -> data){
                return -1;
            }
            else if(p1 -> data == p2 -> data) {
                p1 = p1 -> next;
                p2 = p2 -> next;
            }
        }
        if(!p1 && !p2)
            return 0;
    }
    exit(11111);
}
//_compare
int _compare(struct unBigNumber *List1, struct unBigNumber *List2){
    int flag2;
    //比较绝对值大小
    flag2 = _compareAbs(List1,List2);
    if(List1 -> phead -> data == 0 && List2 -> phead -> data == 0) {
        return 0;
    }
    else if(List1 -> sign == 0 && List2 -> sign == -1) {
        return 1;
    }
    else if(List1 -> sign == -1 && List2 -> sign == 0) {
        return -1;
    }
    else {
        //同为正
        if(List1 -> sign == 0 && List2 -> sign == 0){
            if(flag2 == 1) {
                return 1;
            }
            else if(flag2 == 0) {
                return 0;
            }
            else if(flag2 == -1) {
                return -1;
            }

        }
        //同为负
        else if(List1 -> sign == -1 && List2 -> sign == -1) {
            flag2 = _compareAbs(List1,List2);
            if(flag2 == -1) {
                return 1;
            }
            else if(flag2 == 0) {
                return 0;
            }
            else if(flag2 == 1) {
                return -1;
            }
        }
        //正负
        else if(List1 -> sign == 0 && List2 -> sign == -1) {
                return 1;
        }
        //负正
        else if(List1 -> sign == -1 && List2 -> sign == 0) {
                return -1;
        }
    }
    exit(22222);
}

//_add
struct unBigNumber *_add(struct unBigNumber *List1, struct unBigNumber *List2, struct unBigNumber *List3) {
     //双向化链表C
    List3 = _doublylink(List3);

    //进行加法运算
    int iCarry = 0;//进位储存
    int temp;//储存两数相加的结果
    int result;//储存余数
    struct Node *p1, *p2;//进行操作的节点
    p1 = List1 -> ptail;//从尾节点开始处理
    p2 = List2 -> ptail;

    //进行循环计算
    while(p1 != List1 -> phead && p2 != List2 -> phead) {
        //进行余数和进位的计算
        temp = p1 -> data + p2 -> data + iCarry; //加上进位
        iCarry = temp / 10;
        result = temp % 10;

        //将操作所得到的余数添加到List3
        List3 = _appendFront(List3,result);

        //两个链表都向前移动一位
        p1 = p1 -> prev;
        p2 = p2 -> prev;
    }

    //如果位数相同
    if(p1 == List1 -> phead && p2 == List2 -> phead) {
        temp = p1 -> data + p2 -> data + iCarry;
        iCarry = temp / 10;
        result = temp % 10;
        List3 = _appendFront(List3,result);
        return List3;
    }

    int x = p2 -> data;//储存p2 -> phead的值，只做一次运算,避免改掉phead的值
    //处理List1剩余位
    while(p1 != List1 -> phead ) {
        temp = p1 -> data + x + iCarry;
        iCarry = temp / 10;
        result = temp % 10;
        x = 0;
        List3 = _appendFront(List3,result);
        p1 = p1 -> prev;

        //加上phead的值
        if(p1 == List1 -> phead) {
                result = p1 -> data + iCarry;
            List3 = _appendFront(List3,result);
        }
    }

    int y = p1 -> data;
    //处理List2剩余位
    while(p2 != List2 -> phead) {
        temp = p2 -> data + y + iCarry;
        iCarry = temp / 10;
        result = temp % 10;
        y = 0;
        List3 = _appendFront(List3,result);
        p2 = p2 -> prev;
        if(p2 == List2 -> phead) {
                result = p2 -> data + iCarry;
            List3 = _appendFront(List3,result);
        }
    }

    //如果两个链表都已经遍历完仍有进位则List3在加一位
    if(iCarry != 0) {
        List3 = _appendFront(List3,iCarry);
    }
    return List3;

};
//minus 做减法
struct unBigNumber *_minus(struct unBigNumber *List1, struct unBigNumber *List2, struct unBigNumber *List3) {
    //双向化链表C
    List3 = _doublylink(List3);

    //进行减法运算
    int iCarry = 0;//借位储存
    int temp;//储存两数相减的结果
    int result;//储存余数
    struct Node *p1, *p2;//进行操作的节点
    p1 = List1 -> ptail;//从尾节点开始处理
    p2 = List2 -> ptail;

    //进行循环计算
    while(p1 != List1 -> phead && p2 != List2 -> phead) {
        //进行余数和进位的计算
        temp = p1 -> data  - p2 -> data - iCarry; //借位减去1
        if(temp < 0) {
            temp += 10;
            iCarry = 1;
        }
        else
            iCarry = 0;
        result = temp;

        //将操作所得到的余数添加到List3
        List3 = _appendFront(List3,result);

        //两个链表都向前移动一位
        p1 = p1 -> prev;
        p2 = p2 -> prev;
    }

    //位数相同
    if(p1 == List1 -> phead && p2 == List2 -> phead) {
        temp = p1 -> data - p2 -> data - iCarry;
        result = temp % 10;
        List3 = _appendFront(List3,result);
        List3 = _normalize(List3);

        return List3;
    }

    //处理List1剩余位
    int x = List2 -> phead -> data;//同上
    while(p1 != List1 -> phead) {
        //减去减数的第一个数
        if(p2 -> data != 0) {
            temp = p1 -> data - x - iCarry;
            if(temp < 0) {
                temp += 10;
            }
            else
                iCarry = 0;
            result = temp;

            List3 = _appendFront(List3,result);
            p1 = p1 -> prev;
            x = 0;
        }

        //将List1剩余的值进行拷贝
        else {
            temp = p1 -> data - iCarry;
            if(temp < 0) {
                temp += 10;
            }
            else
                iCarry = 0;

            result = temp;
            List3 = _appendFront(List3,result);
            p1 = p1 -> prev;

        }

        //加上phead的值
        if(p1 == List1 -> phead) {
            List3 = _appendFront(List3,List1 -> phead -> data);
            break;
        }
    }
    List3 = _normalize(List3);

    return List3;
};
//_print
void _print(struct unBigNumber *List) {
    if(List -> sign == -1)
        printf("-");
    struct Node *p;
    p = List -> phead;
    while(p) {
        printf("%d",p -> data);
        p = p -> next;
    }
}

//_destroy
void _destroy(struct unBigNumber *List) {
    struct Node *p;
    p = List -> phead;

    while(p) {
        List -> phead = p -> next;
        free(p);
        p = List -> phead;
    }
}

//_printCompare
void _printCompare(struct unBigNumber *List1, struct unBigNumber *List2,int flag) {
    //打印比较结果
    switch(flag) {
    case 0:
        _print(List1);
        printf("=");
        _print(List2);
        printf("n");
        break;
    case 1:
        _print(List1);
        printf(">");
        _print(List2);
        printf("n");
        break;
    case -1:
        _print(List1);
        printf("<");
        _print(List2);
        printf("n");
        break;
    default:
        printf("Error");
        break;
    }
}