数据结构之栈（链式存储）——C++模板类实现

#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED
#include <bits/stdc++.h>

const int maxSize = 284;
template<class T>
class Stack {
public:
Stack() {std::cout << "Defalut Stack Constructing" << std::endl;}
~Stack() {std::cout << "Destructing Stack"<< std::endl;}
virtual void Push(const T& x) = 0;;
virtual bool Pop(T& x) = 0;
virtual bool GetTop(T& x)const = 0;
virtual bool IsEmpty()const = 0;
virtual bool IsFull()const = 0;
virtual int GetSize()const = 0;
};
#endif // STACK_H_INCLUDED

#ifndef LinkedListEDLIST_H_INCLUDED
#define LinkedListEDLIST_H_INCLUDED
#include <bits/stdc++.h>
using namespace std;

template<class T>
class LinkNode {
public:
LinkNode(LinkNode<T>* ptr = NULL) {cout << "Constructing a LinkNode by default way!" << endl; link = ptr;}
LinkNode(const T& item, LinkNode<T>* ptr = NULL) {cout << "Constructing a LinkNode by defined way!" << endl; data = item, link = ptr;}
~LinkNode() {cout << "Desctructing a LineNode!" << endl; delete link;}
T data;                    // Data Scope
LinkNode<T> *link;         // Point Scope, Point to next Node
};

// LinkedListList with head node
template <class T>
class LinkedList : public LinkNode<T> {
public:
LinkedList() {cout << "Constructing a LinkedListList by default way" << endl; first = new LinkNode<T>;}
LinkedList(const T&x);
LinkedList(LinkedList<T>& L);       // Deep copy constructor function
~LinkedList() {cout << "Destructing a LinkedListNode by default way" << endl; delete first;}
void makeEmpty();           // Delete all nodes in the LinkedList
int Length() const;         // Get the length of the SinlyLinkedList
LinkNode<T> *GetHead() const {return first;} // Return first
LinkNode<T> *Search(T x);   // x can only be a variable while T& x
LinkNode<T> *Locate(int i); // Get the i-th node's address
bool GetData(int i, T& x);        // Get the data in i-th node and let x = data
void SetData(int i, T& x);              // Make the data in i-th node equals x
bool Insert(int i, T& x);               // Insert a node in i-th with its' data be x
bool Remove(int i, T& x);               // Delete the i-th node and make x = node[i]->data
bool IsEmpty() const {return first->link == NULL ? true : false;}
bool IsFull() const {return false;}
void Sort();                            // Sort all datas in the LinkedList by non-decreasing way
void Input();                           // Input all elements
void Output();                          // Out all elements
LinkedList<T>& operator=(LinkedList<T>& L); // Overloading operator =
protected:
LinkNode<T> *first;     // Point to Head node
};

#endif // LinkedListEDLIST_H_INCLUDED

#ifndef LINKEDSTACK_H_INCLUDED
#define LINKEDSTACK_H_INCLUDED
#include "stack.h"
#include "LinkedList.h"
#include <bits/stdc++.h>

template<class T>
class LinkedStack : public Stack<T>{
public:
LinkedStack() : top(NULL) {cout << "Constructing LinkedStack" << endl;}
~LinkedStack() {MakeEmpty();cout << "Destructing LinkedStack" << endl;}
void Push(const T& x);
bool Pop(T& x);
bool GetTop(T& x)const;
bool IsEmpty()const {return top == NULL ? true : false;}
bool IsFull()const {return GetSize() == maxSize ? true : false;};
int GetSize()const;     // Declaration must be exactly same except virtual
void MakeEmpty();
//friend ostream& operator<<(ostream& os, LinkedStack<T>& s);
private:
LinkNode<T> *top;
};

template<class T>
void LinkedStack<T>::Push(const T& x) {
top = new LinkNode<T>(x, top);
assert(top != NULL);    // Create a new node and quit if top == NULL
}

template<class T>
bool LinkedStack<T>::Pop(T& x) {
if(IsEmpty() == true) {
cerr << "No more elements to pop" << endl;
return false;
}
LinkNode<T> *ptr = top;
top = top->link;
x = ptr->data;
delete ptr;
return true;
}

template<class T>
bool LinkedStack<T>::GetTop(T& x)const {
if(IsEmpty() == true) {
cerr << "No elements in the stack now" << endl;
return false;
}
x = top->data;
return true;
}

template<class T>
int LinkedStack<T>::GetSize()const {
int cnt = 0;
LinkNode<T> *cur = top;
while(cur != NULL) {
cnt++;
cur = cur->link;
}
return cnt;
}

template<class T>
void LinkedStack<T>::MakeEmpty() {
if(IsEmpty()) return ;
LinkNode<T> *cur = top;
while(top != NULL) {
top = top->link;
delete cur;
cur = top;
}
return ;
}
#endif // LINKEDSTACK_H_INCLUDED

#include <iostream>
#include "LinkedStack.h"
using namespace std;

int main()
{
LinkedStack<int> s;
s.Push(284);
s.Push(220);
cout << s.GetSize() << endl;
int topEle;
if(s.GetTop(topEle)) {
cout << topEle << endl;
}
s.Pop(topEle);
cout << topEle << endl;
cout << s.GetSize() << endl;
s.Push(7);
s.MakeEmpty();
cout << s.GetSize() << endl;
return 0;
}