【编程与算法基础】数据结构——线性表之单链表

已于 2023-05-12 19:22:30 修改
阅读量160 收藏 1
点赞数 2
分类专栏： 编程与算法 文章标签： c语言 链表 数据结构 开发语言 算法
于 2023-03-31 22:03:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52158753/article/details/129858629
版权

文章目录

单链表

观看这里的uu建议先看顺序表
线性表之顺序表点击这里

一、前言

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列等。
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
链表是典型的线性表之一，以链式结构的形式存储。
链表又被分为单链表和双链表。
本篇仅对单链表详细说明。

二、单链表

1·单链表的概念及其结构

概念：单链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针单向链接次序实现的。
逻辑结构图如下：
在这里插入图片描述
根据单链表的逻辑结构可以想到单链表这种结构体中包含存入的数据和指向下一个结构体的结构体指针。

物理结构图如下：
在这里插入图片描述
单链表需要增加空间存储新数据时只需要动态申请一个结构体大小的空间即可。对空间的使用率非常高。完美解决了顺序表频繁扩容浪费空间的缺点。

2·单链表的分类

实际中要实现的单链表的结构非常多样，以下情况组合起来就有很多种单链表结构：

  • 不带头、带头非循环单链表
    在这里插入图片描述

  • 单链表、循环单链表
    在这里插入图片描述

  • 无头单向非循环链表
    在这里插入图片描述
    虽然有这么多的单链表结构，但是在实际中最常用的是无头单向非循环链表
    无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。

单链表是否带头的区别：当不带头要改变头指针的指向时，那么就需要传二级指针形参来改变头指针的指向；当带头时只需要传一级指针，操作头节点来处理后续数据的操作即可。
单链表是否循环的区别：当非循环时头节点与尾节点没有逻辑上的联系，某些操作会不方便；当循环时头节点与尾节点有逻辑上的联系，某些操作会方便许多。

说明：
单链表无论带头或不带头、循环或非循环的实现都大同小异，这里只详细说明不带头+单向+非循环链表的实现。
是否带头的唯一区别：

3·单链表接口函数

单链表头文件Slist.h的声明如下：

#pragma once
#include  <stdio.h>
#include <stdlib.h>

// 无头+单向+非循环链表增删查改实现
typedef int SLTDateType;

//无头+单向+非循环链表结构体
typedef struct SListNode
{
	//存储的数据
	SLTDateType data;
	//指向下一个结构体数据的结构体指针
	struct SListNode* next;
}SLNode;

// 动态申请一个节点
SLNode* BuySListNode(SLTDateType x);

// 单链表打印
void SListPrint(SLNode* phead);

// 单链表尾插
void SListPushBack(SLNode** pphead, SLTDateType x);

// 单链表的头插
void SListPushFront(SLNode** pphead, SLTDateType x);

// 单链表的尾删
void SListPopBack(SLNode** pphead);

// 单链表头删
void SListPopFront(SLNode** pphead);

// 单链表查找
SLNode* SListFind(SLNode* phead, SLTDateType x);

// 单链表在pos位置之后插入x
void SListInsertAfter(SLNode* pos, SLTDateType x);

// 单链表在pos位置之后删除x
void SListEraseAfter(SLNode* pos);

// 单链表在pos位置插入x
void SListInsert(SLNode** pphead, SLNode* pos, SLTDateType x);

// 单链表删除pos位置的值
void SListErase(SLNode** pphead, SLNode* pos);

//释放链表
void SListDestroy(SLNode** pphead);

三、单链表的实现

说明：以下函数的实现思路在代码注释中已详细解释。

1·申请新节点、打印链表和释放链表

申请新节点函数在Slist.c中如下：

// 动态申请一个节点，返回一个节点首地址
SLNode* BuySListNode(SLTDateType x)
{
	//开辟一个sizeof(SLNode)的新节点
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	//开辟失败则报错且终止程序
	if (newnode == NULL)
	{
		printf("malloc fail");
		exit(-1);
	}
	//开辟成功则进行赋值
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

打印链表函数在Slist.c中如下：

// 单链表打印
/*只需要输出当前指针解引用data后的值，一级指针传参*/
void SListPrint(SLNode* plist)
{
	SLNode* cur = plist;
	/*当当前指针cur不为空时说明还未到尾部，
	此时打印当前数据并将当前的指针cur移动至下一个结构体以此循环*/
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		//cur->next与plist的区别就是plist是首字节的指针
		cur=cur->next;
	}
	printf("NULL");
}

说明：申请节点只要插入节点都会用到，因此申请节点在尾部插入节点、头部插入节点和任意位置插入节点据函数中嵌套使用。

释放链表函数在Slist.c中如下：

//释放链表
void SListDestroy(SLNode** pphead)
{
	SLNode* cur = *pphead;
	while (cur != NULL)
	{
		//保存当前要释放的下一节点的位置
		SLNode* next = cur->next;
		//释放当前节点
		free(cur);
		//转移当前节点
		cur = next;
	}
	*pphead = NULL;
}

以上函数的具体实现情况尾部、头部和任意位置操作时大同小异且比较简单，不做具体说明。

2·尾部插入节点&尾部删除节点

尾部插入节点函数在Slist.c中如下：

// 单链表尾插
/*先申请一个新节点后分两种情况*/
/*1·链表中有数据，此时不需要二级指针的参与，定义一个结构体指针tail，用遍历移动的方式指向尾节点，
用tail指针修改尾节点next的值为新节点的地址，即可将尾节点与新节点链接/

/*2·链表中无数据，此时需要用二级指针传参是因为当链表中无数据时，
单纯的一级指针传参无法改变头指针plist指针的指向，
因此需要用二级指针解引用来修改头指针的指向为新节点的地址*/

//实现单链表尾部插入不是只有这一种方式的函数，这里采取的只是最典型的一种方式
void SListPushBack(SLNode** pphead, SLTDateType x)
{
	//申请一个新节点
	SLNode* newnode = BuySListNode(x);
	//如果传参的节点为空，说明链表中没有数据，那么需要解引用二级指针修改头指针的指向
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	//如果传参的节点不为空，说明链表中有数据，那么就定义一个结构体指针tail
	else
	{
		//1·用遍历移动的方式指向尾节点
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		//2·用tail指针修改尾节点next的值为新节点的地址，即可将尾节点与新节点链接
		tail->next = newnode;
	}
}

时间复杂度为O(N)，效率一般。

尾部删除节点函数在Slist.c中如下：

// 单链表的尾删
/*尾删会遇到三种情况*/
/*1·空链表时尾删，就终止程序并报错*/
/*2·链表中只有1个数据，tail->next->next无法访问，需要特殊处理*/
/*3·链表中有1个以上数据，这是普遍情况*/
void SListPopBack(SLNode** pphead)
{	
	//空链表，就终止程序并报错
	assert(*pphead != NULL);

	//链表中只有1个数据
	if ((*pphead)->next == NULL)
	{
		//1·释放掉头指针指向的空间
		free(*pphead);
		//2·将头指针指向空
		*pphead = NULL;
	}
	//链表中有1个以上数据
	else
	{
		SLNode* tail = *pphead;
		//使用tail->next->next遍历链表，这样既可以释放尾部空间，
		//也可以将尾节点的上一节点的next指向空指针
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}

时间复杂度为O(N)，效率一般。

具体使用方式如下：

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

//尾插尾删
void TestSList1()
{
	//由于链表是指针管理，因此初始化创建一个结构体指针管理即可
	SListNode* plist = NULL;
	//初始化
	//尾部插入节点
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	//打印尾插节点
	SListPrint(plist);
	printf("\n");

	//尾部删除节点
	SListPopBack(&plist);
	SListPopBack(&plist);
	//打印尾删后的节点
	SListPrint(plist);
	printf("\n");
	//继续尾部删除节点
	SListPopBack(&plist);
	SListPopBack(&plist);
	SListPopBack(&plist);
	//打印尾删后的节点
	SListPrint(plist);
	printf("\n");
}

int main()
{
	TestSList1();
	return 0;
}

执行调试结果如下：
1·向尾部添加4个节点，并对相应变量进行监测：
在这里插入图片描述
2·以上面情况为基础，从尾部删除2个节点，并对相应变量进行监测：
在这里插入图片描述
3·以上面情况为基础，再从尾部删除3个节点，并对相应变量进行监测：
在这里插入图片描述

3·头部插入节点&头部删除节点

头部插入节点函数在Slist.c中如下：

// 单链表的头插
void SListPushFront(SLNode** pphead, SLTDateType x)
{
	//申请一个新节点
	SLNode* newnode = BuySListNode(x);
	//无论传参节点是否为空都是同样的操作
	//1·将新节点设为首节点
	newnode->next = *pphead;
	//2·将头指针指向新节点
	*pphead = newnode;
}

时间复杂度为O(1)，基本没有效率损失。

头部删除节点函数在Slist.c中如下：

// 单链表头删
/*头删会遇到两种情况*/
/*1·空链表时头删，就终止程序并报错*/
/*2·链表中有1个以上数据是普遍情况*/
void SListPopFront(SLNode** pphead)
{
	//空链表时头删，就终止程序并报错
	assert(*pphead != NULL);

	//链表中有1个以上数据
	SLNode* fro = *pphead;
	//1·头指针指向下一个字节
	*pphead = (*pphead)->next;
	//2·释放掉头指针指向的空间
	free(fro);
	//3·将指针指向空，以免出现野指针
	fro = NULL;
}

时间复杂度为O(1)，基本没有效率损失。

具体使用方式如下：

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

void TestSList2()
{
	//由于链表是指针管理，因此初始化创建一个结构体指针管理即可
	SListNode* plist = NULL;
	//尾部插入节点
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	//打印尾插节点
	SListPrint(plist);
	printf("\n");
	//头部插入节点
	SListPushFront(&plist, 1);
	SListPushFront(&plist, 2);
	//打印头插节点
	SListPrint(plist);
	printf("\n");

	//头部删除节点
	SListPopFront(&plist);
	SListPopFront(&plist);
	SListPrint(plist);
	printf("\n");
	//继续删除头部节点
	SListPopFront(&plist);
	SListPopFront(&plist);
	//会报错
	SListPopFront(&plist);
}

int main()
{
	TestSList2();
	return 0;
}

执行调试结果如下：
1·在尾部添加2个节点情况下，向头部添加2个节点，并对相应变量进行监测：
在这里插入图片描述
2·以上面情况为基础，从头部删除2个节点，并对相应变量进行监测：
在这里插入图片描述
3·以上面情况为基础，再次从头部删除3个节点，并对相应变量进行监测：
在这里插入图片描述

4·查找节点

查找节点函数在Slist.c中如下：

// 单链表查找
SLNode* SListFind(SLNode* phead, SLTDateType x)
{
	SLNode* cur = phead;
	//遍历链表
	while (cur != NULL)
	{
		//如果找到了，返回该节点
		if (cur->data == x)
		{
			return cur;
		}
		//如果遍历中未找到，向后移动当前节点
		else
		{
			cur = cur->next;
		}
	}
	//遍历结束未找到，就返回空指针
	return NULL;
}

时间复杂度为O(N)，效率一般。

具体使用方式如下：

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

//查找
void TestSList4()
{
	//由于链表是指针管理，因此初始化创建一个结构体指针管理即可
	SListNode* plist = NULL;
	//尾部插入节点
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	//打印尾插节点
	SListPrint(plist);
	printf("\n");
	//头部插入节点
	SListPushFront(&plist, 3);
	SListPushFront(&plist, 4);
	//打印头插节点
	SListPrint(plist);
	printf("\n");

	//查找
	SLNode* pos1 = SListFind(plist, 1);
	printf("pos1->data:%p->%d", pos1, pos1->data);
	printf("\n");
	SLNode* pos2 = SListFind(plist, 3);
	printf("pos2->data:%p->%d", pos2, pos2->data);
	printf("\n");
	//无此数据时查找
	SLNode* pos3 = SListFind(plist, 5);
	printf("pos3->data:%p->%d", pos3, pos3->data);
	printf("\n");
}

int main()
{
	TestSList4();
	return 0;
}

执行调试结果如下：
在数据为4->3->1->2->NULL情况下，查找1、3、5：
在这里插入图片描述

5·任意位置插入节点&任意位置删除节点

这组函数共有两种方式实现
说明：这组函数常与查找函数配合使用，即先找到对应数据，然后在对应数据周围或数据本身处进行操作。

5.1任意位置后插入节点&任意位置后删除节点

任意位置后插入节点函数在Slist.c中如下：

// 单链表适合在pos位置之后插入数据，因为基本没有效率损失
/* 此函数与查找函数配合使用，不存在不合法的插入，
因为只有找到存在的节点才能插入节点*/
//无法添加头部节点
void SListInsertAfter(SLNode* pos, SLTDateType x)
{
	//申请一个节点
	SLNode* newnode = BuySListNode(x);
	//尾插也适用
	/*1·将新节点的next指向pos位置的下一节点*/
	newnode->next = pos->next;
	/*2·再将当前位置的next指向新节点*/
	pos->next = newnode;
}

时间复杂度为O(1)，基本没有效率损失。

删除任意位置后节点函数在Slist.c中如下：

// 单链表删除pos位置后的节点
//无法删除头部节点
//禁止删除尾部节点
void SListEraseAfter(SLNode* pos)
{
	//禁止尾删
	assert(pos->next != NULL);
	//修改指定位置的next指向该指定位置后的第二个节点处
	pos->next = pos->next->next;
	//释放指定位置下一个节点的空间
	free(pos->next);
	pos->next = NULL;
}

时间复杂度为O(1)，基本没有效率损失。

具体使用方式如下：

#include <iostream>
#include  <stdio.h>
#include <stdlib.h>
#include "Slist.h"
#include <assert.h>

//任意位置后插入、任意位置后删除
void TestSList3()
{
	//由于链表是指针管理，因此初始化创建一个结构体指针管理即可
	SListNode* plist = NULL;
	//尾部插入节点
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	//打印尾插节点
	SListPrint(plist);
	printf("\n");

	//在1后插入4
	SLNode* pos1 = SListFind(plist, 1);
	assert(pos1 != NULL);
	SListInsertAfter(pos1, 4);
	//在3后插入5
	SLNode* pos2 = SListFind(plist, 3);
	assert(pos2 != NULL);
	SListInsertAfter(pos2, 5);
	//打印插入后节点
	SListPrint(plist);
	printf("\n");

	//删除3后的5
	SLNode* pos3 = SListFind(plist, 3);
	SListEraseAfter(pos3);
	//打印删除后节点
	SListPrint(plist);
	printf("\n");
	//禁止删除尾部后无空间的数据
	SLNode* pos4 = SListFind(plist, 3);
	SListEraseAfter(pos4);
}
int main()
{
	TestSList3();
	return 0;
}

执行调试结果如下：

1·在已有节点123基础上，在1后插入4，3后插入5：
在这里插入图片描述
2·以上面情况为基础，删除3后的5
在这里插入图片描述
3·以上面情况为基础，删除3后的非法访问内存
在这里插入图片描述

5.2任意位置处插入节点&任意位置处删除节点

任意位置处插入节点函数在Slist.c中如下：

//在pos处插入一个节点
//无法进行尾插
void SListInsert(SLNode** pphead, SLNode* pos, SLTDateType x)
{
	SLNode* newnode = BuySListNode(x);
	//头插
	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	//正常插入
	else
	{
		//找到pos前一个位置
		SLNode* posPrev = *pphead;
		//遍历pos前的节点
		while (posPrev->next != pos)
		{
			posPrev = posPrev->next;
		}
		//1·将指定位置的前一个节点next指向新节点
		posPrev->next = newnode;
		//2·新节点的next指向pos处
		newnode->next = pos;
	}
}

时间复杂度为O(N)，效率一般。

任意位置处删除节点函数在Slist.c中如下：

//删除pos处的节点
void SListErase(SLNode** pphead, SLNode* pos)
{
	//头删
	if(pos == *pphead)
	{
		SListPopFront(pphead);
	}
	//尾删同样适用
	else
	{
		//找到pos前一个位置
		SLNode* posPrev = *pphead;
		//遍历pos前的节点
		while (posPrev->next != pos)
		{
			posPrev = posPrev->next;
		}
		//1·将指定位置上一节点的next指向指定位置的next
		posPrev->next = pos->next;
		//释放指定位置的空间
		free(pos);
		pos = NULL;
	}
}

时间复杂度为O(N)，效率一般。

具体实现方式如下：

#include <iostream>
#include  <stdio.h>
#include <stdlib.h>
#include "Slist.h"
#include <assert.h>

void TestSList3()
{
	//由于链表是指针管理，因此初始化创建一个结构体指针管理即可
	SListNode* plist = NULL;
	//尾部插入节点
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	//打印尾插节点
	SListPrint(plist);
	printf("\n");

	//在1前插入4
	SLNode* pos1 = SListFind(plist, 1);
	assert(pos1 != NULL);
	SListInsert(&plist, pos1, 4);
	//在3前插入5
	SLNode* pos2 = SListFind(plist, 3);
	assert(pos2 != NULL);
	SListInsert(&plist, pos2, 5);
	//打印插入后节点
	SListPrint(plist);
	printf("\n");

	//删除2
	SLNode* pos3 = SListFind(plist, 2);
	SListErase(&plist, pos3);
	//删除3
	SLNode* pos4 = SListFind(plist, 3);
	SListErase(&plist, pos4);
	//删除4
	SLNode* pos5 = SListFind(plist, 4);
	SListErase(&plist, pos5);
	//打印删除后节点
	SListPrint(plist);
	printf("\n");
}

int main()
{
	TestSList3();
	return 0;
}

执行调试结果如下：
1·在已有节点123基础上，在1处插入4，3处插入5：
在这里插入图片描述
2·以上面情况为基础，删除2、3、4
在这里插入图片描述

5.3两组实现方式对比
  • 对于任意位置后插入节点&任意位置后删除节点，这种方式不需要找到上一节点的位置，时间复杂度为O(1)，因此基本不损失效率，但是这种方式比较不符合实际。
  • 对于任意位置处插入节点&任意位置处删除节点，这种方式需要找到上一节点的位置，时间复杂度为O(N)，这个代价是比较大的，因此效率一般，但是这种方式比较符合实际。

四、单链表的缺点

单链表相比双链表的缺点就是当需要上一个节点的地址时，需要遍历并且重新定义一个变量保存上一节点的地址，这样操作起来非常不方便，并且效率一般。而双链表很好的解决了这个问题。
线性表之双链表点击这里

码上芯路人
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
【编程与算法基础】数据结构——线性表之顺序表
qq_52158753的博客
03-30 179
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列等。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是典型的线性表之一，以数组的形式存储。
【编程与算法基础】数据结构——线性表之队列
qq_52158753的博客
04-03 239
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列等。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。队列是一种特殊的线性表，既可以以数组形式存储也可以以链式结构的形式存储。以数组形式存储称为数组队列（特殊的线性表），以链式结构的形式存储称为链式队列（特殊的链表）。
【编程与算法基础】数据结构——线性表之双链表
qq_52158753的博客
04-01 139
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列等。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。链表是典型的线性表之一，以链式结构的形式存储。链表又被分为单链表和双链表。本片仅对双链表详细说明。
【编程与算法基础】数据结构——线性表之栈
qq_52158753的博客
04-02 101
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列等。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。栈是一种特殊的线性表，既可以以数组形式存储也可以以链式结构的形式存储。以数组形式存储称为数组栈（特殊的线性表），以链式结构的形式存储称为链式栈（特殊的链表）。
数据结构与算法——线性表 实验报告及代码
weixin_45791919的博客
09-11 905
设计一算法，实现两个非递减的线性表的合并，采用链式存储结构，能够输出合并前和合并后链表的内容。
数据结构基础和算法图解(2)——线性表
zyw2002的博客
05-10 794
文章目录2. 线性表2.1 线性表的逻辑结构2.1.1 例题2.2 线性表的操作2.2.1 合并集合2.2.2 过滤集合中的重复元素2.2.3合并有序表2.3 顺序表2.3.1线性表的顺序存储结构2.3.1.1 顺序表初始化2.3.2 顺序表的查找2.3.1.3 例题2.3.2 顺序表的插入2.3.2.1例题2.3.3 顺序表的删除2.3.3.1 例题2.3 单链表2.3.1 生成链表2.3.2 获取元素2.3.3 单链表存储结构改进2.3.4 例题2.3.5 单链表的插入2.3.5.1 例题2.3.6 单
数据结构——线性表算法题
weixin_43525993的博客
01-11 1376
在第4个元素之前插入元素25（顺序表）。 思想: ① 将第 n 到 i 个元素均向后移动一个位置 ②将新元素放置在第 i 个位置 Status ListInsert_Sq ( Sqlist &amp;amp;amp;L ，int i ，ElemType e ) { if ( i &amp;amp;lt; 1 || i &amp;amp;gt; L.length +1 ) return ERROR ； if ( L.le...
数据结构C++实现——线性表之链表(单链表)
Wontoner的博客
12-29 1335
线性表分为顺序表与链表 其中链表分为单链表、双链表、循环链表(这三个为指针实现)与静态链表(数组实现) 指针实现的链表可以分为带头结点与不带头结点两种 其基本操作有插入、删除、按位查找、按值查找等 单链表，不带头结点: /* 单链表（不带头结点）：用链式存储方式实现的线性表 */ #include <cstdio> #include <iostream> #include <cstdlib> using namespace std; #define E
【数据结构】——线性表的相关习题
小宇y的博客
08-01 1749
若将删除结点 * p的操作转换为删除结点 * p的后继结点来实现，将下一个结点的指针域指向上一个结点，在交换数据域后，将* q结点从单链表中断开并释放该结点即可，这样的时间复杂度为O(1)。，也是将新结点的指针域指向下一个结点，该结点与前一个结点连接，然后通过一个中间变量将上一个结点的数据域与该结点交换即可，从而使时间复杂度达到。3、在单链表中删除第i个结点的时间复杂度为（），若将删除结点 * p的操作转换为删除结点 * p的后继结点来实现，其时间复杂度为（）。时，则该双链表为空。
数据结构实验——线性表子系统
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
C++与数据结构 第一次上机实验——线性表.pdf
11-07
本文主要讨论了C++编程中关于数据结构中的线性表，包括线性表的定义、顺序存储结构和链式存储结构的特点，以及如何通过C++实现线性表的相关操作，如插入、删除和查找等。 线性表是一种数据结构，其中的元素之间存在...
《数据结构与算法实验》教学大纲.docx
12-14
该课程对应的理论课程是《数据结构与算法》，使用的教材是《算法与数据结构——C语言描述》第三版，由张乃孝、陈光、孙猛等人编写，于2011年6月由高等教育出版社出版。 教学目标包括让学生深入理解各种数据的逻辑...
C基础day6
最新发布
qq_55245263的博客
07-08 88
【代码】C基础day6。
深入理解计算机系统 CSAPP 家庭作业8.23
apple_50569014的博客
07-04 135
增加了一些代码先看看啥情况。
【算法】（C语言）：快速排序（递归）、归并排序（递归）、希尔排序
yannan20190313的博客
07-05 838
【算法】（C语言）：快速排序（递归）、归并排序（递归）、希尔排序
C语言求10进制转2进制（除2取余法）
weixin_55021541的博客
07-08 181
递归的工作原理可以类比为数学中的等比数列求和，或者像是一个俄罗斯套娃，每个问题都包含了一个更小的问题，直到达到基本情况。1.思路：除2取余法，也就是说用除以2取余来将10进制数转换为二进制。递归通常用于解决那些可以被分解为更小的、相同类型的子问题的问题。2.两种代码实现，这里用了两，一个递归一个非递归。
数据结构与算法之线性表基础——单链表（C与C++双人打） 定义线性表节点的结构.pdf
04-18
"数据结构与算法之线性表基础——单链表（C与C++双人打） 定义线性表节点的结构.pdf" 本文主要探讨的是数据结构中的线性表的一种特殊形式——单链表，以及如何在C和C++中实现它的基本操作。线性表是一种逻辑上相邻...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值