单链表基本内容回顾_第四周

已于 2023-04-06 16:43:24 修改
阅读量325 收藏
点赞数
分类专栏： 数据结构和算法设计 文章标签： c++ 数据结构
于 2022-03-18 20:39:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47830158/article/details/123583474
版权

目录

单链表内容回顾

已经到大三下学期，有必要对基本数据结构和一些基本算法进行回顾和复习，每周更新，包括基本数据结构以及一些基本算法，这里使用C++语言实现较多，在时间有空余的情况下会更新 Java 实现基本的数据结构和算法。
这里每实现一个函数都会进行一个测试，测试的代码包括已经实现的全部功能，因此文章可能会比较繁琐，文章仅供参考，如有错误，欢迎批评指教。
文章 PDF 链接：

「单链表内容回顾.pdf」https://www.aliyundrive.com/s/vn3XUQwMG7p
点击链接保存，或者复制本段内容，打开「阿里云盘」APP ，无需下载极速在线查看，视频原画倍速播放。

单链表的定义和表示

线性表链式存储结构的特点是：用一组任意的存储单元存储线表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素 a i a_i ai​ 与其直接后继数据元素 a i + 1 a_i+1 ai​+1 之间的逻辑关系，对数据元素 a i a_i ai​ 来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。这两部分信息组成数据元素 a i ​ a_i​ ai​​ 的存储映像，称为结点（node）。

单链表：由于链表的每个结点中只包含一个指针域，故称为线性链表或单链表

单链表特点：

  • 包括两个域：数据域（data），指针域（node）
  • 指针域中存储的信息称为指针或链，存储直接后继
  • n个结点链结成一个链表

单链表图解

结点的实现

关于结点的实现代码如下：

typedef struct LNode
{
	// 这里数据域使用 int 型, 这里使用了递归定义
	int data;
	LNode *next;
}LNode, *LinkList;

说明：

  • 这里对同一结构体指针类型起了两个名称，LinkList 与 * LNode，两者本质等价。习惯上用 LinkList 定义单链表，强调定义的是某个单链表的头指针；用 LNode * 定义指向单链表中任意结点的指针变量。
  • 区分指针变量和结点变量两个不同的概念，若定义 LinkList p 或 LNode *p，则 p 为指向某结点的指针变量，表示结点的地址；而 * p 为对应的结点变量，表示该节点的名称。

头插法创建单链表

头插法又称为前插法，是通过将新结点逐个插入链表的头部（头结点）之后来创建链表，每次申请一个新节点，读入相应的数据元素值，然后将新节点插入到头结点之后。

使用头插法创建单链表时，注意是逆序的。

头插法创建单链表

代码实现：

/**
 * 使用头插法创建单链表，注意是逆置创建
 * 
 * @param &L 指向头结点的头指针
 * @param n 表示插入结点的个数
 * 
 * */
void createHead(LinkList &L, int n)
{
	// 首先将头结点的指针域置空
	L = new LNode;
	L->next = NULL;
	for(int i = 0; i < n; i++)
	{
		// 生成新节点
		LNode *p = new LNode;
		// 输入新节点中的 data
		cin >> p->data;
		// 实现图解 ①
		p->next = L->next;
		// 实现图解 ②
		L->next = p;
	}
}

这里写一个遍历链表的函数进行测试：

/**
 * 遍历单链表
 * 
 * @param &L 表示指向头结点的头指针
 * 
 * */
void getElementAll(LinkList &L)
{
	LNode *p = L->next;
	while(p != NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

测试头插法创建单链表

这里进行测试，以上完整代码如下：

#include <iostream>
using namespace std;

typedef struct LNode
{
	// 这里数据域使用 int 型, 这里使用了递归定义
	int data;
	LNode *next;
}LNode, *LinkList;

/**
 * 使用头插法创建单链表，注意是逆置创建
 * 
 * @param &L 指向头结点的头指针
 * @param n 表示插入结点的个数
 * 
 * */
void createHead(LinkList &L, int n)
{
	// 首先将头结点的指针域置空
	L = new LNode;
	L->next = NULL;
	for(int i = 0; i < n; i++)
	{
		// 生成新节点
		LNode *p = new LNode;
		// 输入新节点中的 data
		cin >> p->data;
		// 实现图解 ①
		p->next = L->next;
		// 实现图解 ②
		L->next = p;
	}
}

/**
 * 遍历单链表
 * 
 * @param &L 表示指向头结点的头指针
 * 
 * */
void getElementAll(LinkList &L)
{
	LNode *p = L->next;
	while(p != NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

int main()
{
	LinkList L;
	cout << "请输入单链表的长度:";
	// n 表示单链表的长度
	int n;
	cin >> n;
	cout << "请输入链表中元素: ";
	// 测试头插法创建单链表
	createHead(L, n);
	// 遍历链表
	getElementAll(L);

	return 0;
}

测试结果如图：
测试头插法创建单链表

尾插法创建单链表

尾插法又称为后插法，是通过将新结点逐个插入到链表的尾部来创建链表。通头插法一样，每次申请一个新节点，读入相应的数据元素值。不同的是，为了使新结点能够插入到表尾，需要增加一个尾指针 r 指向链表的尾结点。

尾插法创建单链表是按正序的

尾插法创建单链表

代码实现：

/**
 * 尾插法创建单链表
 * 
 * @param &L 表示指向头结点的头指针
 * @param n 表示要插入结点个数
 * 
 * */
void createTail(LinkList &L, int n)
{
	L = new LNode;
	L->next = NULL;
	// 首先让指针 r 指向最后一个结点
	LNode *r = L;
	for(int i = 0; i < n; i++)
	{
		LNode *p = new LNode;
		// 实现第 ① 步
		p->next = NULL;
		cin >> p->data;
		// 实现第 ② 步
		r->next = p;
		// 实现第三步
		r = p;
	}
}

测试尾插法创建单链表

这里进行测试，以上完整代码如下：

#include <iostream>
using namespace std;

typedef struct LNode
{
	// 这里数据域使用 int 型, 这里使用了递归定义
	int data;
	LNode *next;
}LNode, *LinkList;

/**
 * 使用头插法创建单链表，注意是逆置创建
 * 
 * @param &L 指向头结点的头指针
 * @param n 表示插入结点的个数
 * 
 * */
void createHead(LinkList &L, int n)
{
	// 首先将头结点的指针域置空
	L = new LNode;
	L->next = NULL;
	for(int i = 0; i < n; i++)
	{
		// 生成新节点
		LNode *p = new LNode;
		// 输入新节点中的 data
		cin >> p->data;
		// 实现图解 ①
		p->next = L->next;
		// 实现图解 ②
		L->next = p;
	}
}

/**
 * 尾插法创建单链表
 * 
 * @param &L 表示指向头结点的头指针
 * @param n 表示要插入结点个数
 * 
 * */
void createTail(LinkList &L, int n)
{
	L = new LNode;
	L->next = NULL;
	// 首先让指针 r 指向最后一个结点
	LNode *r = L;
	for(int i = 0; i < n; i++)
	{
		LNode *p = new LNode;
		// 实现第 ① 步
		p->next = NULL;
		cin >> p->data;
		// 实现第 ② 步
		r->next = p;
		// 实现第三步
		r = p;
	}
}


/**
 * 遍历单链表
 * 
 * @param &L 表示指向头结点的头指针
 * 
 * */
void getElementAll(LinkList &L)
{
	LNode *p = L->next;
	while(p != NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

int main()
{
	LinkList L;
	cout << "请输入单链表的长度:";
	// n 表示单链表的长度
	int n;
	cin >> n;
	cout << "请输入链表中元素: ";
	// 测试头插法创建单链表
	// createHead(L, n);
	
	// 测试尾插法创建单链表
	createTail(L, n);

	// 遍历链表
	getElementAll(L);

	return 0;
}

测试结果如图所示：

测试尾插法创建单链表

单链表的常见操作

取值（根据序号取值）

和顺序表不同，链表中逻辑相邻的结点并没有存储在物理相邻的单元中，这样，根据给定的结点位置序号 i i i ,在链表中获取该结点的值不能像顺序表那样随机访问，而只能从链表的首元结点出发，顺着链域 next 逐个结点向下访问。

取值图解

代码实现：

/**
 * 取值（根据序号取值）
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示输入的序号
 * @param &e 通过序号 i 查找到的值，传递回去
 * 
 * */
void getElement(LinkList &L, int i, int &e)
{
	LNode *p = L;
	int j = 0;
	// 这里 j <= i 的时候表示和数组下标相同，都是从 0 开始
	// 如果写成 j < i，表示从 1 开始
	// 为了符合数组从 0 开始的习惯，这里写成 j <= i
	while((p != NULL) && j <= i)
	{
		p = p->next;
		j++;
	}
	e = p->data;
}
测试根据下标取值：

完整代码如下：

#include <iostream>
using namespace std;

typedef struct LNode
{
	// 这里数据域使用 int 型, 这里使用了递归定义
	int data;
	LNode *next;
}LNode, *LinkList;

/**
 * 使用头插法创建单链表，注意是逆置创建
 * 
 * @param &L 指向头结点的头指针
 * @param n 表示插入结点的个数
 * 
 * */
void createHead(LinkList &L, int n)
{
	// 首先将头结点的指针域置空
	L = new LNode;
	L->next = NULL;
	for(int i = 0; i < n; i++)
	{
		// 生成新节点
		LNode *p = new LNode;
		// 输入新节点中的 data
		cin >> p->data;
		// 实现图解 ①
		p->next = L->next;
		// 实现图解 ②
		L->next = p;
	}
}

/**
 * 尾插法创建单链表
 * 
 * @param &L 表示指向头结点的头指针
 * @param n 表示要插入结点个数
 * 
 * */
void createTail(LinkList &L, int n)
{
	L = new LNode;
	L->next = NULL;
	// 首先让指针 r 指向最后一个结点
	LNode *r = L;
	for(int i = 0; i < n; i++)
	{
		LNode *p = new LNode;
		// 实现第 ① 步
		p->next = NULL;
		cin >> p->data;
		// 实现第 ② 步
		r->next = p;
		// 实现第三步
		r = p;
	}
}


/**
 * 遍历单链表
 * 
 * @param &L 表示指向头结点的头指针
 * 
 * */
void getElementAll(LinkList &L)
{
	LNode *p = L->next;
	while(p != NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

/**
 * 取值（根据序号取值）
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示输入的序号
 * @param &e 通过序号 i 查找到的值，传递回去
 * 
 * */
void getElement(LinkList &L, int i, int &e)
{
	LNode *p = L;
	int j = 0;
	// 这里 j <= i 的时候表示和数组下标相同，都是从 0 开始
	// 如果写成 j < i，表示从 1 开始
	// 为了符合数组从 0 开始的习惯，这里写成 j <= i
	while((p != NULL) && j <= i)
	{
		p = p->next;
		j++;
	}
	e = p->data;
}

int main()
{
	LinkList L;
	cout << "请输入单链表的长度:";
	// n 表示单链表的长度
	int n;
	cin >> n;
	cout << "请输入链表中元素: ";
	// 测试头插法创建单链表
	// createHead(L, n);

	// 测试尾插法创建单链表
	createTail(L, n);

	// 遍历链表
	// getElementAll(L);

	// 测试根据下标获取元素值
	cout << "请输入下标:";
	int i, e;
	cin >> i;
	getElement(L, i, e);
	cout << "下标" << i << "的值为:" << e << endl;

	return 0;
}

测试结果：

测试根据下标取值

查找（根据给定值查找）

链表中按值查找的过程和顺序表类似，从链表的首元结点出发，依次将结点值和给定值 e 进行比较，返回查询结果。

根据值查找图解

代码实现：

/**
 * 根据给定值查找结点
 * 
 * @param L 表示指向头结点的头指针
 * @param e 表示给定值
 * @return 返回值是结点的地址，如果不存在返回 NULL
 * 
 * */
LNode *LocationElement(LinkList L, int e)
{
	// 首先 p 指向首元结点
	LNode *p = L->next;
	while(p)
	{
		if(p->data == e)
		{
			// 查找成功，返回地址
			return p;
		}
		p = p->next;
	}
	// 查找失败，返回NULL，此时 p == NULL;
	return p;
}
测试根据给定值查找：

完整代码如下：

#include <iostream>
using namespace std;

typedef struct LNode
{
	// 这里数据域使用 int 型, 这里使用了递归定义
	int data;
	LNode *next;
}LNode, *LinkList;

/**
 * 使用头插法创建单链表，注意是逆置创建
 * 
 * @param &L 指向头结点的头指针
 * @param n 表示插入结点的个数
 * 
 * */
void createHead(LinkList &L, int n)
{
	// 首先将头结点的指针域置空
	L = new LNode;
	L->next = NULL;
	for(int i = 0; i < n; i++)
	{
		// 生成新节点
		LNode *p = new LNode;
		// 输入新节点中的 data
		cin >> p->data;
		// 实现图解 ①
		p->next = L->next;
		// 实现图解 ②
		L->next = p;
	}
}

/**
 * 尾插法创建单链表
 * 
 * @param &L 表示指向头结点的头指针
 * @param n 表示要插入结点个数
 * 
 * */
void createTail(LinkList &L, int n)
{
	L = new LNode;
	L->next = NULL;
	// 首先让指针 r 指向最后一个结点
	LNode *r = L;
	for(int i = 0; i < n; i++)
	{
		LNode *p = new LNode;
		// 实现第 ① 步
		p->next = NULL;
		cin >> p->data;
		// 实现第 ② 步
		r->next = p;
		// 实现第三步
		r = p;
	}
}


/**
 * 遍历单链表
 * 
 * @param &L 表示指向头结点的头指针
 * 
 * */
void getElementAll(LinkList &L)
{
	LNode *p = L->next;
	while(p != NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

/**
 * 取值（根据序号取值）
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示输入的序号
 * @param &e 通过序号 i 查找到的值，传递回去
 * 
 * */
void getElement(LinkList &L, int i, int &e)
{
	LNode *p = L;
	int j = 0;
	// 这里 j <= i 的时候表示和数组下标相同，都是从 0 开始
	// 如果写成 j < i，表示从 1 开始
	// 为了符合数组从 0 开始的习惯，这里写成 j <= i
	while((p != NULL) && j <= i)
	{
		p = p->next;
		j++;
	}
	e = p->data;
}

/**
 * 根据给定值查找结点
 * 
 * @param L 表示指向头结点的头指针
 * @param e 表示给定值
 * @return 返回值是结点的地址，如果不存在返回 NULL
 * 
 * */
LNode *LocationElement(LinkList L, int e)
{
	// 首先 p 指向首元结点
	LNode *p = L->next;
	while(p)
	{
		if(p->data == e)
		{
			// 查找成功，返回地址
			return p;
		}
		p = p->next;
	}
	// 查找失败，返回NULL，此时 p->next == NULL;
	return p;
}

int main()
{
	LinkList L;
	cout << "请输入单链表的长度:";
	// n 表示单链表的长度
	int n;
	cin >> n;
	cout << "请输入链表中元素: ";
	// 测试头插法创建单链表
	// createHead(L, n);

	// 测试尾插法创建单链表
	createTail(L, n);

	// 遍历链表
	// getElementAll(L);

	// 测试根据下标获取元素值
	// cout << "请输入下标:";
	int i, e;
	// cin >> i;
	// getElement(L, i, e);
	// cout << "下标" << i << "的值为:" << e << endl;


	// 测试给定值获取结点
	cout << "请输入值:";
	cin >> e;
	LNode *p = LocationElement(L, e);
	if(p)
	{
		cout << "此结点值为: " << p->data;
	}
	else 
	{
		cout << "此结点不存在!";
	}

	return 0;
}

测试结果：

测试根据给定值获取结点

插入

要在单链表的两个数据元素之间插入一个元素

插入图解

代码实现：

/**
 * 根据下标，在该下标前插入新结点
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示下标，这里下标从 0 开始，和数组一样，便于理解
 * @param e 表示要插入的新结点的 data
 * 
 * */
void insertElement(LinkList &L, int i, int e)
{
	// 首先 r 指向头结点
	LNode *r = L;
	// j 用于定位指向 i 的前一个结点位置
	int j = 0;
	while(j < i)
	{
		r = r->next;
		j++;
	}
	// 创建新节点
	LNode *p = new LNode;
	p->data = e;
	// 实现 ①
	p->next = r->next;
	// 实现 ②
	r->next = p;
}
测试插入

完整代码：

#include <iostream>
using namespace std;

typedef struct LNode
{
	// 这里数据域使用 int 型, 这里使用了递归定义
	int data;
	LNode *next;
}LNode, *LinkList;

/**
 * 使用头插法创建单链表，注意是逆置创建
 * 
 * @param &L 指向头结点的头指针
 * @param n 表示插入结点的个数
 * 
 * */
void createHead(LinkList &L, int n)
{
	// 首先将头结点的指针域置空
	L = new LNode;
	L->next = NULL;
	for(int i = 0; i < n; i++)
	{
		// 生成新节点
		LNode *p = new LNode;
		// 输入新节点中的 data
		cin >> p->data;
		// 实现图解 ①
		p->next = L->next;
		// 实现图解 ②
		L->next = p;
	}
}

/**
 * 尾插法创建单链表
 * 
 * @param &L 表示指向头结点的头指针
 * @param n 表示要插入结点个数
 * 
 * */
void createTail(LinkList &L, int n)
{
	L = new LNode;
	L->next = NULL;
	// 首先让指针 r 指向最后一个结点
	LNode *r = L;
	for(int i = 0; i < n; i++)
	{
		LNode *p = new LNode;
		// 实现第 ① 步
		p->next = NULL;
		cin >> p->data;
		// 实现第 ② 步
		r->next = p;
		// 实现第三步
		r = p;
	}
}


/**
 * 遍历单链表
 * 
 * @param &L 表示指向头结点的头指针
 * 
 * */
void getElementAll(LinkList &L)
{
	LNode *p = L->next;
	while(p != NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

/**
 * 取值（根据序号取值）
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示输入的序号
 * @param &e 通过序号 i 查找到的值，传递回去
 * 
 * */
void getElement(LinkList &L, int i, int &e)
{
	LNode *p = L;
	int j = 0;
	// 这里 j <= i 的时候表示和数组下标相同，都是从 0 开始
	// 如果写成 j < i，表示从 1 开始
	// 为了符合数组从 0 开始的习惯，这里写成 j <= i
	while((p != NULL) && j <= i)
	{
		p = p->next;
		j++;
	}
	e = p->data;
}

/**
 * 根据给定值查找结点
 * 
 * @param L 表示指向头结点的头指针
 * @param e 表示给定值
 * @return 返回值是结点的地址，如果不存在返回 NULL
 * 
 * */
LNode *LocationElement(LinkList L, int e)
{
	// 首先 p 指向首元结点
	LNode *p = L->next;
	while(p)
	{
		if(p->data == e)
		{
			// 查找成功，返回地址
			return p;
		}
		p = p->next;
	}
	// 查找失败，返回NULL，此时 p->next == NULL;
	return p;
}

/**
 * 根据下标，在该下标前插入新结点
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示下标，这里下标从 0 开始，和数组一样，便于理解
 * @param e 表示要插入的新结点的 data
 * 
 * */
void insertElement(LinkList &L, int i, int e)
{
	// 首先 r 指向头结点
	LNode *r = L;
	// j 用于定位指向 i 的前一个结点位置
	int j = 0;
	while(j < i)
	{
		r = r->next;
		j++;
	}
	// 创建新节点
	LNode *p = new LNode;
	p->data = e;
	// 实现 ①
	p->next = r->next;
	// 实现 ②
	r->next = p;
}

int main()
{
	LinkList L;
	cout << "请输入单链表的长度:";
	// n 表示单链表的长度
	int n;
	cin >> n;
	cout << "请输入链表中元素: ";
	// 测试头插法创建单链表
	// createHead(L, n);

	// 测试尾插法创建单链表
	createTail(L, n);

	// 遍历链表
	// getElementAll(L);

	// 测试根据下标获取元素值
	// cout << "请输入下标:";
	int i, e;
	// cin >> i;
	// getElement(L, i, e);
	// cout << "下标" << i << "的值为:" << e << endl;


	// 测试给定值获取结点
	// cout << "请输入值:";
	// cin >> e;
	// LNode *p = LocationElement(L, e);
	// if(p)
	// {
	// 	cout << "此结点值为: " << p->data;
	// }
	// else 
	// {
	// 	cout << "此结点不存在!";
	// }

	// 测试 根据下标插入新结点
	cout << "请输入下标: ";
	cin >> i;
	cout << "请输入被插入结点的值:";
	cin >> e;
	insertElement(L, i, e);
	getElementAll(L);
	
	return 0;
}

测试结果：

测试插入

删除

根据给定下标删除结点

删除结点图解

代码实现：

/**
 * 根据给定下标删除结点
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示下标（下标从 0 开始）
 * 
 * */
void deleteElement(LinkList &L, int i)
{
	LNode *p = L->next;
	int j = 0;
	// 实现 ①
	while(j < i)
	{
		p = p->next;
		j++;
	}
	// 实现 ②
	LNode *q = p->next;
	p->next = q->next;
	// 实现 ③
	delete q;
}
测试删除

完整代码：

#include <iostream>
using namespace std;

typedef struct LNode
{
	// 这里数据域使用 int 型, 这里使用了递归定义
	int data;
	LNode *next;
}LNode, *LinkList;

/**
 * 使用头插法创建单链表，注意是逆置创建
 * 
 * @param &L 指向头结点的头指针
 * @param n 表示插入结点的个数
 * 
 * */
void createHead(LinkList &L, int n)
{
	// 首先将头结点的指针域置空
	L = new LNode;
	L->next = NULL;
	for(int i = 0; i < n; i++)
	{
		// 生成新节点
		LNode *p = new LNode;
		// 输入新节点中的 data
		cin >> p->data;
		// 实现图解 ①
		p->next = L->next;
		// 实现图解 ②
		L->next = p;
	}
}

/**
 * 尾插法创建单链表
 * 
 * @param &L 表示指向头结点的头指针
 * @param n 表示要插入结点个数
 * 
 * */
void createTail(LinkList &L, int n)
{
	L = new LNode;
	L->next = NULL;
	// 首先让指针 r 指向最后一个结点
	LNode *r = L;
	for(int i = 0; i < n; i++)
	{
		LNode *p = new LNode;
		// 实现第 ① 步
		p->next = NULL;
		cin >> p->data;
		// 实现第 ② 步
		r->next = p;
		// 实现第三步
		r = p;
	}
}


/**
 * 遍历单链表
 * 
 * @param &L 表示指向头结点的头指针
 * 
 * */
void getElementAll(LinkList &L)
{
	LNode *p = L->next;
	while(p != NULL)
	{
		cout << p->data << " ";
		p = p->next;
	}
}

/**
 * 取值（根据序号取值）
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示输入的序号
 * @param &e 通过序号 i 查找到的值，传递回去
 * 
 * */
void getElement(LinkList &L, int i, int &e)
{
	LNode *p = L;
	int j = 0;
	// 这里 j <= i 的时候表示和数组下标相同，都是从 0 开始
	// 如果写成 j < i，表示从 1 开始
	// 为了符合数组从 0 开始的习惯，这里写成 j <= i
	while((p != NULL) && j <= i)
	{
		p = p->next;
		j++;
	}
	e = p->data;
}

/**
 * 根据给定值查找结点
 * 
 * @param L 表示指向头结点的头指针
 * @param e 表示给定值
 * @return 返回值是结点的地址，如果不存在返回 NULL
 * 
 * */
LNode *LocationElement(LinkList L, int e)
{
	// 首先 p 指向首元结点
	LNode *p = L->next;
	while(p)
	{
		if(p->data == e)
		{
			// 查找成功，返回地址
			return p;
		}
		p = p->next;
	}
	// 查找失败，返回NULL，此时 p->next == NULL;
	return p;
}

/**
 * 根据下标，在该下标前插入新结点
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示下标，这里下标从 0 开始，和数组一样，便于理解
 * @param e 表示要插入的新结点的 data
 * 
 * */
void insertElement(LinkList &L, int i, int e)
{
	// 首先 r 指向头结点
	LNode *r = L;
	// j 用于定位指向 i 的前一个结点位置
	int j = 0;
	while(j < i)
	{
		r = r->next;
		j++;
	}
	// 创建新节点
	LNode *p = new LNode;
	p->data = e;
	// 实现 ①
	p->next = r->next;
	// 实现 ②
	r->next = p;
}

/**
 * 根据给定下标删除结点
 * 
 * @param &L 表示指向头结点的头指针
 * @param i 表示下标（下标从 0 开始）
 * 
 * */
void deleteElement(LinkList &L, int i)
{
	LNode *p = L->next;
	int j = 0;
	// 实现 ①
	while(j < i)
	{
		p = p->next;
		j++;
	}
	// 实现 ②
	LNode *q = p->next;
	p->next = q->next;
	// 实现 ③
	delete q;
}


int main()
{
	LinkList L;
	cout << "请输入单链表的长度:";
	// n 表示单链表的长度
	int n;
	cin >> n;
	cout << "请输入链表中元素: ";
	// 测试头插法创建单链表
	// createHead(L, n);

	// 测试尾插法创建单链表
	createTail(L, n);

	// 遍历链表
	// getElementAll(L);

	// 测试根据下标获取元素值
	// cout << "请输入下标:";
	int i, e;
	// cin >> i;
	// getElement(L, i, e);
	// cout << "下标" << i << "的值为:" << e << endl;


	// 测试给定值获取结点
	// cout << "请输入值:";
	// cin >> e;
	// LNode *p = LocationElement(L, e);
	// if(p)
	// {
	// 	cout << "此结点值为: " << p->data;
	// }
	// else 
	// {
	// 	cout << "此结点不存在!";
	// }

	// 测试 根据下标插入新结点
	// cout << "请输入下标: ";
	// cin >> i;
	// cout << "请输入被插入结点的值:";
	// cin >> e;
	// insertElement(L, i, e);
	// getElementAll(L);

	// 测试 删除结点
	cout << "请输入下标: ";
	cin >> i;
	deleteElement(L, i);
	getElementAll(L);
	
	return 0;
}

测试结果：

测试删除

大大大菜鸡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线性表的实验_《数据结构》实验二：线性表的实验 JAVA
weixin_42473904的博客
02-13 712
一．.实验目的巩固线性表的数据结构，学会线性表的应用。1.回顾线性表的逻辑结构，线性表的物理存储结构和常见操作。2.学习运用线性表的知识来解决实际问题。3.进一步巩固程序调试方法。4.进一步巩固模板程序设计。二．实验时间准备时间为第2周到第4周，具体集中实验时间为第4周第2次课。2个学时。三．.实验内容1.建立一个N个学生成绩的顺序表，对表进行插入、删除、查找等操作。分别输出结果。要求如下：1)用...
题解 | #武汉工程大学第六届ACM程序设计竞赛（同步赛）#
2301_79125431的博客
04-29 871
各位，如果来了，就来了，别慌了，看命吧， 各位，如果来了，就来了，别慌了，看命吧，慌改变不了什么，还是要打工吃饭的。#铜五铁六真的存在吗？(51062)# #铜五铁六真的存在吗？# 我选铜五必存！#牛客帮帮团来啦！有问必答(50227) #牛客帮帮团来啦！有问必答# 25届双非java后端求助。请问各位大佬，现在双非后端很难进大厂，所以杭州亚信科技 26号做的笔试，有牛友收到面试通知了吗本菜鸟双非零实习零竞
2019春第十二周作业
weixin_33933118的博客
05-16 99
一、本周作业 本周作业头 这个作业属于哪个教程 C语言程序设计Ⅱ 这个作业要求在哪里 https://edu.cnblogs.com/campus/zswxy/software-engineering-class1-2018/homework/3235 我在这个课程的目标是 二级指针、指针数组、指针与函数的关系、单向链表的概念和操作 这个作业在哪个具体方面帮助我实现目标 题目中对...
C++程序设计-第15周 数据结构扩展与GUI开发体验
迂者-贺利坚的专栏
06-04 4061
课程首页地址：http://blog.csdn.net/sxhelijian/article/details/7910565【目的】1. 体验用面向对象的方法操作数组和动态链表2. 体验窗口程序的实现第一部分 引言　　大学中的学习死守着课本非常的没有劲。我不是说课本和课堂没用，而是说在课内的学习之余要有所拓展和扩充。大学的课程（和课本）成为一个体系，受到各种因素的制约，势必会形成一个框框，所涉及的
5万字100图再回顾操作系统
RawChen · Blog
06-25 363
大学学了一学期的操作系统（Operating System），回想还记得几个系统调度算法、页面置换算法啥的，还是很多知识点不太清楚。学习其他相关的软件专业知识时导致了基础知识的脱节，下面就再次通过5万字和100张图清楚的讲一遍操作系统（Operating System），看之前请先认真思考下你为什么要看这篇文章以及为什么要学习操作系统。 搞清楚几个问题 首先你要搞明白你学习操作系统的目的是什么？操作系统的重要性如何？学习操作系统会给我带来什么？下面我会从这几个方面为你回答下。 操作系统也是一种软件，但是操作
Algorithms, Princeton, Coursera课程整理与回顾
weixin_34174322的博客
05-25 197
Princeton的算法课是目前为止我上过的最酣畅淋漓的一门课，得师如此夫复何求，在自己的记忆彻底模糊前，愿对这其中一些印象深刻的点做一次完整的整理和回顾，以表敬意。 注：这是一篇更关注个人努力与完成任务项目过程相关的文章，内容集中于课程背后值得提到的部分，不会介绍课程基本信息及学习时必读的设定要求等部分，敬请谅解。在学习一门课程的时候考...
第7期 Datawhale 组队学习计划
weixin_34259559的博客
05-06 305
马上就要开始啦 这次共组织15个组队学习 涵盖了AI领域从理论知识到动手实践的内容 按照下面给出的最完备学习路线分类 难度系数分为低、中、高三档 可以按照需要参加 - 学习路线 - 基础知识 01 统计学 课程设计：王佳鑫、许辉 组队学习说明：学习内容涵盖统计学中所有的主要知识，并对其分部分进行梳理总结。 任务路线：根据所学习内容进行 （1）统计学基本知识、二项及泊松分布、大数定律、正态分...
【数据结构之树和二叉树】暴肝一周，详细如斯
apple_51673523的博客
12-02 4117
前言 终于到了这一块了！到这里数据结构的难度才会慢慢体现出来，与此相比之前的都是小儿科，树的内容会用到栈与队列，线性表相关的知识如果你还不清楚，可以先去看看，点击蓝色字体即可进入相关内容。 数据结构之线性表 数据结构之栈和队列 同时也欢迎大家关注本专栏，持续更新中！ 目录前言初识树二叉树树与森林 初识树 二叉树 树与森林 .........
心得体会
热门推荐
阳光岛主
07-24 1万+
今天下午，刚在百度HR网站上看到了自己“面试未通过”的字样，终于等来了面试最终的结果看到结果后，没有感伤，也没有喜悦，而是坦然待之。生活何尝不是一次次的在面试着自己呢不管结果好坏，都将是对我曾经努力过程的一种评判，或肯定、或否定、或鼓舞、或激励但到百度大厦一面、二面的经历，对面试
链表的基本操作链表的基本操作
06-22
3. **掌握单链表的基本操作**：包括但不限于查找、插入、删除等操作，同时理解这些操作对单链表存取特性的影响。 #### 实验内容 1. **创建单链表**：初始化一个包含10个数据元素的单链表。 2. **插入数据元素**：...
单链表的排序，c源代码
04-05
### 单链表排序C语言实现 #### 一、引言 在计算机科学中，链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据元素和指向下一个节点的指针。对于链表的排序操作是算法设计中的一个重要主题。本文将...
数据结构（c语言）（第2版）ppt.zip
11-19
第4章“串、数组和广义表”进一步扩展了线性结构的概念。字符串是字符的序列，数组是一组相同类型的数据集合，而广义表则是更通用的列表形式，可以包含不同类型的数据。 第5章“树和二叉树”介绍了非线性数据结构。...
SHU大一ALP第一学期大一期末作业10 网购系统
10-07
设计一个简易的网购系统，利用单链表来处理买家信息、卖家信息与商品信息，要求实现如下功能。 (1)初始化菜单 程序开始运行后显示菜单，要求菜单能完全展示本系统的功能：提示三种用户身份(买家、卖家、管理员),...
李春葆数据结构教程（第三版),上机源程序
03-02
《李春葆数据结构教程（第三版)》是学习数据结构的重要教材，它涵盖了数据结构的基本概念、原理和实现方法。本教程不仅提供了理论知识，还强调了实践应用，通过课后上机习题帮助学生深入理解并掌握数据结构。在...
【C++】输入输出
2401_83948390的博客
08-02 354
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
3.C_Demo_最大公约数、最小公倍数
最新发布
Fresh_man111的博客
08-03 138
假设两个数字a和b，求两个数字相除的余数c=a%b，如果余数为0，则b为最大公约数。如果b不为零，a=b,b=c,继续循环计算。两个数的最小公倍数数等于两个数的乘积除以两个数的最大公约数。即：x，y的最小公倍数 min(公倍数)=x*y÷max(公约数)参数a，b：传入的两个数值，两个数都不能为0。参数a，b：传入的两个数值，不能全为0。返回值：0代表错误，正常返回最大公约数。返回值：0代表错误，正常返回最小公倍数。功能：求a，b最大公约数。功能：求a，b最小公倍数。
c语言之函数调用约定
qq_45583706的博客
08-02 488
在C和C++编程中，函数调用约定（Calling Convention）定义了函数参数如何传递、由谁负责清理栈（如果有的话）、以及返回值如何传递等规则。不同的平台和编译器可能采用不同的调用约定。不同的调用约定适用于不同的场景和需求。了解这些调用约定的特点和适用场景有助于编写更高效、更可移植的代码。在选择调用约定时，需要考虑目标平台、编译器、以及与其他代码或库的兼容性。
类和对象(上) - c++
2301_81336748的博客
08-01 686
class。
科院数据结构期末考试重点回顾：填空、判断、选择与算法题解析
- 完全二叉树的特点：第5层有5个结点，共有20个结点，度为1的结点1个（根节点），度为0的结点10个（叶节点）。 6. **二叉树高度**： - 二叉树的高度与其形状有关，完全二叉树高度最小。对n个结点的完全二叉树，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值