码迷,mamicode.com
首页 > 其他好文 > 详细

栈及栈的C++实现

时间:2015-10-05 15:29:08      阅读:196      评论:0      收藏:0      [点我收藏+]

标签:

栈:栈是一种数据结构,栈里元素的添加和删除只能在栈的末端进行。它是一种“后进先出”(LIFO)的数据结构。

栈的操作:

initializeStack:初始化栈,使得为一个空栈。

destroyStack:清空栈里所有的元素,使得为一个空栈。

isEmptyStack:判断栈是否为空,如果为空,返回true,否则返回false。

isFullStack  : 判断栈是否溢出,如果溢出,返回true,否则返回false。

push : 添加一个新的元素到栈顶。前提是栈存在,且栈没有溢出。

top  : 返回栈顶元素。前提是栈存在,且栈没有溢出。

pop  : 删除栈顶元素。前提是栈存在,且栈不为空。

 

栈的实现可以用数组和链表两种类型来实现。

1.用数组来实现栈:

因为栈里所有的元素都是同一数据类型,所以可以用数组来实现一个栈。栈的第一个元素放在数组的第一个位置,栈的第二个元素放在数组的第二个位置,以此类推。

为了跟踪数组的top position ,我们声明另一个变量stackTop.

下面的类stackType定义了一个栈为ADT。

template<class Type> class stackType
{
public:
    const stackType<Type>& operator=(const stackType<Type>&);//重载赋值运算符
    void initializeStack();
    //Function to initialize the stack to an empty state
    //precondition:stackTop=0
    bool isEmptyStack() const;
    //Function to determine whether the stack is empty
    //postcondition:Returns true if the stack is
    //              empty,otherwise returns false
    bool isFullStack() const;
    //Function to determine whether the stack is full
    //postcondition:Returns true if the stack is full
    //              otherwise returns false
    void destroyStack();
    //Function to remove all the elements from the stack
    //Postcondition: stackTop = 0.
    void push(const Type& newItem);
    //Function to add newItem to the stack.
    //precondition:The stack exists and is not full
    //postcondition:the stack is changed and newItem is
    //              added to the top of the stack.
    Type top() const;
    //Function to return the top element of the stack.
    //precondition:the stack exists and is not empty.
    //postcondition:If the stack is empty,the program
    //              terminates;otherwise ,the top element
    //              of the stack is returned.
    void pop();
    //Function to remove the top element of the stack.
    //precondition:The stack exists and is not empty.
    //postcondition:The stack is changed and the top
    //              element  is removed from the stack.
    stackType(int stackSize = 100);
    //constructor
    //Create an array of the size stackSize to hold the
    //stack elements.the default stack size is 100.
    //Postcondition:The variable list contains the base
    //address of the array,stackTop=0,
    //and maxStackSize =stackSize.
    stackType(const stackType<Type>&otherStack);
    //copy constructor
    ~stackType();
    //desturctor;
    //Remove all the elements from the stack.
    //Postcondition:The array (list)holding the stack
    //elements is deleted.
    
private:
    int maxStackSize;//variable to store the maximum
                    //stack size.
    int stackTop;//variable to point to the top of the
                //stack
    Type *list;//pointer to the array that holds the stack
                //elements
    
    void copyStack(const stackType<Type>& otherStack);
    //Function to make a copy of otherStack.
    //Postcondition:A copy of otherStack is created and
    //assigned to this stack.
};

定义栈的初始化函数:

template <class Type>
void stackType<Type>::initializeStack()
{
    stackTop = 0;
}

定义Destroy Stack函数:

在用数组实现的栈的过程中,销毁栈的操作和初始化栈操作相似。如果我们把stackTop=0,所有栈元素就被销毁了,尽管元素仍然在栈里,但是stackTop的值表明栈是否为空。

template <class Type>
void stackType<Type>::destroyStack()
{
    stackTop = 0;
}

定义Empty Stack函数

既然stackTop的值决定栈是否为空,如果stackTop = 0,则栈为空,否则栈不为空。

template <class Type>
bool stackType<Type>::isEmptyStack() const
{
    return (stackTop == 0);
}

定义Full Stack函数:

如果stackTop = maxStackSize,栈满。

template<class Type>
bool stackType<Type>::isFullStack() const
{
    return (stackTop == maxStackSize);
}

定义入栈函数:push函数

template<class Type>
void stackType<Type>::push(const Type &newItem)
{
    if (!isFullStack()) {
        list[stackTop]=newItem;
        stackTop++;
    }
    else
       cout<<"Cannot add to a full stack."<<endl;

}

定义top函数:return the top element

template<class Type >
Type stackType<Type>::top() const
{
    assert(stackTop !=0);//if the stack is empty,
                        //terminate the program.
    return list[stackTop-1];
}

定义pop函数

template<class Type >
void stackType<Type >::pop()
{
    if(!isEmptyStack())
        stackTop--;
    else
        cout<<"Cannot remove from an empty stack,"<<endl;
}//end pop

定义Copy Stack 函数:

template<class Type >
void stackType<Type>::copyStack(const stackType<Type> &otherStack)
{
    delete [] list;
    maxStackSize = otherStack.maxStackSize;
    stackTop = otherStack.stackTop;
    
    list = new Type(maxStackSize);
    assert(list != NULL );
    
    //copy otherStack into this stack.
    for(int j=0;j<stackTop;j++)
        list[j] = otherStack.list[j];
}//end copyStack

定义Constructor和Destructor函数:

//constructor
template<class Type >
stackType<Type>::stackType(int stackSize)
{
    if(stackSize <= 0)
    {
        cout<<"The size of the array to hold the stack"  <<"must be positive"<<endl;
        cout<<"Creating an array of size 100"<<endl;
        maxStackSize = 100;
    }
    else
        maxStackSize = stackSize;
    stackTop=0;
    list=new Type[maxStackSize];
    
    assert(list != NULL);
}//end constructor
template <class Type >
stackType<Type>::~stackType<Type>()
{
    delete [] list;//deallocate memory occupied
                    //by the array.
}

定义Copy Constructor

template<class Type >
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
    list = NULL;
    
    copyStack(otherStack);
}//end copy constructor

重载运算符(=)

template<class Type >
const stackType<Type>& stackType<Type>::operator=(const stackType<Type> & otherStack)
{
    if(this != &otherStack)//avoid self-copy
        copyStack(otherStack);
    
    return *this;
}//end operator =

 

2.用链表实现栈

因为数组的大小是固定的,所以用数组实现的栈的元素数量是固定的。当入栈元素数量超过数组大小,程序就会终止。所以我们用链表来克服这个问题。

下面定义一个链表栈的ADT:

template<class Type>
struct nodeType
{
    Type info;
    nodeType<Type> *link;
};
template<class Type>
class linkedStackType
{
public:
    const linkedStackType<Type>& operator=(const linkedStackType<Type>&);
    void initializeStack();
    bool isEmptyStack();
    bool isFullStack();
    void destroyStack();
    void push(const Type& newItem);
    Type top() const;
    void pop();
    
    linkedStackType();
    linkedStackType(const linkedStackType<Type>& otherStack);
    ~linkedStack();
private:
    nodeType<Type> *stackTop;
    
    void copyStack(const linkedStackType<Type>& otherStack);
};

说明:链表实现的栈在存储元素时,内存是动态分配的,因此栈不会满。只有当内存满了栈才会满,因此不需要用isFullStack来判断栈是否满。为了和数组实现的栈保持一致,链表实现的栈也包含了这个操作。

对链表实现的栈的基本操作:

默认构造函数(default constructor)

//default constructor
template <class Type>
linkedStackType<Type>::linkedStackType()
{
    stackTop = NULL;
}

销毁函数(destroy stack)

在数组里只需将stackTop设为0即可,但是在链表中,由于数据存储是动态的,所以需要把stackTop设置为NULL,然后释放栈元素占用的内存空间。

template<class Type>
void linkedStackType<Type>::destroyStack()
{
    nodeType<Type> *temp;
    while (stackTop!=NULL) {
        temp = stackTop;
        stackTop = stackTop->link;
        delete temp;
    }

初始化栈:(initializeStack)

初始化操作是将栈重新初始化为空的状态。

template<class Type>
void linkedStackType<Type>::initializeStack()
{
    destroyStack();
}

 

判断栈是否为空和判断栈是否满:

template<class Type>
bool linkedStackType<Type>::isEmptyStack() const
{
    return(stackTop==NULL);
}

template<class Type>
bool linkedStackType<Type>::isFullStack() const
{
    return false;
}

接下来是入栈操作push:

template<class Type>
void linkedStackType<Type>::push(const Type&newItem)
{
    nodeType<Type> *newNode;
    newNode = new nodeType<Type>;//create the new node
    assert(newNode !=NULL);
    
    newNode->info=newItem;
    newNode->link=stackTop;
    stackTop=newNode;
}

返回栈顶元素(Return the Top element )

template <class Type>
Type linkedStackType<Type>::top()const
{
    assert(stackTop != NULL);
    return(stackTop->info);
}//end top

出栈操作:pop

template <class Type>
void linkedStackType<Type>::pop()
{
    nodeType <Type> *temp;
    if (stackTop != NULL) {
        temp = stackTop;
        stackTop=stackTop->link;
        delete temp;
    }
    else
        cout<<"cannot remove from an empty stack"<<endl;
    
}

复制栈操作:

template<class Type>
void linkedStackType<Type>::copyStack(const linkedStackType<Type>& otherStack)
{
    nodeType<Type> *newNode,*current,*last;
    if(stackTop != NULL)
        destroyStack();
    if(otherStack.stackTop == NULL)
        stackTop=NULL;
    else
    {
        current = otherStack.stackTop;
        stackTop = new nodeType<Type>;
        assert(stackTop!=NULL);
        
        stackTop->info = current->info;
        stackTop->link=NULL;
        
        last = stackTop;
        current=current->link;
        
        while (current!=NULL) {
            newNode = new nodeType<Type>;
            assert(newNode != NULL);
            
            newNode->info = current->info;
            newNode->link = NULL;
            last->link = newNode;
            last = newNode;
            current = current->link;
        }//end while
    }//end else
}

构造函数和解析函数:

template <class Type>
linkedStackType<Type>::linkedStackType(const linkedStackType<Type>& otherStack)
{
    stackTop = NULL;
    copyStack(otherStack);
}

template<class Type>
linkedStackType<Type>::~linkedStackType()
{

    destroyStack();
}

重载赋值运算符(=)

template<class Type>
const linkedStackType<Type>& linkedStackType<Type>::operator =(const linkedStackType<Type>& otherStack)
{
    if(this != &otherStack)
        copyStack(otherStack);
    return *this;
}//end operator =

 

说明:

linkedStackType<int > stack;

这个语句声明了一个类型为linkedStackType的对象,并且这个stack里的元素类型为int型

比如:linkedStackType<stirng > stringStack;

这个语句声明了一个类型为linkedStackType的对象,并且这个stringStack里的元素类型为string型

 

栈及栈的C++实现

标签:

原文地址:http://www.cnblogs.com/weekend/p/4855714.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!