1.2 单链表

最新推荐文章于 2022-06-25 18:33:29 发布
最新推荐文章于 2022-06-25 18:33:29 发布
阅读量422 收藏 3
点赞数 1
分类专栏： 数据结构复习 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiSeMn/article/details/119895247
版权

这一章是单链表的算法分析和代码实现。

单链表的结点数据结构：

typedef struct LNode {
	ElemType data;								//数据域
	struct LNode* next;							//指针域
}LNode, *LinkList ;

主要有以下实现功能的函数：

  1. LinkList List_HeadInsert(LinkList& L) 功能：头插法建立单链表（逆向建立单链表）；
    参数：L:链表；
    时间复杂度：O(n);

  2. LinkList List_TailInsert(LinkList& L) 功能：尾插法建立单链表（正向建立单链表）；
    参数：L:链表；
    时间复杂度：O(n)；

  3. LNode* GetElem(LinkList L, int i) 功能：按序号查找结点；
    参数：L:链表 , i:要查找的结点的位置;
    时间复杂度：O(n);

  4. LNode* LocateElem(LinkList L, ElemType e) 功能：按值查找结点（查找第一次出现的）；
    参数：L:链表，e:要查找的结点的值；
    时间复杂度：O(n)；

  5. bool LNodeInsert(LinkList &L,int i,ElemType e) 功能：插入一个结点；
    参数：L:链表 ，i:插入的位置，e:插入结点的值
    时间复杂度：O(n);

  6. bool LNodeDelete(LinkList &L, int i) 功能：删除一个结点；
    参数：L:链表，i:删除结点的位置；
    时间复杂度：O(n);

  7. bool LNodeRevise(LinkList& L, int i, ElemType e) 功能：修改一个结点的值；
    参数：L:链表，i:要修改的结点位置，e:要改成的值；
    时间复杂度：O(n)；

  8. int LinkLength(LinkList L) 功能：求表长；
    参数：L:链表；
    时间复杂度：O(n)；

  9. void PrintList(LinkList L) 功能：输出所有结点的值；
    参数：L:链表；
    时间复杂度：O(n);

可能理解困难的地方：
关于头插法和尾插法：头插法是把每次插入的结点都放到头结点后一位；而尾插法有尾结点指针，每次插入新结点到尾结点后面，然后把尾结点指针移到新插入的结点上。所以用头插法建立的链表和输入的顺序倒序，而尾插法是顺序的。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<iostream>

#define ElemType int

/*--------------------------------------------数据结构部分--------------------------------------------*/
/*单链表的数据结构*/
typedef struct LNode {
	ElemType data;								//数据域
	struct LNode* next;							//指针域
}LNode, *LinkList ;

/*初始化链表*/
void InitList(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));		//创建头结点
	L->next = NULL;								//初始为空链表
}

/*头插法建立单链表（逆向建立单链表）*/
LinkList List_HeadInsert(LinkList& L) {
	LNode* s,* p;								//s是创建的结点的指针
	int x;
	InitList(L);								//初始化链表
	p = L;
	scanf("%d", &x);							//输入结点的值
	while (x!=9999)								//输入9999结束
	{
		s = (LNode*)malloc(sizeof(LNode));		//创建新结点
		//s = new LNode							//c++可以new
		s->data = x;
		s->next = p->next;						//将新结点插入表中，s->next指向头结点外的第一个结点
		p->next = s;
		scanf("%d", &x);
	}
	return L;
}

/*尾插法建立单链表（正向建立单链表）*/
LinkList List_TailInsert(LinkList& L) {
	int x;
	InitList(L);
	LNode* s, * r = L;						//r为表尾指针
	scanf("%d", &x);
	while (x!=9999)
	{
		s = new LNode;
		s->data = x;
		r->next = s;						//把新结点s添加到表尾r
		r = s;								//r指向新的表尾结点
		scanf("%d", &x);
	}
	r->next = NULL;							//尾结点指针置空
	return L;
}

/*按序号查找结点*/
LNode* GetElem(LinkList L, int i) {
	int j = 1;								//计数，初始为1
	LNode* p = L->next;						//头结点赋值给p
	if (i == 0)								//若i == 0 则返回头结点
		return L;							
	if (i < 1)								//若i无效则返回NULL
		return NULL;
	while (p && j<i)						//从第一个结点开始找，找到第i个结点
	{										//在p == NULL(表遍历结束)或j == i(已找到第i个结点)时跳出循环
		p = p->next;
		j++;
	}
	return p;								//返回第i个结点的指针，若i大于表长返回NULL
}

/*按值查找结点*/
LNode* LocateElem(LinkList L, ElemType e) {
	LNode* p = L->next;
	while (p != NULL && p->data != e)		//从第1个结点开始查找data为e的结点
	{
		p = p->next;						//移动结点指针
	}
	return p;								//找到后返回该节点的指针，否则返回NULL
}

/*插入结点*/
bool LNodeInsert(LinkList &L,int i,ElemType e) {
	LNode* s;
	LinkList p = L;
	p = GetElem(L, i - 1);					//查找插入位置的前驱结点
	if (!p)
		return false;
	s = new LNode;
	s->data = e;
	s->next = p->next;						//s->next指向原来p的下一个结点
	p->next = s;							//p->next指向新增的s结点
	return true;
}

/*删除结点*/
bool LNodeDelete(LinkList &L, int i) {
	LNode* q;
	LinkList p = L;
	p = GetElem(L, i - 1);					//查找删除位置的前驱结点
	if (!p)									//未找到第i个位置的前驱结点，返回false
		return false;
	q = p->next;							//q指向被删除结点
	if (!q)									//边界判断：第i个位置有前驱结点，但是不存在第i个位置的结点，返回false
		return false;		
	p->next = q->next;						//将*q结点从链中断开
	free(q);								//释放结点的存储空间
	return true;
}

/*求表长*/
int LinkLength(LinkList L) {
	LNode* p = L->next;						//头节点不存放数据，不算长度
	int sum = 0;
	while (p)
	{
		p = p->next;						//移动结点指针
		sum++;
	}
	return sum;								//返回表长
}

/*修改节点*/
bool LNodeRevise(LinkList& L, int i, ElemType e) {
	LinkList p = L;
	p = GetElem(L, i);						//拿到要修改的结点
	if (!p || i == 0)						//结点不能为空，不能修改头结点
		return false;
	p->data = e;							//修改结点的值
	return true;
}

/*--------------------------------------------下面是功能函数--------------------------------------------*/
/*插入结点的功能*/
void Insert(LinkList& L) {
	int location;
	ElemType elem;
	printf("输入要插入的元素：");
	scanf("%d", &elem);
	printf("要插入的位置：");
	scanf("%d", &location);
	if (LNodeInsert(L, location, elem))
		printf("插入成功\n");
	else
		printf("插入失败\n");
}

/*删除结点的功能*/
void Delete(LinkList& L) {
	int location;
	printf("输入要删除的元素的位置：");
	scanf("%d", &location);
	if (LNodeDelete(L, location))
		printf("删除成功\n");
	else
		printf("删除失败\n");
}

/*修改结点的功能*/
void Revise(LinkList& L) {
	int i;
	ElemType e;
	printf("输入要修改的位置：");
	scanf("%d", &i);
	printf("修改为：");
	scanf("%d", &e);
	if (LNodeRevise(L, i, e))
		printf("修改成功\n");
	else
		printf("修改失败\n");
}

void Search(LinkList L) {
	int searchChoice;
	printf("（1）按位查找\n");
	printf("（2）按值查找\n");
	printf("选择查找功能：\n");
	scanf("%d", &searchChoice);
	int i;
	ElemType e;
	LNode* p;
	switch (searchChoice)
	{
		case(1):
			printf("输入要查找的节点位置：");
			scanf("%d", &i);
			p = GetElem(L, i);
			if (p && i != 0)					//查找的结点不能为空，也不能查找头结点的值
				printf("第%d个结点的值为%d\n", i, p->data);
			else
				printf("查找失败\n");
			break;
		case(2):
			printf("输入要查找的结点的值：");
			scanf("%d", &e);
			p = LocateElem(L, e);
			if (p)
				printf("找到该元素,查找成功\n");
			else
				printf("找不到该元素,查找失败\n");
			break;
		default:
			break;
	}
}

void PrintList(LinkList L) {
	LinkList p = L->next;					 //头结点无数据不输出
	if (!p)
		printf("表空\n");
	else {
		printf("链表数据：\n");
		while (p)
		{
			printf("%d  ", p->data);
			p = p->next;
		}
		printf("\n共%d个元素\n", LinkLength(L));
	}
}

void menu() {
	printf("\n\n");
	printf("----------①前插法建立链表----------\n");
	printf("----------②后插法建立链表----------\n");
	printf("----------③   插入结点   ----------\n");
	printf("----------④   删除结点   ----------\n");
	printf("----------⑤   修改结点   ----------\n");
	printf("----------⑥   查找结点   ----------\n");
	printf("----------⑦    打印表    ----------\n");
	printf("按“0”退出\n");
	printf("\n\n");
}

int main() {
	LinkList L;
	int choice;
	do
	{
		menu();
		scanf("%d", &choice);
		switch (choice)
		{
			case(1):
				printf("输入每个元素的值（输入9999停止建表）\n");
				List_HeadInsert(L);
				break;
			case(2):
				printf("输入每个元素的值（输入9999停止建表）\n");
				List_TailInsert(L);
				break;
			case(3):
				Insert(L);
				break;
			case(4):
				Delete(L);
				break;
			case(5):
				Revise(L);
				break;
			case(6):
				Search(L);
				break;
			case(7):
				PrintList(L);
				break;
			default:
				break;
		}
	} while (choice!=0);
	return 0;
}
LiSeMn
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的相关操作
04-22
单链表的相关操作 1.1:... 1.2:单链表删除指定位置的元素(删除某个元素) 1.3:单链表打印 1.4:单链表的反转 1.5:单链表找出倒数第k个节点的元素 1.6:从尾到头打印一个单链表 1.7:找出单链表中中间节点的值
数据结构-（有头结点）单链表的基本操作实现----------随笔记录（2）
yaoyao_ju的博客
04-05 1929
单链表的基本操作的实现
单链表基本操作函数
Antler_的博客
11-25 409
/*************************************************************************************/ /* 单链表基本操作函数 /*-------------------------------------------------------------------------------------------------...
单链表笔记
Lzylijn的博客
07-10 163
单链表 代码定义 typedef struct LNode { ElemType data; //值域 struct LNode *next; //定义域 }LNode,*LinkList; ​ //等价于 struct LNode{ ElemType data; struct LNode *next; }; typedef struct LNode LNode; typedef struct LNode *LinkList; //要表示一个单...
数据结构—单链表
qq_43558806的博客
07-18 345
#include <bits/stdc++.h> using namespace std; //定义单链表 typedef struct LNode //定义单链表节点类型,typedef意思是重命名 { int data;//每个节点存放一个数据元素 struct LNode *next;//指针指向下一个节点 } LNode,*LinkList; //LNode *强调返回的是一个节点，LinkList强调这是一个单链表 //初始化单链表(不带头结点），目的是清楚可能留下来
数据结构第二章（单链表部分）学习笔记
qq_62175345的博客
04-05 4078
线性表---单链表部分 1、知识承接 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式来表示。但效率低插入和删除操作需要移动大量的元素。临时扩大存储空间有困难，存储分配只能预先进行必须占用地址连续的内存空间 . 链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起数据元素之间的逻辑关系，因此插入和删除操作不需要移动大量的元素，只需要修改指针，但也会失去顺序表可以随机存取的优点。 单链表 链表： 通过一组任意的
数据结构实验1.2：带表头结点单链表的相关操作.doc
10-29
数据结构实验报告
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
1.实验目的及要求 1.1实验目的： （1）掌握线性表的顺序存储结构； （2）验证单链表及其...1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、删除、查找等基本操作。
python算法与数据结构之单链表的实现代码
09-19
#### 1.2 链表的分类 链表可以根据其链接方式的不同分为几种类型： - **单链表**：每个节点仅包含一个指向下一个节点的指针。 - **双链表**：每个节点包含两个指针，一个指向前一个节点，另一个指向后一个节点。 - *...
详解go语言单链表及其常用方法的实现
01-21
1.2、结点 结点(node) 数据域 => 存储元素信息 指针域 => 存储结点的直接后继，也称作指针或链 首元结点 是指链表中存储的第一个数据元素的结点 头结点 是在首元结点之前附设的一个结点，其指针域指向首元结点(非...
数据结构-单链表的查找
qq_50104963的博客
06-25 656
数据结构-单链表的查找
数据结构 链表 c++
weixin_50557468的博客
03-01 378
线性表的链式表示和实现 单链表（带头节点）： typedef struct LNode { Elemtype data; struct LNode* next; }LNode, *LinkList; bool InitList(LinkList& L) { L = new LNode; if (L == NULL)return false; else L->next = NULL; return true; }//创建空表 void DestroyList(LinkList&a
初学数据结构——单链表的基本操作
薛铁钢的博客
06-14 632
#include <iostream> #include <iomanip> #include <string> #include <cstdlib> #include <math.h> #define MAXSIZE 100 #define OK 1 #define ERROR 0 typedef int Status; using namespace std; //定义单链表的存储结构 typedef struct LNode {
单链表的基本操作（完整代码）
热门推荐
weixin_44195690的博客
08-05 1万+
函数说明????： LinkList List_HeadInsert(LinkList& L)：用头插法建立单链表 LinkList List_TailInsert(LinkList& L)：用尾插法建立单链表 LNode * GetElem(LinkList L, int i):按照序号查找结点值 LNode * LocateElem(LinkList L,int i) ：按值查找表结点 bool InsetElem(LinkList& L, int i, int e) :插入
单链表操作实现getelem_【数据结构】单链表的基本操作（C语言）
weixin_31599065的博客
01-01 4962
线性表的链式存储又称为单链表通过一组任意的存储单元来存储线性表中的数据元素（数据元素存储的位置地址可能连续也可能不连续）通过指针连接不相邻的地址，实现线性逻辑关系单链表的定义 L=(,, , ........)每个结点不仅保存该结点的数据元素data，还保存指向下一数据元素位置的指针nexttypedef struct LNode { ElemType data; struct LNode...
线性表之链式表示
Soloversion的博客
12-17 551
一、 线性表之链式存储1. 单链表1.1 单链表的定义1.2 单链表的特点1.3 单链表结点类型描述1.4 单链表上基本操作的实现1.4.1 头插法创建单链表实现思路实现代码1.4.2 尾插法创建单链表实现思路实现代码1.4.3 按值查找结点实现思路实现代码1.4.4 插入结点实现思路实现代码1.4.5 删除结点实现思路实现代码2. 双链表2.1 双链表与单链表的区别2.2 双链表的构成2.3 双链表结点类型描述2.4 双链表的基本操作实现2.4.1 双链表的创建实现代码2.4.2 双链表的按位序删除实现代
c语言单链表的查找,单链表的查找、建立操作（C语言）
weixin_39549899的博客
05-20 3326
一、单链表的查找(带头结点)(一)按位查找GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。//按位查找，返回第i个元素(带头结点)LNode * GetElem(LinkList L, int i){if(i<0)return NULL;LNode *p;//指针p指向当前扫描到的结点int j=0;//当前p指向的是第几个结点p = L;//L指向头结点，头结点是第...
链表知识总结及代码实现
m0_63330233的博客
10-24 2761
目录 头指针、头结点和首元结点的概念 链表的概念 链表的特性 有关链表的三个讨论 了解顺序表前首先应该了解结点等知识，下面来依次了解相关知识： 头指针、头结点和首元结点的概念 头指针: 是指向链表中第一个结点的指针 首元结点: 是指链表中存储第一个数据元素的结点 头结点: 是在链表的首元结点之前附设的一个结点; 链表的概念 定义：链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素...
【数据结构】链表的基本操作
m0_53171456的博客
03-11 8321
规划 /* 链表的基本操作 */ #include<iostream> #include<algorithm> #define ElemType int using namespace std; typedef struct LNode{ ElemType data; //数据域 LNode *next; //指针域 } *LinkList; //链表的初始化 void IniteList(LinkList &L){ L = new LNode; //创建头结点
1.以函数形式实现单链表的建立、插入、删除、查找运算的思路结构。 2.以函数形式实现循环单链表的建立、插入、删除、查找运算的思路结构。
最新发布
04-06
1. 单链表的建立、插入、删除、查找运算思路结构： 定义单链表节点结构体： ``` struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ``` 1.1 单链表的建立 ``` ListNode* createList(vector<int>& nums) { ListNode* head = new ListNode(0); ListNode* cur = head; for (int i = 0; i < nums.size(); i++) { ListNode* newNode = new ListNode(nums[i]); cur->next = newNode; cur = newNode; } return head->next; } ``` 1.2 单链表的插入 ``` void insertNode(ListNode* head, int val) { ListNode* newNode = new ListNode(val); newNode->next = head->next; head->next = newNode; } ``` 1.3 单链表的删除 ``` void deleteNode(ListNode* head, int val) { ListNode* cur = head; while (cur->next != NULL) { if (cur->next->val == val) { ListNode* temp = cur->next; cur->next = temp->next; delete temp; break; } cur = cur->next; } } ``` 1.4 单链表的查找 ``` ListNode* searchNode(ListNode* head, int val) { ListNode* cur = head->next; while (cur != NULL) { if (cur->val == val) { return cur; } cur = cur->next; } return NULL; } ``` 2. 循环单链表的建立、插入、删除、查找运算思路结构： 定义循环单链表节点结构体： ``` struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ``` 2.1 循环单链表的建立 ``` ListNode* createList(vector<int>& nums) { ListNode* head = new ListNode(0); ListNode* cur = head; for (int i = 0; i < nums.size(); i++) { ListNode* newNode = new ListNode(nums[i]); cur->next = newNode; cur = newNode; } cur->next = head; return head->next; } ``` 2.2 循环单链表的插入 ``` void insertNode(ListNode* head, int val) { ListNode* newNode = new ListNode(val); ListNode* cur = head->next; while (cur->next != head) { cur = cur->next; } newNode->next = head; cur->next = newNode; head = newNode; } ``` 2.3 循环单链表的删除 ``` void deleteNode(ListNode* head, int val) { ListNode* cur = head; while (cur->next != head) { if (cur->next->val == val) { ListNode* temp = cur->next; cur->next = temp->next; delete temp; break; } cur = cur->next; } } ``` 2.4 循环单链表的查找 ``` ListNode* searchNode(ListNode* head, int val) { ListNode* cur = head->next; while (cur != head) { if (cur->val == val) { return cur; } cur = cur->next; } return NULL; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值