数据结构探险—栈篇

头文件

#pragma once
#ifndef _STACK_H
#define _STACK_H// !_STACK_H

class Stack
{
public:
    Stack(int size);
    virtual ~Stack();
    bool StackEmpty() const;
    bool StackFull() const;
    void ClearStack();
    int  StackLength() const;
    bool push(char element);
    bool pop(char &element);
    void StackTraverse(bool isFromButtom);
private:
    char *m_pStack;
    int  m_iSize;
    int  m_iTop;
};

#endif

源文件

#include "stack.h"
#include <iostream>

using namespace std;


Stack::Stack(int size)
{
    m_iSize = size;
    m_pStack = new char[size];
    m_iTop = 0;
}


Stack::~Stack()
{
    delete []m_pStack;
    m_pStack = 0;
}

bool Stack::StackEmpty() const
{
    return m_iTop == 0 ? true : false;
}

bool Stack::StackFull() const
{
    return m_iTop == m_iSize ? true : false;
}

void Stack::ClearStack()
{
    m_iTop = 0;
}
int  Stack::StackLength() const
{
    return m_iTop;
}

bool Stack::push(char element)
{
    if (StackFull()) return false;
    m_pStack[m_iTop] = element;
    m_iTop++;
    m_iSize++;
    return true;
}
bool Stack::pop(char &element)
{
    if (StackEmpty()) return false;
    m_iTop--;
    element = m_pStack[m_iTop];
    m_iSize--;
    return true;
}
void Stack::StackTraverse(bool isFromButtom)
{
    if (isFromButtom)
    {
        for (int i = 0; i < m_iTop; i++)
        {
            cout << m_pStack[i] << ",";
        }
    }
    else
    {
        for (int i = m_iTop - 1; i >= 0; i--)
        {
            cout << m_pStack[i] << ",";
        }
    }
}

模板

#pragma once
#ifndef _STACK_H
#define _STACK_H// !_STACK_H
#include <iostream>
template <typename T>
class Stack
{
public:
    Stack(int size);
    virtual ~Stack();
    bool StackEmpty() const;
    bool StackFull() const;
    void ClearStack();
    int  StackLength() const;
    bool push(T element);
    bool pop(T &element);
    void StackTraverse(bool isFromButtom);
private:
    T *m_pStack;
    int  m_iSize;
    int  m_iTop;
};

template <typename T>
Stack<T>::Stack(int size)
{
    m_iSize = size;
    m_pStack = new T[size];
    m_iTop = 0;
}

template <typename T>
Stack<T>::~Stack()
{
    delete[]m_pStack;
    m_pStack = 0;
}
template <typename T>
bool Stack<T>::StackEmpty() const
{
    return m_iTop == 0 ? true : false;
}
template <typename T>
bool Stack<T>::StackFull() const
{
    return m_iTop == m_iSize ? true : false;
}
template <typename T>
void Stack<T>::ClearStack()
{
    m_iTop = 0;
}
template <typename T>
int  Stack<T>::StackLength() const
{
    return m_iTop;
}
template <typename T>
bool Stack<T>::push(T element)
{
    if (StackFull()) return false;
    m_pStack[m_iTop] = element;
    m_iTop++;
    m_iSize++;
    return true;
}
template <typename T>
bool Stack<T>::pop(T &element)
{
    if (StackEmpty()) return false;
    m_iTop--;
    element = m_pStack[m_iTop];
    m_iSize--;
    return true;
}
template <typename T>
void Stack<T>::StackTraverse(bool isFromButtom)
{
    if (isFromButtom)
    {
        for (int i = 0; i < m_iTop; i++)
        {
            cout << m_pStack[i];
        }
    }
    else
    {
        for (int i = m_iTop - 1; i >= 0; i--)
        {
            cout << m_pStack[i];
        }
    }
}
#endif

主函数

#include <iostream>
#include <cstdlib>
#include "stack.h"
using namespace std;
int main(void)
{
    Stack<char> *p = new Stack<char>(4);
    p->push('D');
    p->push('S');
    p->push('L');
    p->StackTraverse(true);
    delete p;
    p = NULL;//Look Out！
    system("pause");
    return 0;
}