recursion in stack to get the maximum element and copying stacks

[hala esaili]

am still new to stacks and recursion and am trying to implement two functions using recursion to get the maximum element in a stack and copying one stack into the other
but it keeps repeating some elements and i dont understand why!!

this is the code for the functions:

void copyStack(MyStack &firstStack, MyStack &secondStack)
{
    if(!firstStack.empty())    {
        string x=firstStack.top();
        firstStack.pop();
        //secondStack.push(x);
        copyStack(firstStack,secondStack);
        secondStack.push(x);
        firstStack.push(x);
    }
}
string getMax(MyStack &stack)
{
    string a=stack.top();
    stack.pop();
    getMax(stack,a);
    stack.push(a);
    return a;    
}
 
void getMax(MyStack &stack,string &max)
{
    if(stack.empty()!=true)
    {
        string x=stack.top();
        if(x>max)
            max=x;
        stack.pop();
        getMax(stack,max);
        stack.push(x);
    }
}

any answer can help me alot!!
thank you in advance ^_^

[ehud117]

It looks okey, except that those will revert the order of the stack, what is the implementation of the class MyStack?

[hala esaili]

hehehe it has an inheritance from a linked list :P

this is the linked list

#include "LList.h"
 
LList::LList(void)
{
    first=0;
}
 
LList::~LList(void)
{
    initializeList();
}
bool LList::isEmpty()
{
    if(first==0)
        return true;
    else
        return false;
}
bool LList::isFull()
{
    return false;
}
void LList::initializeList()
{
    Node* temp;
    if(first!=0)
    {
        temp=first->getLink();
        delete first;
        first=temp;
        initializeList();
    }
}
int LList::getSize()
{
    int count=0;
    if(first!=0){    Node* temp=first;
 
    while(temp!=0)
    {
        temp=temp->getLink();
        count++;
    }}
    return count;
}
string LList::front()
{
    if(first!=0)
        return first->getInfo();
    else
        return "";
}
string LList::back()
{
    Node*temp=first;
    if(temp==0)
        return "";
    else
        while(temp->getLink()!=0)
            temp=temp->getLink();
    return temp->getInfo();
}
void LList::insertAt(int position,string value)
{
    Node*current;
    Node* newN=new Node;
    int counter=0;
    newN->setInfo(value);
    if(first==0)
    {
        first=new Node;
        first->setInfo(value);
        first->setLink(0);
    }
    if(position==0)
    {
        newN->setLink(first);
        first=newN;
    }
    else
    {
        current=first;
        while(counter<position&&current->getLink()!=0)
        {
            current=current->getLink();
            ++counter;
        }
        newN->setLink(current->getLink());
        current->setLink(newN);
    }
 
}
void LList::deleteAt(int pos)
{        int count=0;
Node* current=first;
Node*trail=new Node;
if(first!=0)
{
    if(pos==0)
        if(first->getLink()!=0)
        {
            trail=current->getLink();
            delete current;
            first=trail;
        }
        else
        {
            delete first;first=0;
        }
    else{
 
 
        while(count<pos&&current->getLink()!=0)
        {
            trail=current;
            current=current->getLink();
            ++count;
        }
        trail->setLink(current->getLink());
        delete current;}
}
 
}
 

an this is the stack

void MyStack::push(string value)
{
    insertAt(0,value);
}    
void MyStack::pop()
{
    deleteAt(0);
}
string MyStack::top()
{
    return front();
}
bool MyStack::empty()
{
    return isEmpty();
}
bool MyStack::full()
{
    return isFull();
}
int MyStack::size()
{
    return getSize();
}

and the linked list has a first of type Node
this is Node class

Node* Node::getLink()
{
return link;
}
void Node::setLink(Node* newLink)
{
link=newLink;
}
string Node::getInfo()
{
return info;
}
void Node::setInfo(string newInfo)
{
info=newInfo;
}