数据结构-单链表

已于 2022-12-30 15:47:48 修改
阅读量690 收藏 6
点赞数 4
分类专栏： 数据结构笔记 文章标签： 数据结构 链表 算法
于 2022-10-15 23:06:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46133097/article/details/127342101
版权

title: 链表笔记
date: 2022-10-11 16:24:26
tags:数据结构

单链表

特点

用一组任意的存储单元存储线性表的数据结构（这组数据结构单元可以是连续的，也可以是不连续的）

优点：不要求大片连续空间，改变容量方便

缺点：不可随机存取，要耗费一定空间存放指针

算法描述

typedef struct LNode
{
	ElemType data; 	//节点的数据域
    struct LNode * next;	//节点的指针域
}LNode, *LinkList;	//LinkList为指向结构体LNode的指针类型

这是下面所使用的函数原型

//定义单链表
typedef struct LNode
{
	int data; 	//节点的数据域
	struct LNode* next;	//节点的指针域
}LNode, * LinkList;	//LinkList为指向结构体LNode的指针类型

//初始化链表
void InitList(LinkList &L)
{
	L = (LNode *)malloc(sizeof(LNode));	//生成新节点作为头节点，用头指针L指向头节点
	L->next = NULL;	//头节点指针域置空
}

//创建单链表(头插法)
void CreateList_H(LinList &L, int i)
{//逆序位输入n个元素的值， 建立带头节点的单链表L
	InitList(L);	//先建立一个带头节点的空链表
   int i;
	LNode* p;
    for(i = 0; i < n; ++i)
    {
		p = (LNode*)malloc(sizeof(LNode));	//生成新节点*p
       scanf_s("%d", &p->data);	//输入元素值赋给新节点*p的数据域
   
        //将新节点*p插入到头节点之后
        p->next = L->next;	
        L->next = p;
	}
}

//创建单链表(尾插法)
void GreateList_R(LinkList &L, int n)
{//正序位输入n个元素的值， 建立带头节点的单链表L
	InitList(L);	//先建立一个带头节点的空链表
   LNode* p,*r;
    r = L;	//尾指针r指向头节点
    for(i = 0; i < n; ++i)
    {
		p = (LNode*)malloc(sizeof(LNode));	//生成新节点
       scanf_s("%d", &p->data);	//输入元素值赋给新节点*p的数据域
      	
        //将新节点＊p插入到 ＊r之后
        p->next = NULL;	
        r->next = p;
       
        r = p;	//尾指针r指向新的尾节点＊p
    } 
}

//取值
int GetElem(LinkList L, int i, int &e)
{	//在带头节点的单链表Ｌ中根据序号i获取元素的值，用ｅ返回Ｌ中第ｉ个数据元素的值
	LNode *p;
    int  j = 1;
    p = L -> next; 	//初始化，p指向首元节点，计数器j赋为1
    while(p && j < i)	//顺链域向后查找，直到p为空或p指向第i个元素
    {
		p = p->next;	//p指向下一个节点
        ++j;	//计数器j加1
	}
    if(!p || j > i)		//i的值不合法i > 0或 i <= 0
    {
		printf("取值失败！\n");
		exit(0);
    }
    e = p->data;	//去第i个节点的数据域
    return OK;
}

// 查找
LNode *LocateElem(LinkList L, int e)
{//在带头节点的单链表中查找值为e的元素
    LNode* p;
	p = L->next;	//初始化p指向的首元节点
    while	(p && p->data != e)		//依次顺着链域next向后查找，直到p为空或p所指向节点的数据域等于e
    {
		p = p->next;	//p指向下一个节点
	}
    if (p == NULL)
	{
		printf("查找失败！");
		exit(0);
	}
    return p;	//查找成功返回值为e的节点地址p，查找失败p为NULL
}

//插入
void ListInsert(LinkList& L, int i, int e)
{//在带头节点的单链表L中第ｉ个位置插入值为ｅ的新节点
	LNode *p = L;
	int j = 0;
	while (p && j < i - 1)	//查找第i - 1个节点，p指向该节点
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1)	//i > n + 1或者i < 1
	{
		printf("删除失败！");
		exit(0);
	}
	LNode* s = (LNode*)malloc(sizeof(LNode));	//生成一个新节点＊s
	s->data = e;	//将新节点＊s的数据域置为e
	s->next = p->next;	//将新节点＊s的指针域指向节点a~i~
	p->next = s;	//将节点p的指针域指向新节点＊ｓ
}

//删除
void ListDelete(LinkList& L, int i)
{//在带头节点的单链表L中，删除第i个元素
	LNode *p = L;
	int j = 0;
	while ((p->next) && (j < i - 1))		//查找第i - 1个节点，p指向该节点
	{
		p = p->next;
		++j;
	}
	if (!(p->next) || (j > i - 1))		//i >n 或者i < 1,删除位置不合理
	{
		printf("删除失败！");
		exit(0);
	}
	LNode *q = p->next;	//临时保存被删除节点 的地址在q中，以备释放
	p->next = q->next;		//改变删除节点前驱节点的指针域
	free(q);	//释放节点的空间
}

//遍历链表
void pritfLNode(LinkList L)
{
	LNode* p;
	p = L->next;

	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
}

一. 创建单链表

1. 头插法（前插法）创建单链表 （ 时间复杂度为O(n)）

（输入顺序和线性表中的逻辑顺序相反）

算法步骤

① 创建只有一个头节点的空链表；

②根据带创建链表包括的元素个数n，循环n次执行以下操作：

  • 生成一个新节点 ＊p

  • 输入元素值赋给新节点 ＊p 的数据域

  • 将新节点 ＊p 插入到头节点之后 （先插入后递增指针）

void CreateList_H(LinList &L, int i)
{//逆序位输入n个元素的值， 建立带头节点的单链表L
	InitList(L);	//先建立一个带头节点的空链表
    for(i = 0; i < n; ++i)
    {
		p = new  LNode;		//生成新节点*p
        cin>>p->data;	//输入元素值赋给新节点*p的数据域
   
        //将新节点*p插入到头节点之后
        p->next = L->next;	
        L->next = p;
	}
}

例

int main(void)
{
	int n;

	LNode* L; //声明链表
	InitList(L); // 初始化链表
	printf("请输入链表长度：");
	scanf_s("%d", &n);
	printf("请输入链表数据：");
	CreateList_H(L,n);	//创建单链表（头插法）
	printf("链表：");
	pritfLNode(L);	//打印单链表

	return 0;
	
}

2. 尾插法（后插法）创建单链表（ 时间复杂度为O(n)

（输入顺序和线性表中的逻辑顺序相反）

算法步骤

① 创建只有一个头节点的空链表；

② 尾指针r初始化，指向头节点；

③ 根据创建链表包括的元素个数n，循环n次执行以下操作

  • 生成一个新节点＊p；

  • 输入元素值赋给新节点＊p的数据域

  • 将新节点＊p插入到 ＊r之后

  • 尾指针r指向新的尾节点＊p（先插入后递增指针）

算法描述

void GreateList_R(LinkList &L, int n)
{//正序位输入n个元素的值， 建立带头节点的单链表L
	InitList(L);	//先建立一个带头节点的空链表
    r = L;	//尾指针r指向头节点
    for(i = 0; i < n; ++i)
    {
		p = new LNode;	//生成新节点
        cin>>p->data;	//输入元素值赋给新节点*p的数据域
      	
        //将新节点＊p插入到 ＊r之后
        p->next = NULL;	
        r->next = p;
       
        r = p;	//尾指针r指向新的尾节点＊p
    }
}

例

int main(void)
{
	int n;

	LNode* L; //声明链表
	InitList(L); // 初始化链表
	printf("请输入链表长度：");
	scanf_s("%d", &n);
	printf("请输入链表数据：");
	CreateList_R(L, n); 	//创建单链表(尾插法)
	printf("链表：");
	pritfLNode(L);	//打印单链表

	return 0;
	
}

二. 基本操作

1. 初始化（创建只有一个头节点的空链表）

算法描述

//带头节点
Status InitList(LinkList &L)
{
	L = new LNode;	//生成新节点作为头节点，用头指针L指向头节点
    L->next = NULL;	//头节点指针域置空
    return OK;
}

//不带头节点
Status InitList_N(LinkList &L)
{
    L->next = NULL;	//头节点指针域置空
    return OK;
}

例

void InitList(LinkList &L)
{
	L = new LNode;	//生成新节点作为头节点，用头指针L指向头节点
    L->next = NULL;	//头节点指针域置空
}

2.取值（平均时间复杂度为O(n)）

算法步骤

①用指针p指向首元节点，用j做计数器初值赋为1。

②从首元节点开始依次顺着链域next向下访问，只要指向当前节点的指针不为空（NULL），并且没有到达序号为i的节点，则循环执行以下内容：

  • p 指向下一个节点

  • 计数器j加一

③退出循环，如果指针p为空，或者计数器j大于i，说明指定的序号i值不合法（i大于表长或i小于等于0），取值失败返回ERROR；否则取值成功，此时j = i，p指向的节点就是要找的第i个节点，用参数e保存当前节点的数据域，返回OK。

算法描述

Status GetElem(LinkList L, int i, ElemType &e)
{	//在带头节点的单链表Ｌ中根据序号i获取元素的值，用ｅ返回Ｌ中第ｉ个数据元素的值
	 p = L -> next; 	//初始化，p指向首元节点，计数器j赋为1
    j = 1;
    while(p && j < i)	//顺链域向后查找，直到p为空或p指向第i个元素
    {
		p = p->next;	//p指向下一个节点
        ++j;	//计数器j加1
	}
    if(!p || j > i)		//i的值不合法i > 0或 i <= 0
    {
		return ERROR;
    }
    e = p->data;	//去第i个节点的数据域
    return OK;
}

例

int main(void)
{
	int n;	//链表长度
	int e, i;
	LNode* L; //声明链表
	InitList(L); // 初始化链表
	printf("请输入链表长度：");
	scanf_s("%d", &n);
	printf("请输入链表数据：");
	CreateList_R(L, n);
	
	printf("链表：");
	pritfLNode(L); //打印单链表

	printf("\n请输入要取值的元素序号：");
	scanf_s("%d", &i);

	e = GetElem(L, i, e);	//取值
	printf("取值结果：%d", e);	

	return 0;
}

3. 查找（平均时间复杂度为O(n)）

算法步骤

① 用指针p指向首元节点

② 从首元节点开始依次顺着链域next向下查找，只要指向当前节点的指针p不为空，并且p所指向的数据域不等于给定值e，则循环执行以下操作：p指向下一个节点

③ 返回p。若查找成功，p此时指向节点的地址值，若查找失败，则p的值为NULL

算法描述

LNode *LocateElem(LinkList L, ElemType e)
{//在带头节点的单链表中查找值为e的元素
	p = L->next;	//初始化p指向的首元节点
    while	(p && p->data != e)		//依次顺着链域next向后查找，直到p为空或p所指向节点的数据域等于e
    {
		p = p->next;	//p指向下一个节点
	}
    return p;	//查找成功返回值为e的节点地址p，查找失败p为NULL
}

例

int main(void)
{
	int n;	//链表长度
	int e, i;
	LNode* L; //声明链表
	InitList(L); // 初始化链表
	printf("请输入链表长度：");
	scanf_s("%d", &n);
	printf("请输入链表数据：");
	CreateList_R(L, n);

	printf("链表：");
	pritfLNode(L); //打印单链表

	printf("\n请输入要查找的元素：");
	scanf_s("%d", &e);

	LNode* p = LocateElem(L, e);	//查找
	printf("查找结果：%d", p->data);

	return 0;
}

4. 插入（平均时间复杂度为O(n)）

算法步骤

① 查找节点ai-1 并由指针p指向该节点

② 生成一个新节点＊s

③ 将新节点＊s的数据域置为e

④ 将新节点＊s的指针域指向节点ai

⑤ 将节点p的指针域指向新节点＊ｓ

算法描述

Status ListInsert(LinkList &L, int i ,ElemType e)
{//在带头节点的单链表L中第ｉ个位置插入值为ｅ的新节点
	p = L；
    j = 0;
    while(p && j < i - 1)	//查找第i - 1个节点，p指向该节点
    {
		p = p->next;
        ++j;
	}
    if(!p || j >i - 1)	//i > n + 1或者i < 1
    {
		return ERROR;
	}
    s = new LNode;	//生成一个新节点＊s
    s->data = e;	//将新节点＊s的数据域置为e
    s-next = p->next;	//将新节点＊s的指针域指向节点a~i~
    p->next = s;	//将节点p的指针域指向新节点＊ｓ
    return OK;
}

例

int main(void)
{
	int n;	//链表长度
	int e, i;
	LNode* L; //声明链表
	InitList(L); // 初始化链表
	printf("请输入链表长度：");
	scanf_s("%d", &n);
	printf("请输入链表数据：");
	CreateList_R(L, n);

	printf("链表：");
	pritfLNode(L); //打印单链表

	
	printf("\n请输入要插入的位置：");
	scanf_s("%d", &i);
	printf("\n请输入要插入的元素：");
	scanf_s("%d", &e);
	
	ListInsert(L, i, e);	//插入

	printf("链表：");
	pritfLNode(L); //打印单链表
	return 0;
}

5. 删除（平均时间复杂度为O(n)）

算法步骤

① 查找节点ai-1 并由指针p指向该节点

② 临时保存待删除节点ai 的地址在q中，以备释放

③ 将节点*p的指针域指向ai 的直接后继节点

④ 释放节点ai 的空间

算法描述

Status ListDelete(LinkList &L, int i)
{//在带头节点的单链表L中，删除第i个元素
	p = L;
    j = 0;
    while((p->next) && (j < i - 1))		//查找第i - 1个节点，p指向该节点
    {
		p = p->next;
        ++j;
	}
    if( !(p->next) || (j > i - 1))		//i >n 或者i < 1,删除位置不合理
    {
		return ERROR;
    }
    q = p->next;	//临时保存被删除节点 的地址在q中，以备释放
    p->next = q->next;		//改变删除节点前驱节点的指针域
    delete q;	//释放节点的空间
    return OK;
}

算法描述

int main(void)
{
	int n;	//链表长度
	int i;
	LNode* L; //声明链表
	InitList(L); // 初始化链表
	printf("请输入链表长度：");
	scanf_s("%d", &n);
	printf("请输入链表数据：");
	CreateList_R(L, n);

	printf("链表：");
	pritfLNode(L); //打印单链表

	
	printf("\n请输入要删除的位置：");
	scanf_s("%d", &i);
	
	ListDelete(L, i);	//删除

	printf("链表：");
	pritfLNode(L); //打印单链表
	return 0;
}

												单链表完
wlowrd
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； ...
6-5 用头插法创建单链表 数据结构实训（c/c++编程题）
m0_62351105的博客
05-23 547
LinkList是函数返回的头指针类型。
链表创建（create_list)与遍历（travese_list)
qq_41783512的博客
11-08 5581
链表创建（create_list)与遍历（travese_list) 《数据结构》研究的主要是对数据的存储问题，而链表作为线性存储的一个重要方式，如何通过c语言来实现对链表的操作（下面的代码主要是创建链表以及如何遍历输出）是学习中的一个重点和难点。 代码部分： #include<stdio.h> #include<malloc.h> #include<stdli...
创建带头结点的单链表之头插法和尾插法并求节点数（C+详细注释）
苍之羽
01-11 3884
一、单链表抽象数据类型定义： #include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;time.h&amp;amp;amp;gt; #define OK 1 #define ERROR 0 #define LEN 10 typedef
C语言创建createlist链表,(有关 C语言\C++ 的链表):创建链表的函数 node * create()中的那个*号是什么意......
weixin_29437577的博客
05-24 2643
满意答案Deforlla_BY2013.08.24采纳率：40%等级：12已帮助：19476人(1)node * create()中*表示这个函数的返回值是一个指针，而这个指针指向的类型就是node型。也就是说node * create()表示的是create()函数返回的值类型是指向node型数据的指针。(2)至于空格，纯粹是编程风格的问题，看你习惯怎么写，node * create()...
尾插法，建立带头结点的单链表
qq_44186550的博客
01-05 3203
建立带头结点单链表
数据结构-单链表的操作
最新发布
06-28
数据结构-单链表的操作
数据结构-单链表的学习及代码实现
09-03
【数据结构-单链表的学习及代码实现】 单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据域和一个指向下一个节点的指针。与数组不同，链表中的元素在内存中并不一定是连续存储的，而是通过指针...
C语言-数据结构-单链表完整程序
10-22
本项目提供的“C语言-数据结构-单链表完整程序”应该包含了上述所有功能的实现，通过学习和实践这个项目，你可以深入理解单链表的工作原理，提升C语言编程能力，并巩固数据结构基础。在实际使用中，可以结合具体的...
数据结构-单链表以及对单链表进行的操作
01-08
数据结构-单链表以及对单链表进行的操作
单链表的创建，插入与删除
a1686799661的博客
11-07 791
删除结点，就是将指定的结点从链表中删除，而删除结点中用处最广泛的就是指定位置删除，而指定位置删除，本质上是从表头开始向后找，当遇到满足删除条件的结点，就将其从链表中删除，然后停止，所以，这种方法只能将离表头最近的满足条件的结点删除。所以说，如果链表有多个相同的结点，则要进行多次指定位置删除才可将所有满足条件的结点删除，也就是说每次删除最多只能删掉一个结点，代码如下。头插法，就是将一个新的结点插入表头的后面，使表头的指针域指向新的结点，而新的结点的指针域指向原本头结点指向的结点，代码如下。
Create List
weixin_34292924的博客
10-04 648
1. Create List View Code public static bool CreateList(SPWeb web,string listName,string strDescription,SPListTemplateType type,bool IsOnQuickLaunch) { bool result = fals...
数据结构实验-线性表&&链表操作
qq_62899367的博客
09-24 858
④ 建立两个按值递增有序的单链表，将他们合并成一个按值递减有序的单链表。要求利用原来的存储空间，并且新表中没有相同的元素。理解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。③ 在该顺序表中查找某一元素,查找成功显示查找元素，否则显示查找失败。① 输入一组整型元素序列，使用尾插法建立一个带有头结点的单链表。① 随机产生一组两位数整数，建立线性表的顺序存储结构。④ 在该顺序表中删除或插入指定元素。③ 实现单链表的就地逆置。② 实现该线性表的遍历。② 实现该线性表的遍历。
c语言 链表尾插法实现,用尾插法实现单链表整表创建
weixin_36240211的博客
05-21 2071
昨天我们谈到了头插法，可事实上，我们还是可以不这样干，为什么不把新结点都放到最后呢，这才是排队时的正常思维，所谓的先来后到。我们把每次新结点都插在终端结点的后面，这种算法称之为尾插法。/* 随机产生n个元素的值，建立带表头结点的单链线性表L(尾插法) */void CreateListTail(LinkList *L, int n){LinkList p,r;int i;srand(time(0...
以下函数creat用来建立一个带头结点的单向链表，新产生的结点总是插在链表的末尾。单向链表的头指针作为函数值返回
qq_43615815的博客
05-25 2564
#include<iostream> using namespace std; struct list { char data; list *next; }; list *creat( ) { list *h,*p,*q; char ch; h= new list ; p=q=h; cin>>ch; wh
通过子函数调用创建链表的三种方式
千淘万漉
11-16 8055
创建链表的三种方式： 1.在子函数中定义头结点并为头结点开辟空间，将新的数据结点链接在头结点之后，最后返回头结点指针。 2.在主函数中定义头结点并为头结点开辟空间，此时头结点已经创建好，只需要将头结点指针传给子函数即可，子函数调用结束后长长的链表自然就被创建好了。 3.只在主函数中定义头结点，但并不开辟空间，此时头结点指针还没有被赋予初值，将头指针的的引用传给子函数，子函数为头结点开辟空间之后，自然
数据结构学习（链表）
DXRES的博客
11-05 311
数据结构（链表）学习笔记
链表基本操作
zhoucheng_123的博客
05-18 259
一、创建链表 1.给出链表长度n 需要创建三个节点（必须三个节点，两个不行），头尾新节点 头节点用于返回，尾节点用于连接新节点 Lnode *CreateList(int n) { Lnode *H,*p,*tail; int i; for(i=0;i<n;i++) { p=(Lnode*)malloc(sizeof(Lnode)); scanf("%d",&p->data); if(i==0)H=p;
C语言学习笔记——链表（单链表）
唐学长的博客
02-15 1303
链表是什么呢，其实就是数据的一种存储方式。相对于线性存储，链表是链式存储。它不像数组，每个元素的物理地址是相邻的。链表中每个元素（通常称为节点）的地址是随机的。每当要添加新节点时，链表就要开辟新的空间。即有多少个节点，就开辟多少空间，不会造成空间浪费，这就是链表的优势所在。
-3 数据结构-单链表-TODO：ReverseLinkList 原地逆转单链表, gCC ）
05-12
下面是使用C语言实现的单链表原地逆转的代码： ```c #include #include struct Node { int data; struct Node* next; }; void reverseList(struct Node** head) { struct Node* prev = NULL; struct Node* ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值