数据结构设计——大数计算器

  1 /*
  2 大数计算器
  3 
  4 实验目的：数据结构主要是研究计算机存储，组织数据，非数值计算程序设计问题中所 出现的计算机操作对象以及它们之间的关系和操作的学科。数据结构是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。学习数据结构是为了将实际问题中涉及的对象在计算机中表示出来并对它们进行处理。通过课程设计可以提高学生的思维能力，促进学生的综合应用能力和专业素质的提高。
  5 
  6 
  7 
  8 实验要求：要求包含加、减、乘、除、取余的两个超出普通计算器范围的大数运算。
  9 
 10 
 11 程序代码：
 12 *******************************************************************************
 13 */

//Large_Number.h
#define MAXSIZE 200
#define TMAXSIZE 400

typedef class SeqList {
public:
    int data[TMAXSIZE];
    int length;
public:
    SeqList(){};
    SeqList * operator +( SeqList *P2) ;
    SeqList * operator -( SeqList *P2) ;
    SeqList * operator *( SeqList *P2) ;
    SeqList * operator /( SeqList *P2) ;
    SeqList * operator %( SeqList *P2) ;
    int operator <( SeqList *P2) ;
} *PSeqList;

//函数申明区
PSeqList Init_SeqList(void);//创建一个顺序表
PSeqList Input_SeqList(PSeqList L, char a[]);//将数据输入到顺序表中
int Length_SeqList(PSeqList L);//获得表长度
void Output_SeqList(PSeqList PL);//输出顺序表
void Distory_SeqList(PSeqList PL);
PSeqList e_zero(PSeqList P3);//擦除多余的0
PSeqList NInput_SeqList(PSeqList L, int n);//普通数转化为大数

//两个多项式或者大数相乘
PSeqList SeqList::operator *( SeqList *P2) 
{
    int addlength = 0, i, j;
    PSeqList P3;
    P3 = Init_SeqList();
    i = length;
    j = P2->length;
    addlength = i + j;
    for (i = 0; i < addlength; i++)
        P3->data[i] = 0;
    P3->length = i;
    for (i = length - 1; i >= 0; i--)
        for (j = P2->length - 1; j >= 0; j--)
        {
            P3->data[i + j + 1] += (data[i] * P2->data[j]);
            if (P3->data[i + j + 1] >= 10)//如果P3->data的第i+j+1位大于或等于10，要让它进位
            {
                P3->data[i + j] += P3->data[i + j + 1] / 10;
                P3->data[i + j + 1] = P3->data[i + j + 1] % 10;
            }
        }
    P3 = e_zero(P3);
    return P3;
}

PSeqList SeqList::operator +( SeqList *P2) 
{
    PSeqList P3;
    int i, j, ijmax, count = 0;
    int P1_0 = data[0];
    int P2_0 = P2->data[0];//保留下面操作中将要修改的值
    P3 = Init_SeqList();
    i = length;
    j = P2->length;
    ijmax = i > j ? i : j;
    for (i = 0; i < ijmax + 1; i++)//比最大长度大一个，这样不会有溢出位
        P3->data[i] = 0;//给所有位数置零
    P3->length = ijmax + 1;
    for (i = length - 1, j = P2->length - 1; count < ijmax; count++)
        //当P1、P2中都有数据时，两者同时向前移动一个单位，计数加1
    {
        P3->data[ijmax - count] += (data[i] + P2->data[j]);
        if (P3->data[ijmax - count] >= 10)
        {
            P3->data[ijmax - count - 1] = P3->data[ijmax - count] / 10;
            P3->data[ijmax - count] = P3->data[ijmax - count] % 10;
        }
        if (i >= 0) i--;//P1还有数，减一
        if (i < 0){//P1没有数，数data[0] = 0;
            i = 0; data[i] = 0;
        }
        if (j >= 0) j--;
        if (j < 0){//P2没有数，数data[0] = 0;
            j = 0; P2->data[j] = 0;
        }
    }
    data[0] = P1_0;
    P2->data[0] = P2_0;//还原修改的值
    P3 = e_zero(P3);
    return P3;
}

//多项式相减，分前后值P1-P2
PSeqList SeqList::operator -(SeqList *P2)
{
    PSeqList P3;
    int i, j, ijmax, count = 0, ismz = 0, cf;//ismz来判断结果的正负，如果为负数，ismz为1,k表示进位标志
    int P1_0 = data[0];
    int P2_0 = P2->data[0];//保留下面操作中将要修改的值
    P3 = Init_SeqList();
    i = length;
    j = P2->length;
    ijmax = i > j ? i : j;
    for (i = 0; i < ijmax; i++)//和最大长度相同，这样不会有溢出位
        P3->data[i] = 0;//给所有位数置零
    P3->length = ijmax;
    for (i = length - 1, j = P2->length - 1; count < ijmax; count++)//当P2中都有数据时，两者同时向前移动一个单位，计数加1
    {
        P3->data[ijmax - count - 1] += (data[i] - P2->data[j]);
        if (P3->data[ijmax - count - 1] < 0)
        {    
            if (ijmax - count - 1 != 0)//因为当ijmax - count - 1 = 0时，P3->data[ijmax-count-2] 等价于P3->data[-1],不存在，编译过程中会出现问题
                P3->data[ijmax - count - 2] -= 1;
            else
            {
                ismz = 1;
            }
            P3->data[ijmax - count - 1] = P3->data[ijmax - count - 1] + 10;
        }
        if (i >= 0) i--;//P1还有数，减一
        if (i < 0){//P1没有数，数data[0] = 0;
            i = 0; data[i] = 0;
        }
        if (j >= 0) j--;
        if (j < 0){//P2没有数，数data[0] = 0;
            j = 0; P2->data[j] = 0;
        }
    }
    data[0] = P1_0;
    P2->data[0] = P2_0;//还原修改的值
    if (ismz == 1)
    {
        for (cf = 0, count = 0; count < ijmax; count++)//当P2中都有数据时，两者同时向前移动一个单位，计数加1
        {
            P3->data[ijmax - count - 1] = 0 - P3->data[ijmax - count - 1] - cf;
            cf = 0;
            if (P3->data[ijmax - count - 1] < 0)
            {
                cf = 1;
                P3->data[ijmax - count - 1] = P3->data[ijmax - count - 1] + 10;
            }
        }
        P3 = e_zero(P3);
        P3->data[0] *= -1;
    }
    P3 = e_zero(P3);
    return P3;
}//end减法

PSeqList SeqList::operator /(SeqList *P2)//取整操作
{
    PSeqList P1 = this;
    PSeqList P3;
    PSeqList P4;
    P3 = Init_SeqList();
    P4 = Init_SeqList();
    P3->length = length - P2->length + 1;
    if (P3->length < 0)//如果前者小于后者，结果为0
    {
        P3->length = 1;
        P3->data[0] = 0;
        return P3;//返回，结束操作
    }
    for (int i = P3->length-1; i >= 0; i--)
    {
        int j = 0;
        P4 = NInput_SeqList(P4,  i);
        P4 = *P4 * P2;
        while (1){
            if (*P1 < P4)  break;
            P1 = *P1 - P4;
            j++;
        }
        P3->data[P3->length -1 - i] = j;
    }
    Distory_SeqList(P4);
    P3 = e_zero(P3);
    return P3;
}
PSeqList SeqList::operator %(SeqList *P2)
{
    PSeqList P1 = this;
    PSeqList P3;
    P3 = Init_SeqList();
    P3 = *P1 - (*(*P1 / P2)*P2);
    P3 = e_zero(P3);
    return P3;
}

int SeqList::operator < (SeqList *P2)
{
    SeqList *P3 = this;
    if (length < P2->length)
        return 1;
    if (length > P2->length)
        return 0;
    if ((*P3 - P2)->data[0] < 0)
        return 1;
    else
        return 0;
}


//创建一个顺序表，入口参数无，返回一个指向顺序表的指针，指针值为零表示分配空间失败
PSeqList Init_SeqList(void)
{
    PSeqList PL;
    PL = (PSeqList)malloc(sizeof(SeqList));
    if (PL)
        PL->length = 0;
    else
    {
        cout << "内存分配失败..." << endl;
        exit(-1);
    }
    return (PL);
}

//数据输入
PSeqList Input_SeqList(PSeqList L, char a[])
{
    int i, a_length = 0;
    a_length = strlen(a);
    for (i = 0; i < a_length; i++)
        L->data[i] = (int)a[i] - '0';//将char型整数转换成int型整数
    L->length = i;
    return L;
}
PSeqList NInput_SeqList(PSeqList L, int n)
{
    int i;
    L->data[0] = 1;
    for (i = 1; i <= n; i++)
        L->data[i] = 0;
    L->length = n+1;
    return L;
}

//读取顺序表的当前长度
int Length_SeqList(PSeqList L)
{
    if (!L)
    {
        cout << "无PL指针，退出程序..." << endl;
        exit(-1);
    }
    return (L->length);
}

//顺序表整体输出
void Output_SeqList(PSeqList PL)
{
    int i;
    for (i = 0; i < PL->length; i++)
        cout << PL->data[i];
}

PSeqList e_zero(PSeqList P3)//擦除多余的0
{
    int count = 0;
    for (int i = 0; i < P3->length - 1; i++) //如果i和count 同时增加，则说明P3->data[i]为0，则为默认值，可以去掉，保留下来的就是有效的数据
        if (P3->data[i] == 0 && i == count)
            count++;        
    if (count != 0)
        for (int i = 0; i < P3->length - 1; i++)
            P3->data[i] = P3->data[i + count];
    P3->length -= count;//实参传进来的位数总和去掉无效位数就是，结果顺序表的长度
    return P3;
}

void Distory_SeqList(PSeqList PL)
{
    free(PL->data);
}

//end Large_Number.h
**************************************************************************************************************
//Large_Number_calculator.cpp
//可以实现两个200位以内的数值运算，如果需要运算更大的数可以将宏定义中的长度增大
#include<iostream>
#include<cmath>
#include<cstring>
#include<windows.h>
using namespace std;

#include"Large_Number.h"

//主函数
int main(void)
{
    //将一个长整形按位分开，依次存放在数组data中
    PSeqList P1, P2, P3;
    char a[MAXSIZE], b[MAXSIZE];
    char order = 4;    
    int keep_result = 0;
    P1 = Init_SeqList();
    P2 = Init_SeqList();
    while (1)
    {
        int is_exit;
    
        int operate = 1;
        if (keep_result != 1)
        {
            cout << "请输入大数a 操作符 大数b （中间用空格或换行隔开）：" << endl;
            cin >> a;
            P1 = Input_SeqList(P1, a);    
        }
        else
        {
            P1 = P3;
            cout << "请输入 操作符 大数b （中间用空格或换行隔开）：" << endl;    
        }
        cin >> order >> b;
        P2 = Input_SeqList(P2, b);
        switch (order)
        {
        case '+':P3 = *P1 + P2; break;
        case '-':P3 = *P1 - P2; break;
        case '*':P3 = *P1 * P2; break;
        case '/':P3 = *P1 / P2; break;
        case '%':P3 = *P1 % P2;    break;
        default:
            cout << "错误的操作符,无法进行操作..." << endl;
            operate = 0;//操作失败标志
        }
        if (operate == 1)
        {
            int i;
            int max_length = P1->length > P2->length ? P1->length : P2->length;
            max_length = max_length > P3->length ? max_length : P3->length;
            for (i = 0; i < max_length + 4; i++)
                cout << "-";
            cout << endl;
            if (P1->length >= P2->length)  {
                cout << "  ";
                Output_SeqList(P1);
                cout << "
" << order << " ";
                for (i = 0; i < P1->length - P2->length; i++) cout << " ";
                Output_SeqList(P2);
            }
            else {
                for (i = 0; i < P2->length - P1->length + 2; i++)
                    cout << " ";
                Output_SeqList(P1);
                cout << "
" << order << " ";
                Output_SeqList(P2);
            }
            cout << endl;
            for (i = 0; i < max_length + 6; i++)
                cout << "-";
            cout << "
= ";
            Output_SeqList(P3);
            cout << "
结果的的长度:" << Length_SeqList(P3) << endl;
        }
        cout << "是否继续运算?，任意字符、退出，1、继续 : " ;
        cin >> is_exit;
        if (is_exit != 1)   break;
        cout << "是否保留上次运算结果并在此基础上进行运算(1、保存，其他、不保存) : ";
        cin >> keep_result;
    }    
    Distory_SeqList(P1);
    Distory_SeqList(P2);
    Distory_SeqList(P3);
    system("pause");
    return 0;
}
//end Large_Number_calculator

 本篇文章中所有数据结构都是后期整理的，如有问题欢迎指正，转载请注明出处http://www.cnblogs.com/a1982467767/p/8889528.html

 

实验结果：

 

心得：

一开始，我只是按照大数相乘的思路，以顺序表的形式设计了大数乘法的运算，当大数相乘算法实现了吗，我又想设计下大数相加和相减运算，但由于一开始设计大数相减时用的是分段计算，单个大数相减运算就写了一百多行，虽然得到的结果是正确的，但还是感觉这段代码就是垃圾代码，整个结构过于复杂，后来听了老师的一些建议，我就在大数相加的基础上修改，并通过标志位，成功完成了大数相减运算，但程序中存在BUG（在最后的大数计算器设计中发现的，经过将近两个小时的测试，发现了错误的根源——两个同等长度，前面N位基本相同，导致最后的结果没有加上负号，使整个大数计算过程出现错误，最后的验算结果不匹配）。在设计完大数加减乘之后，我想就这样结束了，因为当时我头脑中想象的大数想除和取余太过于复杂，但是在一次睡醒时，我脑中突然蹦出了大数相除的思想，虽然后来操作工程中存在很多问题，但还是再多次测试时候解决了（比如多次计算，内存不足，进入死循环，测试结果明显不正确，测试结果只存在微小的错误，但是利用此次结果在计算时出现明显错误等问题）；最后设计的是大数取余运算，在前面的基础上很轻松的就解决了；虽然最后留下来的代码就三百多行，但实际操作过程中花费了大量的时间，不断地修改和删除，加总起来的代码量也该有两千行了，在不断的测试过程中，我明白了结构的重要性；一开始我是用c写的，后来觉得单纯的函数操作，不如用运算符来代替，这样看起来舒服，操作起来便捷，后来我把栈结构体写成了栈的类，重载了运算符，虽然还是有些不明了，如果使用引用类型作为参数，着呢个结构可能会更优化点，但我还是习惯了用指针类型；美中不足的是我现在的基础还不能实现图形化这能将界面优化到这种程度了；

要写好一个完整的程序，首先要设置它的结构，在结构的基础上设置框架流程，并更具流程进行书写，这样会少浪费很多时间进行思考和测试，这应该就是数据结构的精髓。吧；在做完这个题目过后，我感觉我的设计思维有一定的提升，在很多困难面前，以程序员不找出Bug不睡觉的态度，真的有促进作用，这种感觉真的很棒。