[数据结构]栈之链式栈的类模板实现

栈的抽象基类的实现:(不用抽象基类也是可以的,为了使用虚函数方便)

#ifndef STACK
#define STACK
//栈的抽象基类

template<class T>
class Stack
{
public:
    Stack(){}
    ~Stack(){}

    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

链式栈模板类的具体实现:(覆盖了抽象基类中的所有纯虚函数,并增加了一些成员)

/////////////////////////
#include"Stack.h"
#include <iostream>
#include <cstdlib>
#include <cassert>
using namespace std;

template<class T>
struct LinkNode //链表节点类
{
    T data;
    LinkNode<T>* link;  

    LinkNode(LinkNode<T>* ptr=NULL):link(ptr){}
    LinkNode(const T& item,LinkNode<T>* ptr=NULL):data(item),link(ptr){}
};

template<class T>
class LinkedStack:public Stack<T>
{
public:
    LinkedStack():top(NULL){}
    LinkedStack(const LinkedStack<T>& rhs);
    LinkedStack<T>& operator=(const LinkedStack<T>& rhs);
    ~LinkedStack(){makeEmpty();}

    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 false;}//无意义,不可能满
    int getSize()const;

    void makeEmpty();
    friend ostream& operator<< <T>(ostream& out,LinkedStack<T>& rhs);//加<T>

private:
    LinkNode<T>* top;
};

template<class T>
void LinkedStack<T>::makeEmpty()
{
    LinkNode<T>* p=NULL;
    while(top!=NULL){
        p=top;
        top=top->link;
        delete p;
    }
}

template<class T>
void LinkedStack<T>::Push(const T& x)
{
    top=new LinkNode<T>(x,top);
    assert(top!=NULL);
}

template<class T>
bool LinkedStack<T>::Pop(T& x)
{
    if(IsEmpty()) return false;
    LinkNode<T>* p=top;
    top=top->link;
    x=p->data;
    delete p;
    return true;
}

template<class T>
bool LinkedStack<T>::getTop(T& x)const
{
     if(IsEmpty()) return false;
     x=top->data;
     return true;
}

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

template<class T>
ostream& operator<<(ostream& out,LinkedStack<T>& rhs)//不加<T>
{
    out<<"elements nums: "<<rhs.getSize()<<endl;
    LinkNode<T>* p=rhs.top;
    out<<"elements is: ";
    while(p!=NULL){
        out<<p->data<<" ";
        p=p->link;
    }
    out<<endl;
    return out;
}

template<class T>
LinkedStack<T>::LinkedStack(const LinkedStack<T>& rhs)
{

    LinkNode<T>* src=rhs.top;
    LinkNode<T>* dest=NULL;
    LinkNode<T>* newNode=NULL;
    while(src!=NULL){
        newNode=new LinkNode<T>(src->data);
        if(dest==NULL){
            dest=newNode;
            top=dest;
        }else{
            dest->link=newNode;
            dest=newNode;
        }
        src=src->link;
    }
}

template<class T>
LinkedStack<T>& LinkedStack<T>::operator=(const LinkedStack<T>& rhs)//copy赋值本质为:析构+copy构造函数
{
    if(top!=NULL)//先析构,释放资源
        makeEmpty();

    LinkNode<T>* src=rhs.top;//copy构造
    LinkNode<T>* dest=NULL;
    LinkNode<T>* newNode=NULL;
    while(src!=NULL){
        newNode=new LinkNode<T>(src->data);
        if(dest==NULL){
            dest=newNode;
            top=dest;
        }else{
            dest->link=newNode;
            dest=newNode;
        }
        src=src->link;
    }

    return *this;
}

类的测试代码如下:

int main(int argc, char* argv[])
{

    LinkedStack<int> s;
    int a=1,b=2,c=3,d=4,e=5;
    s.Push(a);
    s.Push(b);
    s.Push(c);
    s.Push(d);
    s.Push(e);
    cout<<s;
    s.Pop(e);
    cout<<s;

    cout<<std::boolalpha;//控制显式的bool值的显式
    cout<<"IsEmpty(): "<<s.IsEmpty()<<endl;
    cout<<"IsFull(): "<<s.IsFull()<<endl;
    cout<<std::noboolalpha;

    s.getTop(e);
    cout<<"getTop(): "<<e<<endl;

    s.makeEmpty();
    cout<<s;

    s.Push(a);
    s.Push(b);
    s.Push(c);
    cout<<s;
    LinkedStack<int> s1(s),s2;
    cout<<s1;
    s2=s1;
    cout<<s2;

    system("pause");
    return 0;
}

测试结果如下:

elements nums: 5
elements is: 5 4 3 2 1
elements nums: 4
elements is: 4 3 2 1
IsEmpty(): false
IsFull(): false
getTop(): 4
elements nums: 0
elements is:
elements nums: 3
elements is: 3 2 1
elements nums: 3
elements is: 3 2 1
elements nums: 3
elements is: 3 2 1
请按任意键继续. . .

注意事项:

1.在模板类的友元函数的实现与声明时:声明的时间要加额外的参数<T>,在实现的时间时不加的。

2. 实现中采用的是无附加头结点的单链表,所以要注意拷贝时,链表要区分是否是空链表或者是第一次建立链表的情况。

3.链式栈的栈顶在链表的头部,新节点的插入和删除都是在栈顶进行的,是对栈顶元素的操作。

4.链表实现的栈是不可能满的,所以总是返回false

5.采用cout<<std::boolaapha与cout<<std::noboolaapha可显式的控制布尔值的显式方式。

时间: 2024-11-05 06:04:46

[数据结构]栈之链式栈的类模板实现的相关文章

C++提高1 【泛型编程】函数模板 类模板

[本文谢绝转载] [泛型编程] 函数模板 为什么会有函数模板 现象: 函数的业务逻辑一样 函数的参数类型不一样 [最常用]函数模板  显式的调用 [不常用]类型推导 多个参数,参数定义了必须要用 函数模板,实现int类型数组,char字符串排序: 函数模板 与 普通函数的本质区别 函数模板 和 普通函数在一起 的调用型研究: C++是如何支持函数模板机制的? 函数模板机制结论 类模板 类模板的定义 类模板做函数的参数 类模板的派生成普通类 模板类的派生成模板类 复数类,所有函数都写在类的内部,运

[数据结构]栈之顺序栈的类模板实现

栈的数组实现形式,采用动态分配数组,不够时可以调整栈的大小. Stack.h文件:主要定义栈的抽象基类,提供公共的接口函数. #ifndef STACK #define STACK //栈的抽象基类 template<class T> class Stack { public: Stack(){} ~Stack(){} virtual void Push(const T& x)=0; virtual bool Pop(T& x)=0; virtual bool getTop(T

栈类模板

栈是只能从一端访问的线性群体,可以访问的这一端称栈顶,另一端称栈底.栈是一种后进先出的数据结构. 栈示意图 栈的应用举例——表达式处理 栈的基本状态 栈空 栈满 一般状态 栈空 栈中没有元素(以数组容纳的栈为例) 栈满 栈中元素个数达到上限(以数组容纳的栈为例) 一般状态 栈中有元素,但未达到栈满状态(以数组容纳的栈为例) 栈的基本操作 初始化 入栈 出栈 清空栈 访问栈顶元素 检测栈的状态(满.空) 例9-8 栈类模板 //Stack.h #ifndef STACK_H #define STA

c++数组类模板(栈内存)

#ifndef _ARRAY_H_ #define _ARRAY_H_ /* * 实现一个数组类模板,在栈上 * why * 2016/9/5 */ template < typename T, int N > class Array { private: T m_array[N]; public: int length(); //获取数组长度 bool set_array(T value, int index);  //设置数组元素内容 bool get_array(T& value

[数据结构]最小堆的类模板实现

堆数据结构是一种数组对象,它可以被视为一科完全二叉树结构. 它的特点是父节点的值大于(小于)两个子节点的值(分别称为最大堆和最小堆).它常用于管理算法执行过程中的信息,应用场景包括堆排序,优先队列等. 1.根结点若有子树,则子树一定也是堆. 2.根结点一定大于(或小于)子结点. 因为要求堆必须是完全二叉树,所以可以用线性的数据结构,比如数组,来实现堆. 利用数组实现,则对于长为N的堆中的元素从0到N-1排列,有: i的父结点:Parent(i)=(i+1)/2-1 i的左叶子:Left(i)=(

数据结构——栈的类定义和实现

#include<iostream> #include<iomanip> #include<string> #include<stdlib.h> //使用库函数exit() using namespace std; template<class Type> class Stack{ private: Type*data; //栈元素数组 int maxSize; //最大栈顶值 int top; //栈顶 public: void setStac

数据结构-链表逆置(c++模板类实现)

链表结点类模板定义: 1 template <class T> 2 class SingleList; 3 template <class T> 4 class Node 5 { 6 private: 7 T element; 8 Node<T> *link; 9 friend class SingleList<T>; 10 }; 链表类末班定义: 1 template <class T> 2 class SingleList 3 { 4 pub

【C/C++学院】0825-类模板/final_override/类模板与普通类的派生类模板虚函数抽象模板类/类模板友元/位运算算法以及类声明/Rtti 实时类型检测/高级new创建/类以及函数包装器

类模板 类模板多个类型默认类型简单数组模板 #pragma once template <class T=int>//类模板可以有一个默认的值 class myArray { public: myArray(); ~myArray(); }; #include "myArray.h" template <class T=int>//每一个函数都需要加上一个默认的值 myArray<T>::myArray() //类模板成员函数在外部,需要加载类型初始

基本数据结构-栈的实现及其运用

概述:数据结构是用来实现动态集合的方式.动态集合有两个要素,一是动态集合中的元素,二是动态集合上的操作如search(s,k):其中s为给定的集合,k为所要查询的关键字.Insert(s,k),delete,maximun,minimum,successor,predecessor等. 这里介绍几种简单的数据结构:栈,队列,链表,有根树. 一.栈 栈有一定限制的表,元素的插入和删除只能在表头进行,栈虽然缺少鲁棒性,但是更有效,并且很容易应用,栈后进先出.基本的操作包括进栈PUSH,出栈pop,判