链表栈类模板

链表节点

ListNode.h

 1 #include "stdafx.h"
 2 #include<iostream>
 3 using namespace std;
 4 template <typename Type>  class LinkStack;
 5 template <typename Type>
 6 // 链表节点
 7 class ListNode{
 8 private:
 9     friend class LinkStack<Type>;
10     ListNode():p_next(NULL){}
11     ListNode(Type item , ListNode<Type>*next=NULL):data(item),p_next(next){}
12     ~ListNode(){
13         p_next=NULL;
14     }
15 private:
16     Type data;  // 节点数据
17     ListNode<Type>*p_next;  //下一个节点
18 };

栈节点

LinkNode.h

 1 #include "ListNode.h"
 2 template <typename Type>
 3 class LinkStack{
 4 public:
 5     LinkStack():p_top(NULL){}
 6     ~LinkStack(){
 7         makeEmpty();
 8     }
 9 public:
10     void makeEmpty();   // 清空
11     bool push(Type item);  // 入栈
12     Type pop();  // 出栈
13     Type getTop();  // 获取栈首元素
14     void print();  // 打印
15     bool isEmpty(){   // 判空
16         return p_top==NULL;
17     }
18 private:
19     ListNode<Type>*p_top;
20 };
21 template<typename Type>
22 void LinkStack<Type>::makeEmpty(){
23     ListNode<Type>*pdel;
24     while(p_top!=NULL){
25         pdel = p_top;
26         p_top = p_top->p_next;
27         delete pdel;
28     }
29 }
30 template <typename Type>
31 bool LinkStack<Type>::push(Type item){
32     ListNode<Type>*temp = new ListNode<Type>(item);
33     if(temp==NULL){
34         cout << "filed push item:"<<item<<endl;
35         return false;
36     }
37     temp->p_next = p_top;
38     p_top = temp;
39     return true;
40 }
41 template <typename Type>
42 Type LinkStack<Type>::pop(){
43     if(isEmpty()){
44         cout << "stack is empty , can‘t pop the element"<<endl;
45         exit(0);
46     }
47     ListNode<Type>*temp = p_top;
48     p_top = p_top->p_next;
49     Type item = temp->data;
50     delete temp;
51     return item;
52 }
53
54 template <typename Type>
55 Type LinkStack<Type>::getTop(){
56     if(isEmpty()){
57         cout << "stack is empty"<<endl;
58         exit(0);
59     }
60     return p_top->data;
61 }
62 template <typename Type>
63 void LinkStack<Type>::print(){
64     if(isEmpty()){
65         cout << "stack is empty"<<endl;
66         exit(0);
67     }
68     ListNode<Type>*pmove = p_top;
69     cout << "stack";
70     while(pmove!=NULL){
71         cout << "->" << pmove->data;
72         pmove = pmove->p_next;
73     }
74     cout << endl << endl;
75 }

时间: 2024-10-09 20:51:56

链表栈类模板的相关文章

栈类模板

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

[数据结构]线性表之单链表的类模板实现

类的具体实现如下: ///////////////////////// #include"LinearList.h" #include <iostream> #include <cstdlib> using namespace std; template<class T> struct LinkNode //链表节点类 { T data; LinkNode<T>* link; LinkNode(LinkNode<T>* ptr

[数据结构]二叉树之二叉链表的类模板实现

该类模板实现了一个二叉树的模板类,采用二叉链表实现. 定义二叉树节点类,采用二叉链表实现. ///////////////////////// #include <iostream> #include <cstdlib> #include <stack> #include <deque> using namespace std; template<class T> struct BinTreeNode //二叉树节点类的定义,使用二叉链表 { T

类模板的用法

1.格式:template<模板参数表>  (参数可以直接定义默认值) class 类名 { ...}; 其成员函数可以在类外定义. eg: 1 template <class TNO,class TScore=int,int num=10> 2 class S 3 { 4 private: 5 TNO Sid[num]; 6 public: 7 int bel(TScore ascore); 8 void sort(); 9 }; 10 template <class TN

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

栈的抽象基类的实现:(不用抽象基类也是可以的,为了使用虚函数方便) #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

C++中的链表节点用模板类和用普通类来实现的区别

C++中的链表节点通常情况下类型都是一致的.因此我们可以用模板来实现. #include <iostream> using namespace std; template<typename Type>//定义一个模板类必须有的声明 class LinkNode //表示链表节点的类 { public: LinkNode() :m_pnext(nullptr){}//构造函数,在函数体内实现的相当于默认在前面加了inline关键字修饰 LinkNode(Type item, Link

C++学习笔记47:链表的概念与结点类模板

学堂在线学习笔记 链表的概念与结点类模板 顺序访问的线性群体--链表类 链表是一种动态数据结构,可以用来表示顺序访问的线性群体: 链表是由系列结点组成,结点可以在运行时动态生成: 每一个结点包括数据域和指向链表中下一个结点的指针(即下一个结点的地址).如链表中每个结点中只有一个指向后继结点的指针,则该链表称为单链表: 单链表的结点类模板 template <class T> void Node<T>::insertAfter(Node<T> *p) { //p结点指针域

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

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

栈的数组实现形式,采用动态分配数组,不够时可以调整栈的大小. 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