【SEU程序设计课笔记】 26 - 2021/01/11 - Write C++ programs - 链表（List 类）

于 2021-01-20 15:38:48 发布
阅读量185 收藏
点赞数
分类专栏： 【SEU程序设计课（C/C++）】 文章标签： c++ 链表 单链表 linked list visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50012998/article/details/112601400
版权
这篇博客介绍了一个模板类`List`的实现，它支持多种数据结构（如数组、向量、列表和双端队列）的构造，并提供了包括插入、删除、访问和打印等操作。此外，代码中包含了错误检查，当操作超出范围或尝试操作空链表时，会显示错误信息。
摘要由CSDN通过智能技术生成

链表

功能

公有函数功能
List(const List<T>&)拷贝构造函数
List(const T*, std::size_t)由数组构造
List(const std::vector<T>&)由 vector 构造
List(const std::list<T>&)由 list 构造
List(const std::deque<T>&)由 deque 构造
inline void push_back(const T& item)最后插入
inline void push_front(const T& item)最前插入
inline void pop_back()删除最后一个
inline void pop_front()删除第一个
inline void insert(const T& item, std::size_t index = node_number)在特定位置前插入
inline void removeAt(std::size_t index)删除特定位置的一个数
inline void clear()清空 List
inline void append(const List<T>&)在 List 后附加一个 List
inline bool isEmpty() const判断是都为空
inline T at(std::size_t index) const只读访问特定位置内容
inline T& at(std::size_t index)可写访问特定位置内容
std::size_t size() constList大小
void print(std::ostream& out = std::cout, std::string str = " ", bool null_info = false) const打印List（第一个参数：输出形式；第二个参数：间隔符；第三个参数：List为空是否提醒）
void operator=(const List<T>&);赋值
inline T operator[](std::size_t index) const;只读访问特定位置内容
inline T& operator[](std::size_t index);可写访问特定位置内容

输出：默认是print(out, " ");。

代码

List.h

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <Windows.h>
#define _LIST_H_

template<typename T0>
struct Node
{
	T0 value = 0;             // the value the node holds
	Node<T0>* next = nullptr; // the pointer that points to the next node

	Node() = default;         // the default constuctor 
	Node(T0 value_, Node<T0>* next_ = nullptr) : value(value_), next(next_) {} // constructor
};

template<typename T>
class List
{
public:
	List() = default;
	List(const List<T>&);
	List(const T*, std::size_t);
	List(const std::vector<T>&);
	List(const std::list<T>&);
	List(const std::deque<T>&);
	inline void push_back(const T& item);
	inline void push_front(const T& item);
	inline void pop_back();
	inline void pop_front();
	inline void insert(const T& item, std::size_t index = node_number);
	inline void removeAt(std::size_t index);
	inline void clear();
	inline void append(const List<T>&);
	inline bool isEmpty() const;
	inline T at(std::size_t index) const;
	inline T& at(std::size_t index);
	std::size_t size() const;
	void print(std::ostream& out = std::cout, std::string str = " ", bool null_info = false) const;
	void operator=(const List<T>&);
	inline T operator[](std::size_t index) const;
	inline T& operator[](std::size_t index);

private:
	Node<T>* head = nullptr;
	Node<T>* tail = head;
	std::size_t node_number = 0;

	inline Node<T>* find(std::size_t index);
};

template<typename T>
std::ostream& operator<<(std::ostream&, const List<T>& list);

template<typename T>
List<T>::List(const List<T>& new_list)
{
	for (Node<T>* p = new_list.head; p; p = p->next)
	{
		this->push_back(p->value);
	}
}

template<typename T>
List<T>::List(const T* new_elements, std::size_t new_size)
{
	for (std::size_t i = 0; i != new_size; i++)
	{
		this->push_back(*(new_elements++));
	}
}

template<typename T>
List<T>::List(const std::vector<T>& vec)
{
	for (T item : vec)
	{
		this->push_back(item);
	}
}

template<typename T>
List<T>::List(const std::list<T>& new_list)
{
	for (auto item : new_list)
	{
		this->push_back(item);
	}
}

template<typename T>
List<T>::List(const std::deque<T>& vec)
{
	for (T item : vec)
	{
		this->push_back(item);
	}
}

template<typename T>
void List<T>::push_back(const T& item)
{
	Node<T>* new_tail = new Node<T>(item);
	if (this->isEmpty())
	{
		tail = head = new_tail;
		node_number++;
	}
	else
	{
		tail->next = new_tail;
		tail = new_tail;
		node_number++;
	}
}

template<typename T>
void List<T>::push_front(const T& item)
{
	Node<T>* new_head = new Node<T>(item, head);
	this->head = new_head;
	node_number++;
}

template<typename T>
void List<T>::pop_back()
{
	if (!this->isEmpty())
	{
		if (node_number == 1)
		{
			node_number = 0;
			head = tail = nullptr;
		}
		else
		{
			find(node_number - 2)->next = nullptr;
			this->tail = find(node_number - 2);
			node_number--;
		}
	}
	else
	{
		MessageBox(NULL, L"Can not pop back an empty list.\nThis action has been omitted", L"ERROR", MB_ICONERROR);
	}
}

template<typename T>
void List<T>::pop_front()
{
	if (!this->isEmpty())
	{
		head = head->next;
		node_number--;
	}
	else
	{
		MessageBox(NULL, L"Can not pop front an empty list.\nThis action has been omitted", L"ERROR", MB_ICONERROR);
	}
}

template<typename T>
void List<T>::insert(const T& item, std::size_t index)
{
	if (index > node_number)
	{
		MessageBox(NULL, L"Can not insert out of range.\nThis action has been omitted", L"ERROR", MB_ICONERROR);
	}
	else
	{
		if (index)
		{
			Node<T>* new_node = new Node<T>(item, find(index));
			find(index - 1)->next = new_node;
			node_number++;
		}
		else
		{
			this->push_front(item);
		}
	}
}

template<typename T>
void List<T>::removeAt(std::size_t index)
{
	if (index >= node_number)
	{
		MessageBox(NULL, L"Can not remove out of range.\nThis action has been omitted", L"ERROR", MB_ICONERROR);
	}
	else if (index)
	{
		find(index - 1)->next = find(index + 1);
		node_number--;
	}
	else
	{
		pop_front();
	}
}

template<typename T>
void List<T>::clear()
{
	tail = head = nullptr;
	node_number = 0;
}

template<typename T>
bool List<T>::isEmpty() const
{
	if (node_number) return false;
	else return true;
}

template<typename T>
void List<T>::append(const List<T>& new_list)
{
	for (Node<T>* p = new_list.head; p; p = p->next)
	{
		this->push_back(p->value);
	}
}

template<typename T>
T List<T>::at(std::size_t index) const
{
	Node<T>* ret = find(index);
	if (ret)
	{
		return ret->value;
	}
	else
	{
		MessageBox(NULL, L"Subscript out of range.", L"ERROR", MB_ICONERROR);
		exit(-1);
	}
}

template<typename T>
T& List<T>::at(std::size_t index)
{
	Node<T>* ret = find(index);
	if (ret)
	{
		return ret->value;
	}
	else
	{
		MessageBox(NULL, L"Subscript out of range.", L"ERROR", MB_ICONERROR);
		exit(-1);
	}
}

template<typename T>
std::size_t List<T>::size() const
{
	return node_number;
}

template<typename T>
Node<T>* List<T>::find(std::size_t index)
{
	if (index > node_number)
	{
		return nullptr; // indecate can not find (i.e. not within range)
	}
	else
	{
		Node<T>* target = this->head;
		for (int i = 0; i != index; i++)
		{
			target = target->next;
		}
		return target;
	}
}

template<typename T>
void List<T>::print(std::ostream& out, std::string fill_str, bool null_info) const
{
	if (null_info && this->isEmpty())
	{
		MessageBox(NULL, L"Empty List", L"Information", MB_ICONINFORMATION);
		return;
	}
	Node<T>* p = this->head;
	for (; p && p->next; p = p->next)
	{
		out << p->value << fill_str;
	}
	if (p) out << p->value;
}

template<typename T>
void List<T>::operator=(const List<T>& new_list)
{
	this->clear();
	for (Node<T>* p = new_list.head; p; p = p->next)
	{
		this->push_back(p->value);
	}
}

template<typename T>
T List<T>::operator[](std::size_t index) const
{
	return this->at(index);
}

template<typename T>
T& List<T>::operator[](std::size_t index)
{
	return this->at(index);
}

template<typename T>
std::ostream& operator<<(std::ostream& out, const List<T>& list)
{
	list.print(out, " ");
	return out;
}

测试

测试代码：

#include "List.h"
using  namespace std;

int main(int argc, char** argv)
{
	double a[5] = { 0, 2, 3.4,-2, 0.8 };
	vector<double> b = { 0.1, -0.5, 0.3 };
	List<double> test(a, 4);
	List<double> test2(b);
	cout << test << endl;
	test.push_back(1);
	cout << test << endl;
	test.push_front(-6.2);
	cout << test << endl;
	test.removeAt(2);
	cout << test << endl;
	test.append(test2);
	cout << test << endl;
	test.pop_back();
	cout << test << endl;
	test[1] = -100;
	cout << test << endl;
	test.clear();
	cout << test << endl;
	for (size_t i = 0; i != 10; i++)
	{
		test.push_back(i);
	}
	cout << test << endl;
	test.insert(0, 3);
	cout << test << endl;
	for (size_t j = 0; j != 5; j++)
	{
		test.pop_front();
	}
	cout << test << endl;
	test = test2;
	test.print(cout, " -> ");
	cout << endl;
	return 0;
}

输出效果：
Output

分析

  • 本程序对于错误的操作进行了判断，并会用MessageBox弹窗提示。
  • 有一些奇怪的事情，如果将.h和.cpp分离，编译器汇报奇怪的错误（MSVC 和 MinGW 都会）：
    Error

ALL RIGHTS RESERVED © 2021 Teddy van Jerry
欢迎转载，转载请注明出处。

See also

Teddy van Jerry 的导航页

Teddy van Jerry
关注
专栏目录
Actel提升RTAX-S/SL系列FPGA的性能
01-19
爱特公司(Actel Corporation)宣布进一步提升其业界之耐辐射RTAX-S和RTAX-SL航天用FPGA的性能和可用性，为航天应用设计人员带来更大优势。RTAX-S/SL 系列FPGA能够免除与耐辐射ASIC相关的成本和进度表风险，是需要防止...
C/C++编程：std::size_t
OceanStar的博客
03-09 2119
std::size_t 定义于如下头文件 #include<cstddef> #include<cstdio> #include<cstdlib> #include<cstring> #include<ctime> #include<cuchar> #include<cwchar> typedef /*implementation-defined*/ size_t; std::size_t可以存放下理论上可能存
C++ STL标准库： std::list使用介绍、用法详解
热门推荐
超级大洋葱的博客
12-16 10万+
文章目录0. std::list 简介1 std::list 定义对象2 std::list添加元素3 std::list删除元素4 std::list容器容量5 std::list迭代器6 std::list判断是否为空7 std::list元素的存取和访问8 std::list元素重置9 std::list 交换两个容器的内容10 std::list元素的插入和删除11 std::list运算符函数12 std::list merge()和sort()13 std::list remove() 和 re
EDA/PLD中的Actel提升RTAX-S/SL系列FPGA的性能
11-11
Actel Corporation，一家知名的电子设计自动化（EDA）和可编程逻辑设备（PLD）供应商，宣布了对RTAX-S/SL系列现场可编程门阵列（FPGA）的重大性能升级，特别针对航天应用领域。这一提升旨在为航天设计工程师提供更...
EDA/PLD中的Actel退出适合太空应用的低功耗FPGA RTAX-SL系列
11-29
耐辐射RTAX-SL FPGA系列是现有器件系列中的一款低功耗系列，其目标市场定位于高可靠性太空飞行设计。在最差情况下，与标准器件相比，该器件可以提供大约低50%的待机电流。FPGA的逻辑门密度扩展到250,000到40亿等效...
Robomaster2018-SEU-OpenSource：这是东南大学RoboMaster 2018竞赛的开源项目
01-30
Robomaster2018-SEU-开源这是东南大学为Robomaster 2018设计的一个项目，其中包括完成自动射击和符文检测任务的完整过程。 包括装甲检测，符文检测，角度求解算法和驱动程序，串行通信。 这基本上是我们在比赛中使用...
seu-report-latex-template:东南大学的LaTeX模板
05-17
SEU LaTeX Template 东南大学 LaTeX 模板 LaTeX template for Southeast University 使用简介 支援且推荐使用 ，并推荐使用 xetex 引擎编译。 中文字体需求 默认采用作为衬线字体，作为非衬线与等宽字体。 使用...
【SEU程序设计课笔记】 Mooc - Chapter 6 - (EX) - 泰勒展开求sin(x)/计算PI的近似值
Teddy van Jerry的博客
12-23 640
Mooc 课程：程序设计基础——发现计算之美 李骏扬 、魏海坤 、仰燕兰 、朱蔚萍 、杨万扣 网址：https://www.icourse163.org/course/SEU-1003771004 泰勒展开求sin(x) 题目 采用泰勒级数展开 sin x，并用C/C++语言实现： 输入一个实数 x（角度） 判断 x，并按 sin 的周期将 x 等效折算到 -180° 到 180° 之间，并进一步按照 sin x 的对称性折算到 -90° 到 90°之间 从角度折算为弧度 采用迭代代价最小的方式计算 s
【SEU程序设计课笔记】 Mooc - Chapter 4 - 递推求和/国际象棋棋盘
Teddy van Jerry的博客
10-22 517
Mooc 课程：程序设计基础——发现计算之美 李骏扬 、魏海坤 、仰燕兰 、朱蔚萍 、杨万扣 网址：https://www.icourse163.org/course/SEU-1003771004 递推求和 有数列 2/3、4/5、6/9、10/15、16/25、26/41、42/67…… 从第三项 6/9 开始，分子是前两项分子之和，分母是前一个分数的分子分母之和，求此数列前30项的和（以小数形式输出即可）。 扩展要求：该数列求和的项数可以通过键盘输入（5分！！）。 #include <iostr
【SEU程序设计课笔记】 12 - 2020/11/19 - Write C++ programs - 排序
Teddy van Jerry的博客
11-19 392
排序是一个学习程序绕不开的问题，这里我们来探讨一下排序的方式。 这里使用有系统自带的 sort 函数、冒泡排序（Bubble_sort）、有快速排序（Quick_sort）、快速排序改进版（Quick_sort_pro）、安全快速排序（Quick_sort_pro_safe）。
【SEU程序设计课笔记】 Mooc - Chapter 3 - (EX) - 判断三角形是否存在/基站问题
Teddy van Jerry的博客
11-03 366
Mooc 课程：程序设计基础——发现计算之美 李骏扬 、魏海坤 、仰燕兰 、朱蔚萍 、杨万扣 网址：https://www.icourse163.org/course/SEU-1003771004 判断三角形是否存在 详见我的博客 【C++ 程序】 判断是否构成三角形。 基站问题 有两个基站，A坐标（0，0)，B坐标（100，0） 假设飞行器根据接收到两个基站A、B信号的强度，可以得到距离A、B的距离，Da 和 Db，那么请根据Da 和 Db 计算飞行器的坐标。 Da、Db依靠手工输入 对Da、Db的有
【SEU程序设计课笔记】 17 - 2020/12/10 - Write C++ programs - 分形绘图
Teddy van Jerry的博客
12-10 321
ALL RIGHTS RESERVED © 2020 Teddy van Jerry 欢迎转载，转载请注明出处。 See also Teddy van Jerry 的导航页
【SEU程序设计课笔记】 13 - 2020/11/23 - Write C++ programs - “面向过程”语法汇总/递归/空指针
Teddy van Jerry的博客
11-23 308
基本技能 盲打 全键盘操作 学会找bug：详见我的博客 【笔记】 C++ bug大全。 二进制 8/16/32/64 正整数的表达 补码表达负数 浮点 符号、阶、尾数 浮点的不精确性 数据类型 整数8种 浮点2种 bool 变量定义 语法 ,的用法 初始化问题 const常变量 #define定义字面常量（即字面常量的替换） static静态变量，在函数内，函数结束不收回 全局(global)变量，定义在函数之外 运算符 6大特性（功能、返回值、优先级、结合性、目（元）、左值可修改性）
【SEU程序设计课笔记】 04 - 2020/10/19 - Numbers in the computer - 进制/编码/孪生素数/sin(x)的泰勒展开
Teddy van Jerry的博客
10-19 293
进制 见我的博客 【笔记】 C++中的进制。 编码 整数 小数 注： 表示0则是 全0。 若第一位为1，后面全是0则是-0。（大量电脑将其认作同一个0，一小部分会认错） E全1，F第一个是1，后面全是0，表示非数字(NAN)。 E和F全部是1，则表示无穷大（无穷大不参与运算）。 ALL RIGHTS RESERVED © 2020 Teddy van Jerry 欢迎转载，转载请注明出处。 See also Teddy van Jerry 的导航页 ...
【SEU程序设计课笔记】 19 - 2020/12/17 - Write C++ programs - 类/封装/tvj::string类
Teddy van Jerry的博客
12-22 243
ALL RIGHTS RESERVED © 2020 Teddy van Jerry 欢迎转载，转载请注明出处。 See also Teddy van Jerry 的导航页
【SEU程序设计课笔记】 09 - 2020/11/09 - Discussion - Solution for Boeing 737 MAX / 数据筛选
Teddy van Jerry的博客
11-09 236
背景 Boeing 737 MAX 的软件 MCAS 系统 程序思路 增加传感器（由2提升至4） 写出一个函数data_filter，给出合适的输出结果 程序
【SEU程序设计课笔记】 03 - 2020/10/15 - Write simple programs - 循环+条件/极坐标/百鸡百钱问题/程序优化
Teddy van Jerry的博客
10-15 231
循环+条件 输出一个圆：（要求足够的精度，也就是每行走半步） #include <iostream> using namespace std; int main() { int n; cin >> n; for (int i = -n / 2; i <= n / 2; i++) { for (double j = -n / 2; j <= n / 2; j+=0.5) { if (i * i + j * j <= (n / 2) * (n /
【SEU程序设计课笔记】 Mooc - Chapter 11 - 复数类/注册界面
Teddy van Jerry的博客
12-28 223
Mooc 课程：程序设计基础——发现计算之美 李骏扬 、魏海坤 、仰燕兰 、朱蔚萍 、杨万扣 网址：https://www.icourse163.org/course/SEU-1003771004 复数类 详见我的博客 【C++ 程序】 复数类 （Complex）和 【C++ 程序】 TVJ Complex Calculator (v 2.2) 复数计算器。 注册页面 （题目本来是说登陆界面，但我认为注册界面形容更恰当一些） 下面使用 Qt 制作。 编译环境 Qt 6.0.0 Qt 5 Compati
【SEU程序设计课笔记】 Mooc - Chapter 5 - 质因数分解/存款方案/完全数
Teddy van Jerry的博客
10-22 210
Mooc 课程：程序设计基础——发现计算之美 李骏扬 、魏海坤 、仰燕兰 、朱蔚萍 、杨万扣 网址：https://www.icourse163.org/course/SEU-1003771004 质因数分解 见我的博客 【C++ 程序】 质因数分解。 存款方案 假设银行整存整取存款不同期限的月利率为： 0.63% 期限为1年 0.66% 期限为2年 0.69% 期限为3年 0.75% 期限为5年 0.84% 期限为8年 现在已知某人手上有2000元，要求通过计算选择一种存钱方案，使得这
东南大学硕士论文：SEU-RedSun仿真足球机器人设计与实现
"这篇硕士论文详细介绍了东南大学的SEU-RedSun仿真足球机器人队伍的设计与实现，由许元撰写，专业为控制理论与控制工程，导师为孟正大和谈英姿。该论文主要涉及类人仿真足球机器人在RoboCup 3D仿真组的比赛平台上的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值