数据结构之线性结构---栈 链式储存

一、链式储存的特点：

栈的链式储存是通过链表的方式进行储存，链式储存的优点在于
1、比顺序存储结构的存储密度小 每个节点都由数据域和指针域组成，所以相同空间内假设全存满的话顺序比链式存储更多。

2、逻辑上相邻的节点物理上不必相邻。

3、插入、删除灵活 不必移动节点，只要改变节点中的指针。

二、栈的链式储存实现

AL_Node.h

#ifndef AL_NODE_INCLUDE
#define AL_NODE_INCLUDE

#include <windows.h>
template<typename T> class AL_StackList;

template<typename T>
class AL_Node
{
    //声明一个朋友类，使这个朋友类可以访问这个类的私有元素
    friend class AL_StackList<T>;
public:
    ~AL_Node();
private:
    AL_Node();
    AL_Node(const T &tTemplate);
    AL_Node(const AL_Node<T>& cAL_Node);
    T m_data;//存储数据
    AL_Node *m_pPre;//记录链表的头结点地址
    AL_Node *m_pNext; //指向下一个节点地址
};

template<typename T>
AL_Node<T>::AL_Node() :m_pPre(NULL), m_pNext(NULL)
{


}

template<typename T>
AL_Node<T>::AL_Node(const T &tTemplate) :m_pPre(NULL), m_pNext(NULL), m_data(tTemplate)
{

}

template<typename T>
AL_Node<T>::~AL_Node()
{
    m_pPre = NULL;
    m_pNext = NULL;
}

#endif // AL_NODE

AL_StackList.h

#ifndef AL_STACKLIST_INCLUDE
#define AL_STACKLIST_INCLUDE

#include "AL_Node.h"


template<typename T>
class AL_StackList
{
public:
    AL_StackList();
    ~AL_StackList();
    //判断栈中是否为空
    bool IsEmpty()const;
    //将元素弹出栈
    bool Pop(T&tTypeOut);
    //将元素压入栈
    bool Push(T&tTemplate);
    //获取栈中储存的元个数
    DWORD Size()const;
    //获取栈顶的元素
    bool Top(T&tTypeOut)const;
    //清空栈中的所有元素
    void Clear();
private:
    AL_Node<T> *m_pHeader;
    DWORD m_dwSize;
};


#endif

template<typename T>
inline AL_StackList<T>::AL_StackList():m_pHeader(NULL),m_dwSize(0x00)
{
    m_pHeader = new AL_Node<T>();
}

template<typename T>
inline AL_StackList<T>::~AL_StackList()
{
    if (m_pHeader!=NULL)
    {
        delete m_pHeader;
        m_pHeader = NULL;
    }
}

template<typename T>
inline bool AL_StackList<T>::IsEmpty() const
{

    return (m_pHeader->m_pNext==NULL)?true:false;
}

template<typename T>
inline bool AL_StackList<T>::Pop(T & tTypeOut)
{
    if (IsEmpty()==true)
    {
        return false;
    }
    AL_Node<DWORD> *pPop = m_pHeader->m_pNext;
    tTypeOut = pPop->m_data;
    m_pHeader->m_pNext = pPop->m_pNext;
    delete pPop;
    pPop = NULL;
    m_dwSize--;
    return true;
}

template<typename T>
inline bool AL_StackList<T>::Push(T & tTemplate)
{
    AL_Node<T> *pPush = new AL_Node<T>();
   if (pPush==NULL)
   {
       return false;
   }
    pPush->m_data = tTemplate;
    pPush->m_pNext = m_pHeader->m_pNext;
    m_pHeader->m_pNext = pPush;
    m_dwSize++;
    return true;
}

template<typename T>
inline DWORD AL_StackList<T>::Size() const
{
    return m_dwSize;
}

template<typename T>
inline bool AL_StackList<T>::Top(T & tTypeOut) const
{
    if (IsEmpty()==true)
    {
        return false;
    }
    AL_Node<T> *pTop = m_pHeader->m_pNext;
    tTypeOut = pTop->m_data;

    return true;
}

template<typename T>
inline void AL_StackList<T>::Clear()
{
    AL_Node<T> *pDelete = NULL;
    while (m_pHeader->m_pNext!=NULL)
    {
        pDelete = m_pHeader->m_pNext;
        m_pHeader->m_pNext = pDelete->m_pNext;
        delete pDelete;
        pDelete = NULL;
    }
    m_dwSize = 0x00;
}

测试代码：

void StackListTest()
{
    AL_StackList<DWORD> cStackList;
    bool bEmpty = cStackList.IsEmpty();
    std::cout << bEmpty << std::endl;

    DWORD dwPop = 0x00;
    cStackList.Pop(dwPop);
    std::cout << dwPop << std::endl;

    DWORD dwTop=0x00;
    cStackList.Top(dwTop);
    std::cout << dwTop << std::endl;

    for (DWORD dwCont=1;dwCont<16;dwCont++)
    {
        DWORD s = 16 - dwCont;
        cStackList.Push(s);
        cStackList.Top(dwTop);
        std::cout << dwTop << std::endl;
    }

}

int main(int argc, char *argv[])
{
    StackListTest();
    getchar();
    return 0;
    }

运行结果：