【Weiss】【第03章】栈例程

写栈比队列更简单一些，毕竟只有一个数据出入口。

之前用C在程序里模拟栈代替递归的时候，直接搞个数组来实现都是非常轻松愉快的事情。

不多说，放代码。

测试代码

#include <iostream>
#include "stack.h"
using namespace std;
using namespace stack;
template class Stack<int>;
int main(void)
{
    Stack<int> number;

    //测试入栈
    cout << "/*additem()*/" << endl;
    number.push(2);
    number.push(3);
    number.push(5);
    number.push(7);
    number.push(11);
    number.traverse();
    cout << "
/*end*/

" << flush;

    //测试获取长度
    cout << "/*length()*/" << endl;
    cout << number.size() << endl;
    cout << "/*end*/

" << flush;

    //测试获得头元素
    cout << "/*getfirst()*/" << endl;
    cout << number.getfirst() << endl;
    cout << "/*end*/

" << flush;

    //测试出栈
    cout << "/*remove()*/" << endl;
    number.pop();
    number.pop();
    number.traverse();
    cout << "
/*end*/

" << flush;

    //测试清空，并测试从空表中出栈
    cout << "/*clear(),remove()*/" << endl;
    number.clear();
    number.pop();
    cout << "/*end*/

" << flush;

    system("pause");
}

主体代码

#ifndef STACK
#define STACK
#include <iostream>
using namespace std;

namespace stack
{

//节点模板
template <typename T> struct Node
{
    Node<T>() : next(nullptr){}
    Node<T>(const T &item, Node<T>* ptr = nullptr) : data(item), next(ptr){}
    T data;
    Node<T>* next;
};
//头节点及主体操作
template <typename T> class Stack
{
//构造函数
public:
    Stack<T>() : length(0), front(nullptr){}
//接口
public:
    //返回长度
    unsigned int size()const{ return length; }
    //返回头指针
    Node<T>* begin()const{ return front; }
    //判断是否为空
    bool empty()const{ return length == 0; }
    //获得头元素
    T getfirst()const{ return front->data; }
    //#查找元素所在地址
    Node<T>* find(const T &item)const;
    //#入栈
    bool push(const T &item);
    //#出栈
    bool pop();
    //#遍历并输栈元素
    void traverse()const;
    //#清空栈
    void clear();

//辅助函数
private:
    //#查找元素前驱
    Node<T>* find_prev(const T& item)const;
//数据
private:
    unsigned int length;
    Node<T>* front;
};

//如果元素为头元素或元素不存在则返回nullptr，否则返回前驱
template <typename T> Node<T>* Stack<T>::find_prev(const T& item)const
{
    if (length == 0)
        return nullptr;
    if (front->data == item)
        return nullptr;
    for (Node<T>* iter = front; iter->next != nullptr; iter = iter->next)
    {
        if (iter->next->data == item)
            return iter;
    }
    return nullptr;
}
//调用find_prev，如果元素存在则返回地址，不存在则返回nullptr
template <typename T> Node<T>* Stack<T>::find(const T &item)const
{
    Node<T>* iter = find_prev(item);
    if (length == 0)
        return nullptr;
    if (front->data == item)
        return front;
    return iter->next;
}
template <typename T> bool Stack<T>::push(const T &item)
{
    Node<T>* pnew = new Node<T>(item);
    pnew->next = front;
    front = pnew;
    ++length;
    return true;
}
template <typename T> bool Stack<T>::pop()
{
    if (length == 0)                    
    {
        cout << "No data!" << endl;
        return false;
    }
    Node<T>* save = front;
    front = front->next;
    delete save;
    --length;
    return true;
}
template <typename T> void Stack<T>::traverse()const
{
    if (length != 0)
    {
        for (Node<T>* iter = front; iter != nullptr; iter = iter->next)
            cout << iter->data << ends;
    }
}
template <typename T> void Stack<T>::clear()
{
    Node<T>* iter;
    while (front != nullptr)
    {
        iter = front;
        front = front->next;
        delete iter;
    }
    front = nullptr;
    length = 0;
}
}
#endif