C++实现堆栈

用类模板和双向链表实现的

加油！

要找到好工作！

 

这是stack.h

#ifndef STACK_H
#define STACK_H

/***************************************
*********双链表栈 C++模块的实现**********
***************************************/
// ref: http://blog.chinaunix.net/uid-21206300-id-3164886.html

#include <iostream>
using namespace std;

namespace MY_STACK
{
    //====================================================//
    // Node:
    template <typename T>
    class Node
    {
    public:
        Node()
        {
            this->element = (T)0;//0; // TODO: 等于0？如果是指针或对象呢？
            this->next = NULL;
            this->prev = NULL;
        }
        ~Node()
        {
            this->element = (T)0;//0;
            this->next = NULL;
            this->prev = NULL;
        }
        T &getElement()
        {
            return this->element;
        }

        //重载"<<"操作符，以便对栈节点输出，注意以friend重载“<<”操作符要加上"<>"
        friend ostream &operator << <>(ostream &ost, Node<T> &src)
        {
            ost << src.getElement();
            return ost;
        }

        Node<T> *next;
        Node<T> *prev;
        template <typename T> friend class Stack;

    protected:
        T element;
        
    };

    //=====================================================//
    // Stack:
    template <typename T>
    class Stack
    {
    public:
        Stack();
        ~Stack();

        bool push(const T &element);
        T pop();

        bool isEmpty();

        bool clear();

        int size();

        friend ostream &operator << <>(ostream &ost, Stack<T> &src);

    protected:
        Node<T> *createNode(const T &element);

    protected:
        Node<T> *head;// 链表头为head
        Node<T> *top; // 链表尾为top

    private:
        int count;
    };

    //=====================================================//
    // Stack realize:
    template <typename T>
    Stack<T>::Stack()
    {
        T node = T();
        // 创建一个带有头节点的双链栈，这个节点不存入任何数据
        this->head = this->createNode(node);
        this->top = this->head;
        this->count = 0;
    }

    template <typename T>
    Stack<T>::~Stack()
    {
        this->clear();
        delete this->head;
        this->head = NULL;
        this->top = NULL;
    }

    template <typename T>
    Node<T> *Stack<T>::createNode(const T &element)
    {
        Node<T> *p = new Node<T>;
        if (p)
        {
            p->element = element;
            p->next = NULL;
            p->prev = NULL;
        }
        return p;
    }

    template <typename T>
    bool Stack<T>::push(const T &element)
    {
        Node<T> *p = this->createNode(element);
        if (NULL == this->head->next)
        {
            this->head->next = p;
            p->prev = this->head;
        }
        else
        {
            this->top->next = p;
            p->prev = this->top;
        }
        this->count++;
        // 把链表尾当作top
        this->top = p;

        return true;
    }

    template <typename T>
    T Stack<T>::pop()
    {
        // if is not empty
        if (!isEmpty())
        {
            Node<T> *p = this->top;
            this->top = this->top->prev;
            //this->top->next = NULL; // TODO: test

            T elem = p->element; // 要注意浅拷贝！
            //T elem = p->getElement(); 
            
            p->next = p->prev = NULL;
            delete p;
            p = NULL;

            this->count--;

            return elem;
        }
        return (T)0;
    }

    template <typename T>
    bool Stack<T>::isEmpty()
    {
        return (this->head == this->top);
    }

    template <typename T>
    bool Stack<T>::clear()
    {
        Node<T> *p = this->top;
        while ((p = this->top) != this->head)
        {
            this->top = p->prev;
            //this->top->next = NULL; // TODO: test
            p->next = p->prev = NULL;
            delete p;
            p = NULL;
        }
        // 或者是：
        /*while (!isEmpty())
            this->pop();*/
        this->count = 0;

        return true;
    }

    template <typename T>
    int Stack<T>::size()
    {
        return this->count;
    }

    template <typename T>
    ostream &operator << <>(ostream &ost, Stack<T> &src)
    {
        Node<T> *p = src.top;
        while (p != src.head)
        {
            ost << *p << " ";
            p = p->prev;
        }
        return ost;
    }
}


#endif

 

这是main：

#include "stack.h"

using namespace MY_STACK;

int main() {
    Stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.push(4);
    s.push(5);

    cout << s << endl;
    cout << s.size() << endl;

    s.pop();

    cout << s << endl;
    cout << s.size() << endl;

    s.pop();
    s.pop();
    s.pop();
    s.pop();
    s.pop();

    cout << s << endl;
    cout << s.size() << endl;

    //============================//
    Stack<char> s1;
    s1.push('a');
    s1.push('b');
    s1.push('c');
    cout << s1 << endl;
    cout << s1.size() << endl;

    s1.clear();
    cout << s1 << endl;
    cout << s1.size() << endl;

    return 0;
}

 

本人的环境：vs2013