數據結構設計——大數計算器

  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 << "\n" << 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 << "\n" << order << " ";
                Output_SeqList(P2);
            }
            cout << endl;
            for (i = 0; i < max_length + 6; i++)
                cout << "-";
            cout << "\n= ";
            Output_SeqList(P3);
            cout << "\n結果的的長度:" << 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不睡覺的態度，真的有促進作用，這種感覺真的很棒。