大数相加 用栈

#include "StdAfx.h"




using namespace std;


const int Maxn = 1000+10;



#define DATA char

typedef struct _STACKNODE_
{
     DATA* Data;
    _STACKNODE_* Next;
    void InitMember()
    {
        Next = NULL;
        Data = NULL;
    }
}STACKNODE,*PSTACKNODE,**PPSTACKNODE;


typedef struct _STACK_
{
    PSTACKNODE Head;
    PSTACKNODE Tail;
    int iCount;
    void InitMember()
    {
        Head = Tail = NULL;
        iCount = 0;
    }
}STACK,*PSTACK;

bool InStack(PSTACK Stack,DATA Data);

bool OutStack(PSTACK Stack,DATA* Data);

bool IsEmpty(PSTACK Stack);


bool GetTop(PSTACK Stack,DATA* Data);





int main()
{
    int i = 0;
    int n = 0;
    DATA Data  = '0';
    STACK Stack1 ;
    STACK Stack2 ;
    STACK Stack3;
    Stack1.InitMember();
    Stack2.InitMember();
    Stack3.InitMember();
    cout << "输入数字的位数" << endl;
    cin >> n;
    for (i = 0;i<n;i++)
    {
        cin >> Data;
        InStack(&Stack1,Data-'0');
    }
    cout << "输入数字的位数" << endl;
    cin >> n;
    for (i = 0;i<n;i++)
    {
        cin >> Data;
        InStack(&Stack2,Data-'0');
    }
    Data = 0;
    while (!IsEmpty(&Stack1)||!IsEmpty(&Stack2))
    {
        DATA DataTemp = '0';
        DATA DataTemp1 = '0';
        DATA DataTemp2 = '0';
        GetTop(&Stack1,&DataTemp1);
        GetTop(&Stack2,&DataTemp2);
        OutStack(&Stack1,&DataTemp1);
        OutStack(&Stack2,&DataTemp2);
        DataTemp = (DataTemp1+DataTemp2+Data)%10;
        Data = (DataTemp1+DataTemp2+Data)/10;
        InStack(&Stack3,DataTemp);
         
    }
    if (Data>0)
    {
        cout << 1 ;
    }
    while (!IsEmpty(&Stack3))
    {
        OutStack(&Stack3,&Data);
        printf("%d",Data);
    }
    cout << endl;
    return 0;
}
bool InStack(PSTACK Stack,DATA Data)
{
    PSTACKNODE Node = (PSTACKNODE)malloc(sizeof(PSTACKNODE));
    if (Node==NULL)
    {
        return false;
    }
    else 
    {
        Node->InitMember();
        Node->Data = (DATA*)malloc(sizeof(DATA));
        if (Node->Data==NULL)
        {
            return false;
        }
        memcpy((Node->Data),&Data,sizeof(DATA));
        
        if (Stack->iCount==0)
        {
            Stack->Head = Stack->Tail = Node;
        }
        else 
        {
            Stack->Head->Next = Node;
            Stack->Head = Node;
        }
        Stack->iCount++;
    }
    return true;
}


bool IsEmpty(PSTACK Stack)
{
    if (Stack->iCount==0)
    {
        return true;
    }
    return false;
}

bool OutStack(PSTACK Stack,DATA* Data)
{
    if (IsEmpty(Stack))
    {
        return false;
    }
    memcpy(Data,Stack->Head->Data,sizeof(DATA));
    free(Stack->Head->Data);
    PSTACKNODE PreNode = Stack->Tail;
    PSTACKNODE Node = Stack->Head;
    if (Stack->iCount!=1)
    {
        while (true)
        {
            if (PreNode->Next==Stack->Head)
            {
                break;
            }
            PreNode = PreNode->Next;
        }
        Stack->Head = PreNode;
    }
    Stack->iCount--;
     
    return true;
    
    
}

bool GetTop(PSTACK Stack,DATA* Data)
{
    if (IsEmpty(Stack))
    {
        return false;
    }
    memcpy(Data,Stack->Head->Data,sizeof(DATA));
    return true;
}