48 c++模板库数据结构

于 2021-10-14 10:52:17 发布
阅读量193 收藏 1
点赞数
分类专栏： 笔记 文章标签： 数据结构 c++ 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36643203/article/details/120759541
版权
该博客详细介绍了如何使用C++模板类实现线性表的顺序存储（SeqList）和链式存储（LinkList），包括增删查改等基本操作。此外，还展示了如何利用链式存储实现栈（LinkStack）的数据结构，支持压栈、弹栈、查看栈顶元素和检查栈的大小。示例代码中涉及了结构体 Teacher 的使用，以及动态内存管理和深拷贝问题。
摘要由CSDN通过智能技术生成

1 线性表顺序存储

SeqList.h

#pragma once
template <typename T>
class SeqList
{
public:
	SeqList(int capacity);
	~SeqList();

	// 返回一个线性表list中的元素个数
	int get_Length();

	int get_Capacity();

	// 向一个线性表list的pos位置中插入新元素node
	int insert(T &t, int pos);

	// 获取一个线性表list的pos位置处的元素
	int get(T &list, int pos);

	// 删除一个线性表list的pos处元素，返回值为被删除的元素，NULL表示删除失败
	int del(T& list, int pos);
    
    // 清空链表
    int clear();

private:
	int length;
	int capacity;
	T* pArray;		// 数组
};

SeqList.cpp

#include "SeqList.h"
#include<iostream>

template <typename T>
SeqList<T>::SeqList(int capacity)
{
	// T* pArray;	// 数组
	pArray = new T[capacity];
	this->capacity = capacity;
	this->length = 0;
}

template <typename T>
SeqList<T>::~SeqList()
{
	delete[]pArray;
	pArray = NULL;
	length = 0;
	capacity = 0;
}


// 返回一个线性表list中的元素个数
template <typename T>
int SeqList<T>::get_Length() {
	return this->length;
}

template <typename T>
int SeqList<T>::get_Capacity() {
	return capacity;
}

// 向一个线性表list的pos位置中插入新元素node
template <typename T>
int SeqList<T>::insert(T& t, int pos) {
	int i = 0;
	if (pos < 0) {
		return -1;
	}

	// 元素后移
	for (i = this->length; i > pos; i--) {
		pArray[i] = pArray[i-1];
	}

	pArray[i] = t;	//stl元素保存是通过复制的机制实现的,类需要可以复制
	this->length++;
	return 0;
}

// 获取一个线性表list的pos位置处的元素
template <typename T>
int SeqList<T>::get(T& t, int pos) {
	int i = 0;
	if (pos < 0) {
		return -1;
	}
	t = pArray[pos];
	return 0;
}

// 删除一个线性表list的pos处元素，返回值为被删除的元素，NULL表示删除失败
template <typename T>
int SeqList<T>::del(T& t, int pos) {
	int i = 0;
	t = pArray[pos];
	for (i = pos + 1; i < length; i++) {
		pArray[i - 1] = pArray[i];
	}
	this->length--;
	return 0;
}

template<typename T>
int SeqList<T>::clear(){
    this->length = 0;
	return 0;
}

mainseqlist.cpp

#include<iostream>

// 模板需要加cpp
#include"SeqList.cpp"
using namespace std;


struct Teacher
{
	char name[64];
	int age;
};
void main_seqlist_play() {
	Teacher t1, t2, t3, tmp;
	t1.age = 21;
	t2.age = 22;
	t3.age = 23;
	SeqList<Teacher> list(10);
	list.insert(t1, 0);
	list.insert(t2, 0);
	list.insert(t3, 0);

	// 测试链表遍历
	for (int i = 0; i < list.get_Length(); i++) {
		list.get(tmp, i);
		cout << tmp.age << " "; 
	}
	cout << endl;
    
    list.clear();

	list.insert(t1, 0);
	list.insert(t2, 0);
	list.insert(t3, 0);
    
	while (list.get_Length() > 0) {
		list.del(tmp, 0);
		cout << tmp.age << " ";
	}
	cout << endl;
}

void main_seqlist_play02() {
	Teacher t1, t2, t3;
	Teacher* p1, * p2, * p3;
	Teacher* tmp;
	t1.age = 21;
	t2.age = 22;
	t3.age = 23;

	p1 = &t1;
	p2 = &t2;
	p3 = &t3;
	
	
	SeqList<Teacher *> list(10);
	list.insert(p1, 0);
	list.insert(p2, 0);
	list.insert(p3, 0);

	// 测试链表遍历
	for (int i = 0; i < list.get_Length(); i++) {
		list.get(tmp, i);
		cout << tmp->age << " ";
	}
	cout << endl;
	while (list.get_Length() > 0) {
		list.del(tmp, 0);
		cout << tmp->age << " ";
	}
	cout << endl;
}

void main() {
	main_seqlist_play();
	main_seqlist_play02();
}

结果

23 22 21
23 22 21
23 22 21
23 22 21

2 线性表链式存储

LinkList.h

#pragma once

// 在插入元素时，模板类中应该把每一个t保存下来
// 模板类中应该能分配节点缓存节点

// 怎么样缓存==>linklist 链表
template<typename T>
struct Node {
	T t;
	Node* next;
};

template <typename T>
class LinkList
{
public:
	LinkList();
	~LinkList();

	// 返回一个线性表list中的元素个数
	int get_Length();

	int get_Capacity();

	// 向一个线性表list的pos位置中插入新元素node
	int insert(T& t, int pos);

	// 获取一个线性表list的pos位置处的元素
	int get(T& list, int pos);

	// 删除一个线性表list的pos处元素，返回值为被删除的元素，NULL表示删除失败
	int del(T& list, int pos);

	int clear();

private:
	Node<T>* head;	// 在链表中需要建一个带有头节点的链表
	int length;
};

LinkList.cpp

#include "LinkList.h"
#include<iostream>


template<typename T>
LinkList<T>::LinkList()
{
	head = new Node<T>;
	head->next = NULL;
	length = 0;
}

template<typename T>
LinkList<T>::~LinkList()
{
	Node<T>* tmp = NULL;
	while (head != NULL) {
		tmp = head->next;		// 删除链表的时候缓存后面节点
		delete head;
		head = tmp;
	}
	length = 0;
	head = NULL;
}


// 返回一个线性表list中的元素个数
template<typename T>
int LinkList<T>::get_Length() {
	return length;
}

// 向一个线性表list的pos位置中插入新元素node
template<typename T>
int LinkList<T>::insert(T& t, int pos) {
	Node<T>* current = NULL;
	current = head;
	
	for (int i = 0; i < pos; i++) {
		current = current->next;
	}
	
	// 思考 node 节点存在吗？ 不存在 需要申请
	Node<T>* node = new Node<T>;
	if (node == NULL) {
		return -1;
	}
	node->t = t;	// 缓存外部数据
	node->next = NULL;
	// 新节点连接后续链表
	node->next = current->next;
	// 连接新节点
	current->next = node;

	length++;

	return 0;
}

// 获取一个线性表list的pos位置处的元素
template<typename T>
int LinkList<T>::get(T& t, int pos) {
	Node<T>* current = NULL;
	current = head;

	for (int i = 0; i < pos; i++) {
		current = current->next;
	}

	t = current->next->t;	// 把缓存的t传给调用者

	return 0;
}

// 删除一个线性表list的pos处元素，返回值为被删除的元素，NULL表示删除失败
template<typename T>
int LinkList<T>::del(T& t, int pos) {
	Node<T>* current = NULL;
	Node<T>* ret = NULL;
	current = head;

	for (int i = 0; i < pos; i++) {
		current = current->next;
	}
	ret = current->next;	// 被删除元素

	t = ret->t;		// 把缓存数据拷贝出
	current->next = ret->next;
	length--;
	
	delete ret;

	return 0;

}

template<typename T>
int LinkList<T>::clear() {
	Node<T>* tmp = NULL;
	while (head != NULL) {
		tmp = head->next;		// 删除链表的时候缓存后面节点
		delete head;
		head = tmp;
	}
	length = 0;
	head = NULL;

	head = new Node<T>;
	head->next = NULL;
	length = 0;
	return 0;
}

main

#include<iostream>

// 模板需要加cpp
#include"SeqList.cpp"
#include"LinkList.cpp"
using namespace std;


struct Teacher
{
	char name[64];
	int age;
};
void main_linklist_play() {
	Teacher t1, t2, t3, tmp;
	t1.age = 21;
	t2.age = 22;
	t3.age = 23;
	LinkList<Teacher> list;
	list.insert(t1, 0);
	list.insert(t2, 0);
	list.insert(t3, 0);

	// 测试链表遍历
	for (int i = 0; i < list.get_Length(); i++) {
		list.get(tmp, i);
		cout << tmp.age << " ";
	}
	cout << endl;

	list.clear();

	list.insert(t1, 0);
	list.insert(t2, 0);
	list.insert(t3, 0);

	// 销毁链表
	while (list.get_Length() > 0) {
		list.del(tmp, 0);
		cout << tmp.age << " ";
	}
	cout << endl;
}

void main() {
	main_linklist_play();
}

加入指针之后，需要考虑拷贝复制中的问题

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

// 模板需要加cpp
#include"SeqList.cpp"
#include"LinkList.cpp"
using namespace std;


struct Teacher
{
public:
	char name[64];
	int age;
	char* pdes;
	Teacher(){
		memset(name, 0, sizeof(name));
		age = 0;
		pdes = NULL;
	}
	Teacher(const Teacher& obj) {
		pdes = (char*)malloc(100);
		strcpy(this->pdes, obj.pdes);
		strcpy(this->name, obj.name);
		age = obj.age;
	}
	~Teacher() {
		if (pdes != NULL) {
			free(pdes);
		}
	}
	// t1 = t2;
	Teacher& operator=(const Teacher& obj) {
		// 清除t1内存空间
		if (pdes != NULL && pdes != obj.pdes) {
			free(pdes);
			pdes = NULL;
			pdes = (char*)malloc(100);
			strcpy(this->pdes, obj.pdes);
		}
		strcpy(this->name, obj.name);
		age = obj.age;
		return *this;
	}
};

void main_linklist_play() {
	Teacher t1, t2, t3, tmp;
	t1.age = 21;
	t2.age = 22;
	t3.age = 23;

	t1.pdes = (char *)malloc(100);
	strcpy(t1.pdes, "t1t1t1");

	t2.pdes = (char*)malloc(100);
	strcpy(t1.pdes, "t2t2t2");

	t3.pdes = (char*)malloc(100);
	strcpy(t1.pdes, "t3t3t3");

	LinkList<Teacher> list;
	list.insert(t1, 0);
	list.insert(t2, 0);
	list.insert(t3, 0);

	// 测试链表遍历
	for (int i = 0; i < list.get_Length(); i++) {
		list.get(tmp, i);
		cout << tmp.age << " ";
	}
	cout << endl;

	list.clear();

	list.insert(t1, 0);
	list.insert(t2, 0);
	list.insert(t3, 0);

	// 销毁链表
	while (list.get_Length() > 0) {
		list.del(tmp, 0);
		cout << tmp.age << " ";
	}
	cout << endl;
}

void main() {
	main_linklist_play();

}

3 栈(利用线性表链式存储实现)

LinkStack.h

#pragma once
#include"LinkList.h"
template<typename T>
class LinkStack
{
public:
	LinkStack();
	~LinkStack();

	void clear();

	int push(T& t);

	int pop(T& t);

	int top(T& t);
	
	int size();
private:
	LinkList<T>* list;
};

LinkStack.cpp

#include "LinkStack.h"
#include<iostream>

template<typename T>
LinkStack<T>::LinkStack()
{
	// 创建栈 相当于创建线性表
	list = new LinkList<T>;
}

template<typename T>
LinkStack<T>::~LinkStack()
{
	clear();
	delete list;
	list = NULL;
}

template<typename T>
void LinkStack<T>::clear() {
	// 清空一个栈 相当于 清空一个链表
	list->clear();
}

template<typename T>
int LinkStack<T>::push(T& t) {
	// 向栈中添加元素相当于在 链表的头部添加元素
	return list->insert(t, 0);
}

template<typename T>
int LinkStack<T>::pop(T& t) {
	// 从栈中添加元素相当于从 线性表头部删除元素
	return list->del(t, 0);
}

template<typename T>
int LinkStack<T>::top(T& t) {
	// 从栈顶获取元素 相当于从线性表中获取0号位置
	return list->get(t, 0);
}

template<typename T>
int LinkStack<T>::size() {
	return list->get_Length();
}

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>

// 模板需要加cpp
#include"LinkStack.cpp"
using namespace std;


struct Teacher
{
public:
	char name[64];
	int age;
}

void main_linkstack_play() {

	// 创建栈 
	LinkStack<Teacher> stack;
	Teacher t1, t2, t3;
	Teacher tmp;
	t1.age = 21;
	t2.age = 22;
	t3.age = 23;
	stack.push(t1);
	stack.push(t2);
	stack.push(t3);

	// 获取栈顶元素
	stack.top(tmp);
	cout << tmp.age << endl;

	cout << stack.size() << endl;
	// 栈的删除
	while (stack.size() > 0) {
		stack.pop(tmp);
		cout << tmp.age << " ";
	}


}

void main() {

	main_linkstack_play();
}
HowDonew
关注
专栏目录
数据结构之C++STL库
Joey's Blog
09-26 782
使用STL实现迭代器 #include&lt;iostream&gt; #include&lt;vector&gt; using namespace std; void print(vector&lt;int&gt; v) { //从向量开头顺次访问 vector&lt;int&gt;::iterator it; for (it = v.begin(); it != v.end(); it...
数据结构类库c++版
07-03
这是我们老师自己编的，在vc++6.0上完全可以运行，很不错的
c++中的数据结构库
weixin_43591464的博客
02-15 503
//向量 #include<iostream> #include<vector> using namespace std; int main(){ vector<string> vs; string s; while(cin>>s){ vs.push_back(s); } for(int i=v...
C++标准模板库与数据结构的学习
weixin_34327761的博客
09-20 259
　　STL（Standard Template Library），即标准模板库，是一个具有工业强度的，高效的C++程序库。它被容纳于C++标准程序库（C++ Standard Library）中，是ANSI/ISO C++标准中极具革命性的一部分。该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。为广大C++程序员们提供了...
c++库函数版数据结构
hgchshs的博客
09-03 245
c++库函数版数据结构 基于stl库中vector的栈 栈的实现代码 栈属于序列的特例，故可直接基于向量或列表派生 template<typename T> class Stack public Vector<T> { public: //size()、empty()以及其它开放接口均可直接沿用 void push(T const & e)//入栈 { insert(size(),e; } T
基于C++模板Template的数据结构代码库
最新发布
10-06
该项目是基于c++11和C++ Template的语法实现了常规数据结构的泛型化处理，采用类似Boost库的编程风格实现。所有目录都配有测试源代码。 该项目实现了数组、列表、双向列表、队列、树、图、搜索、排序等算法。可以...
基于C++模板的通用数据结构设计源码
09-27
本项目提供了一组基于C++模板的通用数据结构源码，总计包含139个文件，涵盖68个头文件、31个源文件、15个文本文件、4个JSON文件和1个Git忽略文件。代码支持跨平台编译，适用于Windows、Linux和Mac操作系统。该数据...
C++模板实现简单的数据结构
04-11
总之，C++模板机制使得我们能够编写泛型代码，适用于各种数据类型，从而实现高效的数据结构。通过理解并掌握这些基本数据结构的实现，开发者可以设计出更加高效和灵活的算法，解决各种实际问题。在实际项目中，根据...
基于C++模板 实现的数据结构代码
02-21
本文将深入探讨如何使用C++模板来实现常见的数据结构，如数组、链表、栈、队列、树等。我们将讨论模板的概念、语法以及在实现这些数据结构时的具体应用。 一、C++模板基础 1.1 模板分类 C++模板分为两种：函数模板...
基于C++模板 实现的数据结构代码.zip
06-17
本压缩包“基于C++模板实现的数据结构代码.zip”显然是一份关于如何利用C++模板来设计和实现各种数据结构的资源集合。 首先，我们来看看C++模板。模板是C++中的泛型编程，允许我们编写参数化的类型代码。这意味着...
数据结构 C++ STL库及用法详解
08-05
数据结构中的STL库，各种模板详解用途及用法，c++
数据结构各种算法实现(C++模板)
08-02
数据结构各种算法实现(C++模板)
《数据结构：使用C++标准模板库（STL)》
05-14
《数据结构：使用C++标准模板库（STL)》 陈本林 傅健康 编著
c++模板存储类数据结构
01-07
使用c++模板保存类结构文件，支持多级存储，多级嵌套，存取极为方便
C语言数据结构库（队列，栈，链表，树的增删改查）
07-09
本库为C语言（Linux环境下编写的适用于所有C的数据结构库函数）。包括了最基础也是最常用的增删改查功能函数，队列，栈，链表（单链表，双链表，循环链表等都有），树的增删改查函数。程序可靠。
C++模板与数据结构
qq4165498的博客
08-03 430
算法，尤其是通用算法是程序设计的重点。模板是建立与数据类型无关的通用算法的重要手段。C++国际标准ISO14882将模板正式引入标准库，要求用模板类取代传统的C++中定义的类。 本章介绍模板及其应用，使读者通过学习与数据结构相关的表、排序和查找的知识和算法，逐步熟悉函数模板和类模板的编程方法。
C++ 标准模板库STL的数据结构
luanqibaazao的博客
09-04 1201
很多时候要用数据结构的时候，不能很好的利用标准库中已有的结构。感觉又浪费时间 又不讨好，主要还是对基本的数据结构的理解和使用不熟悉。这里总结一下C++ STL中的数据结构。STL中数据结构以 STL容器（Container）的形式提供， 主要包括序列式容器和关联式容器。vector动态数组 #include1.定义和初始化vector<int> vec1; //默认初始化，vec1
C++使用标准库实现经典数据结构数据结
weixin_45259896的博客
10-12 416
this is a test do you know the value is
C++STL库常用数据结构用法整理
weixin_30104533的博客
06-02 3802
vector创建对象，vector&lt;int&gt; vec;尾部插入数字，vec.push_back(a)；使用下表访问元素使用迭代器访问元素插入元素删除最后一个元素，vec.pop_back()queue定义一个queue的变量 queue&lt;Type&gt; M查看是否为空范例  M.empty()从已有元素后面增加元素 M.push()输出现有元素的个数 M.size()显示第一个...
AcWing C++算法与数据结构模板库
资源摘要信息:"AcWing算法基础课程中提供的c++常用算法和数据结构模板" AcWing是一个专注于编程竞赛和算法学习的在线教育平台，它为编程竞赛爱好者和专业人士提供了丰富的学习资源和训练环境。AcWing的算法基础课程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值