C++实现链表模板、链表栈模板、数组栈模板

最新推荐文章于 2020-09-14 23:14:19 发布
最新推荐文章于 2020-09-14 23:14:19 发布
阅读量312 收藏 2
点赞数
分类专栏： C++ 数据结构 文章标签： 栈 链表 数组 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuaijg/article/details/90740569
版权
本文介绍了如何使用C++实现链表模板和链表栈模板，以及数组栈模板。通过头文件和源文件的详细讲解，展示了从基础的链表结构到栈数据结构的模板化实现过程，并对比了数组栈和链表栈的特性。
摘要由CSDN通过智能技术生成

数组栈来自于上一篇文章（头文件1、2，源文件1、2）
1、实现链表模板
2、创建链表栈模板
3、比较数组栈和链表栈

1. 头文件1

Array.h

#pragma once
template<typename T>
class Array
{
public:
	Array(int capacity);
	Array();
	T& operator[](int i);

	int GetSize();
	int GetCapacity();
	bool IsEmpty();

	void add(int index, T e);


	void AddLast(T e);
	void AddFirst(T e);
	void toString();
	int get(T index);
	void set(int index, T e);
	bool contains(T e);
	int find(T e);
	//删除并返回
	T remove(int index);
	T removeFirst();
	T removeLast();
	void removeelement(T e);
	T GetLast();
	T GetFirst();
	~Array();

private:
	void reSize(int newcapacity);
protected:

private:
	int size;
	T *data;
	int capacity;
};

2. 头文件2

ArrayStack.h

#pragma once
#include "Array.h"
#include "StackInterface.h"
template<typename T>
class ArrayStack:public Stack<T>
{
public:
	ArrayStack(int capacity);
	ArrayStack();
	int GetSize();
	bool IsEmpty();
	int getcapacity();
	void Push(T e);
	T pop();
	T peek();
	void toString();
	~ArrayStack();
private:
	Array<T> array;
};

3. 头文件3

LinkListStack.h

#pragma once
#include "StackInterface.h"
#include "LinkList.hpp"
template<typename T>
class LinkListStack:public Stack<T>
{
public:
	LinkListStack();
	int GetSize();
	bool IsEmpty();
	void Push(T e);
	T pop();
	T peek();
	void toString();
	~LinkListStack();

private:
	LinkList<T> list;
};

4. 头文件4

StackInterface.h

#pragma once
template<typename T>
class Stack {
public:
	virtual int GetSize() = 0;
	virtual bool IsEmpty() = 0;
	virtual void Push(T e) = 0;
	virtual T pop() = 0;
	virtual T peek() = 0;
};

5. 源文件1

Array.hpp

#pragma once
#include "Array.h"
#include <string>
#include <iostream>
using namespace std;
template<typename T>
Array<T>::Array(int capacity) {
	cout << "Array(int)" << endl;
	data = new T[capacity];
	size = 0;
	this->capacity = capacity;
}
template<typename T>
Array<T>::Array() {
	cout << "Array()" << endl;
	this->capacity = 5;
	data = new T[capacity];
	size = 0;
}
template<typename T>
T& Array<T>::operator[](int i) {
	return data[i];
}
template<typename T>
int Array<T>::GetSize() {
	return size;
}
template<typename T>
int Array<T>::GetCapacity() {
	return capacity;
}
template<typename T>
bool  Array<T>::IsEmpty() {
	return size == 0;
}
template<typename T>
void Array<T>::add(int index, T e) {
	if (size == capacity) {
/*
		cout << "array is full,resize?(YorN)" << endl;
		char tmp;
		cin >> tmp;
		if (tmp == 'Y')
		{
			reSize(this->capacity * 2);
		}
		else
		{
			throw "array is full";
		}*/
		reSize(this->capacity * 2);
	}
	if (index<0 || index>size) {
		throw "add::index<0 || index>size";
	}
	for (int i = size - 1; i >= index; i--) {
		data[i + 1] = data[i];
	}
	data[index] = e;
	size++;
}

template<typename T>
void Array<T>::AddLast(T e) {
	add(size, e);
}
template<typename T>
void Array<T>::AddFirst(T e) {
	add(0, e);
}
template<typename T>
void Array<T>::toString() {
	cout << "Array Size =" << size << "，Capacity=" << capacity << endl;
	for (int i = 0; i < size; i++) {
		cout << *(data + i);
		if (i != size - 1) {
			cout << ",";
		}
	}
}
template<typename T>
int Array<T>::get(T index) {
	if (index<0 || index>size) {
		throw "get::index<0 || index>size";
	}
	return data[index];
}
template<typename T>
void Array<T>::set(int index, T e) {
	if (index<0 || index>size) {
		throw "set::index<0 || index>size";
	}
	data[index] = e;
}
template<typename T>
bool Array<T>::contains(T e) {
	for (int i = 0; i < size; i++) {
		if (data[i] == e) {
			return true;
		}
	}
	return false;
}
template<typename T>
int Array<T>::find(T e) {
	for (int i = 0; i < size; i++) {
		if (data[i] == e) {
			return i;
		}
	}
	return -1;
}
//删除并返回
template<typename T>
T Array<T>::remove(int index) {
	if (index<0 || index>size) {
		throw "remove::index<0 || index>size";
	}
	int ret = data[index];
	for (int i = index + 1; i < size; i++) {
		data[i - 1] = data[i];
	}
	size--;
	data[size] = NULL;
	if (size == capacity / 4 && this->capacity / 2 != 0)
	{
		reSize(this->capacity / 2);
	}
	return ret;
}
template<typename T>
T Array<T>::removeFirst() {
	return remove(0);
}
template<typename T>
T Array<T>::removeLast() {
	return remove(size - 1);
}

template<typename T>
void Array<T>::removeelement(T e) {
	int index = find(e);
	if (index != -1) {
		remove(index);
	}
}
template<typename T>
T Array<T>::GetLast() {
	return get(size - 1);
};
template<typename T>
T Array<T>::GetFirst() {
	return get(0);
};

template<typename T>
Array<T>::~Array() {
	if (data != NULL) {
       delete[] data;
	   data = NULL;
	}
	cout << "~Array()" << endl;
	//system("pause");
}
template<typename T>
void Array<T>::reSize(int newcapacity) {
	/*
	T* tmp = new T[this->capacity];
	for (int i = 0; i < size; i++) {
	tmp[i] = data[i];
	}
	this->capacity = newcapacity;
	data= new T[newcapacity];
	for (int i = 0; i < size; i++) {
	data[i] = tmp[i];
	}
	delete[] tmp;*/
	T* newdata = new T[newcapacity];
	for (int i = 0; i < size; i++) {
		newdata[i] = data[i];
	}
	data = newdata;
	this->capacity = newcapacity;
}

6. 源文件2

ArrayStack.hpp

#pragma once
#include "ArrayStack.h"
#include "Array.hpp"


template<typename T>
ArrayStack<T>::ArrayStack(int capacity){
	cout << "ArrayStack(int)" << endl;
	Array<T> array =Array<T>(capacity);
}
template<typename T>
ArrayStack<T>::ArrayStack() {
	cout << "ArrayStack()" << endl;
}
template<typename T>
int ArrayStack<T>::GetSize() {
	return array.GetSize();
}
template<typename T>
bool ArrayStack<T>::IsEmpty() {
	return array.IsEmpty();
}
template<typename T>
int ArrayStack<T>::getcapacity() {
	return array.GetCapacity();
}
template<typename T>
void ArrayStack<T>::Push(T e) {
	array.AddLast(e);
}
template<typename T>
T ArrayStack<T>::pop() {
	return array.removeLast();
}
template<typename T>
T ArrayStack<T>::peek() {
	return array.GetLast();
}

template<typename T>
void ArrayStack<T>::toString() {
	cout << "Stack:";
	for (int i = 0; i < array.GetSize(); i++) {
		cout << array.get(i) << ",";
	}
	cout << "top"<<endl;

}
template<typename T>
ArrayStack<T>::~ArrayStack() {
	cout << "~ArrayStack()" << endl;
	//system("pause");
}

7. 源文件3

LinkList.hpp

#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include<iostream>
using namespace std;
template<class T>
class  Node
{
public:
	Node(T e, Node* next) {
		this->data = e;
		this->next = next;
	}
	Node(T e) {
		this->data = e;
		this->next = NULL;
	}
	Node() {
		this->data = NULL;
		this->next = NULL;
	}
	T data;
	Node* next;
};

template<class T>
class  LinkList
{
public:
	LinkList() {
		virhead = new Node<T>(NULL,NULL);
		size = 0;
	}
	int GetSize() {
		return size;
	}

	bool IsEmpty() {
		return size == 0;
	}

	void add(int index,T e) {
		if (index<0 || index>size) {
			throw("index<0 || index>size");
			return;
		}
		else
		{
			Node<T>* prev = virhead;
			for (int i = 0; i < index; i++) {
				prev = prev->next;
			}
/*
			Node newnode = new Node(e);
			newnode->next = prev->next;
			prev->next = newnode;*/
			prev->next = new Node<T>(e, prev->next);
			size++;
		}
	} 
	void addFirst(T e) {
		add(0, e);
	}
	void addLast(T e) {
		add(size, e);
	}
	T Get(int index) {
		if (index<0 || index>size) {
			throw("index<0 || index>size");
			return NULL;
		}
		Node<T>* cur = virhead->next;
		for (int i = 0; i < index; i++) {
			cur = cur->next;
		}
		return cur->data;
	}
	T GetFirst() {
		return Get(0);
	}
	T GetLast() {
		return Get(size-1);
	}
	void set(int index, T e) {
		if (index<0 || index>size) {
			throw("index<0 || index>size");
			return;
		}
		Node<T>* cur = virhead->next;
		for (int i = 0; i < index; i++) {
			cur = cur->next;
		}
		cur->data=e;
	}
	bool Contain(T e) {
		Node<T>* cur = virhead;
		while (cur != NULL) {
			if (cur->data == e) {
				return true;
			}
			return false;
		}
	}
	void toString() {
		cout << "LinkList:" << endl;
		for (Node<T>* cur = virhead->next; cur != NULL;cur=cur->next) {
			cout << cur->data << "->";
		}
		cout << "NULL" << endl;
	}
	T RemoveIndex(int index) {
		if (index<0 || index>size) {
			throw("index<0 || index>size");
			return NULL;
		}
		Node<T>* prev = virhead;
		for (int i = 0; i < index; i++) {
			prev = prev->next;
		}
		Node<T>* newnode = prev->next;
		prev->next = newnode->next;
		newnode->next= NULL;
		size--;
		return newnode->data;
	}
	T RemoveFirst() {
		return RemoveIndex(0);
	}
	T RemoveLast() {
		return RemoveIndex(size-1);
	}


protected:

private:
	Node<T>* virhead;
	int size;
};

8. 源文件4

LinkListStack.hpp

#pragma once
#include "LinkList.hpp"
#include "LinkListStack.h"

template<typename T>
LinkListStack<T>::LinkListStack() {
	cout << "LinkListStack()" << endl;
}
template<typename T>
int LinkListStack<T>::GetSize() {
	return list.GetSize();
}
template<typename T>
bool LinkListStack<T>::IsEmpty() {
	return list.IsEmpty();
}

template<typename T>
void LinkListStack<T>::Push(T e) {
	list.addFirst(e);
}
template<typename T>
T LinkListStack<T>::pop() {
	return list.RemoveFirst();
}
template<typename T>
T LinkListStack<T>::peek() {
	return list.GetFirst();
}

template<typename T>
void LinkListStack<T>::toString() {
	cout << "Stack:top"<<endl;
	for (int i = 0; i < list.GetSize(); i++) {
		cout << list.Get(i) << "->";
	}
	cout  <<"NULL"<< endl;

}
template<typename T>
LinkListStack<T>::~LinkListStack() {
	cout << "~LinkListStack()" << endl;
	//system("pause");
}

9. 主程序

xxx.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <string>
#include<windows.h>  
#include<time.h>  
#include "LinkListStack.hpp"
#include "ArrayStack.hpp"
#include "StackInterface.h"
#include "LinkList.hpp"
using namespace std;

void testtime(Stack<int>*q, int count) {
	srand((unsigned)time(NULL));
	LARGE_INTEGER t1, t2, tc;
	QueryPerformanceFrequency(&tc);
	QueryPerformanceCounter(&t1);
	for (int i = 0; i < count; i++) {
		q->Push(rand());
	}
	for (int i = 0; i < count; i++) {
		q->pop();
	}
	QueryPerformanceCounter(&t2);
	printf("Use Time:%f\n", (t2.QuadPart - t1.QuadPart)*1.0 / tc.QuadPart);
}



int main(void)
{
	//链表测试
	LinkList<int> myll = LinkList<int>();
	for (int i = 0; i < 5; i++) {
		myll.addFirst(i);
		myll.toString();
	}
	myll.add(2, 11111);
	myll.toString();

	myll.RemoveIndex(2);
	myll.toString(); 
	myll.RemoveFirst();
	myll.toString();
	myll.RemoveLast();
	myll.toString();
	//链表栈测试
	LinkListStack<int> mylls = LinkListStack<int>();
	for (int i = 0; i < 5; i++) {
		mylls.Push(i);
		mylls.toString();
	}
	mylls.pop();
	mylls.toString();

	//性能测试
	int count = 10000000;
	ArrayStack<int> arrs = ArrayStack<int>();
	LinkListStack<int> lls = LinkListStack<int>();
	testtime(&arrs, count);
	testtime(&lls, count);


	system("pause");
	return 0;
}
没事多喝白开水
关注
专栏目录
C++链表、队列、栈模板
伊一易水寒的博客
07-27 233
//List.h #pragma once #include<iostream> #include<exception> #include<stdexcept> template <typename T> class List { private: class LNode { public: T item{}; LNode* pNext{...
实现一个模板类的链表（c++）
06-03
面向对象程序设计课程作业 1. 请创建一个数据类型为T的链表类模板List，实现以下成员函数： 1） 默认构造函数List()，将该链表初始化为一个空链表（10分） 2） 拷贝构造函数List(const List& list)，根据一个给定的链表构造当前链表（10分） 3） 析构函数~List()，释放链表中的所有节点（10分） 4） Push_back(T e)函数，往链表最末尾插入一个元素为e的节点（10分） 5） operator<<()友元函数，将链表的所有元素按顺序输出（10分） 6） operator=()函数，实现两个链表的赋值操作（10分） 7） operator+()函数，实现两个链表的连接，A=B+C（10分） 2. 请编写main函数，测试该类模板的正确性： 1) 用List模板定义一个List类型的模板类对象int_listB，从键盘读入m个整数，调用Push_back函数将这m个整数依次插入到该链表中；（4分） 2) 用List模板定义一个List类型的模板类对象int_listC，从键盘读入n个整数，调用Push_back函数将这n个整数依次插入到该链表中；（4分） 3) 用List模板定义一个List类型的模板类对象int_listA，调用List的成员函数实现A = B + C；（4分） 4) 用cout直接输出int_listA的所有元素（3分） 5) 用List模板定义List类型的模板类对象double_listA, double_listB, double_listC，重复上述操作。（15分） 3. 输入输出样例： 1) 输入样例 4 12 23 34 45 3 56 67 78 3 1.2 2.3 3.4 4 4.5 5.6 6.7 7.8 2) 输出样例 12 23 34 45 56 67 78 1.2 2.3 3.4 4.5 5.6 6.7 7.8
C++利用链表与模板实现栈
luanzheng_365的博客
03-19 635
栈是一种十分常见的后进先出的数据结构.本文使用C++, 模板, 链表来自己实现一个最基本的栈.
链式链表实现栈模型(C++模板类)
qq_41836269的博客
03-16 334
栈满足先进后出的功能，用于在很多场景，可以发挥意想不到的功能。 栈是一种特殊的线性表，因此可以通过线性链表来实现栈的功能。线性链表有顺序，和链式两种，这里选取链式链表实现栈（顺序请参考上一博客）。在链式链表实现栈模型，栈顶可以可以在链表的头部或尾部，用链表的尾部作为栈顶，入栈和出栈要遍历链表节点直到遍历到链表的尾部，过程复杂效率低下。但用链表的头部作为栈顶，入栈和出栈只用操作链表的首元素，不涉及...
基于链表的模板栈
weixin_44944949的博客
09-14 141
第一次造轮子，使用模板实现的基于链表的栈简介及代码测试代码测试结果后记 简介及代码 首先创建一个结构体模板，即一个链表节点，作为栈的单元。 template <class T> struct LinkedList{ T val; struct LinkedList<T>* next; // LinkedList(T v):val(v),next(NULL){} }; 然后新建一个类，该类有两个成员，分别为栈顶指针top和栈的大小size，top永远指向链表的
c c++ 顺序表 链表 队 栈 树类模板实现 以及例子
01-27
在C/C++中，可以使用数组或链表来实现栈。主要操作包括压栈（push）、弹栈（pop）和查看栈顶元素。栈常用于函数调用、表达式求值和回溯算法等。 5. **树**： 树是一种非线性的数据结构，由节点和连接节点的边组成...
模板线性表，链表，队列，栈的实现（C++实现）
07-31
本文将深入探讨四个基本数据结构的C++实现：模板线性表、链表、队列和栈。这些数据结构在软件开发中扮演着至关重要的角色，它们提供了多种处理数据的方法，使得算法设计和程序优化变得更加灵活。 1. **模板线性表**...
DSA_CPP.rar_向量_树的C++模板实现_链表
09-21
这里，我们关注的是"DSA_CPP.rar"压缩包中的内容，它提供了C++实现向量、链表以及树的数据结构。下面将详细讨论这些知识点。 首先，向量（Vector）是C++标准库中的一种动态数组，它提供了许多便利的方法，如插入、...
C++实现链表模板（链表项的数据元素可以为任意类型）：链表项的插入、删除、链表的打印、两个链表的连接VS2010
08-21
在这个项目中，我们利用C++的模板类来实现一个通用的链表，允许链表项的数据元素可以是任意类型。这极大地增强了代码的复用性。 首先，我们要理解C++中的类模板。类模板是C++的一个强大特性，它允许我们创建可以...
C++模板实现顺序栈
12-20
C++模板实现顺序栈是一种高效且灵活的数据结构，它允许我们用一种通用的方式来处理不同类型的元素。顺序栈基于数组，其工作原理类似于生活中常见的栈，遵循“后进先出”（LIFO）的原则。在顺序栈中，所有的元素都是...
用数组合链表实现栈
04-08
为了更好的理解栈的原理.用数组合链表实现栈
栈模板的链表实现
空山无人,水流花开
04-28 393
stack.h #include #include using namespace std;  template<class T> class Stack {  public:   Stack();   ~Stack();     int size() const;   bool empty() const;   T& top();   void push(const T&);   void
用数组创建链表模板
weixin_43313092的博客
08-03 451
struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; int main() { ListNode *pHead = new ListNode(NULL); ListNode *pPre = pHead, *pNode = NULL; vector<int> vec = { 1,2,3,3,4,4,5 }; for (int i = 0; i < vec.siz
栈模板的链表实现（包含头结点），实现了栈的压入，栈的弹出，返回栈顶元素，排序等操作
qq_28633157的博客
10-12 1090
//头文件 #ifndef STACKLIST_H #define STACKLIST_H #include #include #include using namespace std; template class LinkNode{ //该类的作用是作为节点 public: T data; LinkNode* link; LinkNode(){
[数据结构]栈之链式栈的类模板实现
借你一秒
06-22 2086
栈的抽象基类的实现:(不用抽象基类也是可以的，为了使用虚函数方便） #ifndef STACK #define STACK //栈的抽象基类 template class Stack { public: Stack(){} ~Stack(){} virtual void Push(const T& x)=0; virtual bool Pop(T& x
栈的链表和数组实现
Andy_Xu2014的博客
10-09 302
栈的链表实现 LinkStack.h #ifndef LINKSTACK_H_ #define LINKSTACK_H_ typedef int DataType; //自定义数据类型,假定为整型 struct Node; //单链表结点类型 typedef struct Node *PNo...
C++ 利用模板类链表实现栈结构
God_Xuebi的博客
10-11 1090
C++ 利用模板类链表实现栈结构 运行环境： Dev-c++ 5.11 日期：2018.10.11 主程序 main.cpp //Written by Xuebi //本程序利用链表实现栈结构，实现Pop,Push,Top基本功能 //链表采用前插法构建，不存在空结点 #include &lt;iostream&gt; using namespace std; template &lt;cla...
C++实现链式栈模板类
theo_a_sommeil的博客
06-30 969
上代码上代码//Stack所存放的节点类 #ifndef NODE_H_ #define NODE_H_ #include &lt;cstdlib&gt; #include &lt;iostream&gt; using namespace std; template &lt;typename ElemType&gt; struct Node { ElemType data; Node&lt;...
栈的c++实现（类模板，包含顺序实现和链表实现）
weixin_37993890的博客
04-02 825
头文件：#ifndef STACK_H_INCLUDED #define STACK_H_INCLUDED class OutOfBound{}; template &lt;class elemType&gt; class Stack { public: virtual bool isEmpty() const=0; virtual void push(const elemTy...
C语言模板实现：简易链表栈
本文介绍如何在C语言中利用模板实现一个简单的栈类，该栈类支持数组和单链表两种数据结构，具有后进先出（LIFO）特性，包括入栈、出栈、判断栈是否为空、获取栈的大小等基本功能。 在C++编程中，模板是一种强大的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值