数据结构003 - 线性表（单链表）

已于 2022-04-22 09:36:18 修改
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 数据结构初阶（C语言实现） 文章标签： 数据结构 算法 c语言
于 2022-04-20 17:08:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44944301/article/details/124301271
版权

1. 链表的概念及结构

1.1 链表的概念

链表是一种 物理存储结构上非连续、非顺序的存储结构，数据元素的 逻辑顺序 是通过链表中的指针链接次序实现的 。
在这里插入图片描述

下图为可能的物理分布
在这里插入图片描述

1.2 链表的优缺点

优点：
1、按需申请空间，不使用就释放空间（更合理地使用空间）。
2、在链表头部/中间插入/删除数据，不需要挪动数据。
3、不存在空间浪费。
缺点：
1、每一个数据，都要储存一个指针链接后面的数据节点。
2、不支持随机访问（用下标直接访问第 i 个）。

1.3 链表的结构分类

在实际中，链表的结构非常多样，分类有如下几种：
1、单向链表 与 双向链表
链表1
2、不带头链表 与 带头链表（此处 “头” 也称为 “哨兵”）
链表2
3、非循环链表 与 循环链表
链表3
将以上结构排列组合起来，可得有八种结构的链表。在实际中，最常用的两种结构是 无头单向非循环链表 和 带头双向循环链表。
在这里插入图片描述
（1）无头单向非循环链表 ：结构简单，一般不会单独用于存储数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等。
（2）带头双向循环链表 ：结构最复杂，一般用于单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这种结构虽然结构复杂，但是在使用代码实现以后，会发现结构会带来很多优势，实现反而简单了。

2. 单链表的实现

代码的实现将放在三个文件中，分别是 SList.h（用于声明）、SList.c（用于定义）、Test.c（用于测试）。

SList.h 文件

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#include <assert.h>

typedef int SLTDataType;

// 单链表的结构
typedef struct SListNode{
	SLTDataType data;       // 数据域，储存数据
	struct SListNode* next; // 指针域，储存下一个节点的地址
}SListNode;


// 申请一个新节点
SListNode* BuySListNode(SLTDataType x);

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

// 尾插
void SListPushBack(SListNode* phead, SLTDataType x);

// 头插
void SListPushFront(SListNode** pphead, SLTDataType x);

// 尾删
void SListPopBack(SListNode** pphead);

// 头删
void SListPopFront(SListNode** pphead);

// 查找
SListNode* SListFind(SListNode* phead, SLTDataType x);

// 在 pos 位置之前插入一个节点 
void SListInsertBefore(SListNode** pphead, SListNode* pos, SLTDataType x);

// 在 pos 位置之后插入一个节点 
void SListInsertAfter(SListNode* pos, SLTDataType x);

// 删除 pos 位置的节点
void SListErase(SListNode** pphead, SListNode* pos);

// 删除 pos 位置之后的节点
void SListEraseAfter(SListNode* pos);

// 销毁
void SListDestroy(SListNode** pphead);

2.1 申请一个新节点

SList.c 文件

#include "SList.h"

// 申请一个新节点
SListNode* BuySListNode(SLTDataType x){
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	// malloc 后需要检查是否申请成功，因此要判断 newnode 是否为空
	if (newnode == NULL){
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;    // x 的值储存在 newnode 数据域中
	newnode->next = NULL; // newnode 的指针域置空

	return newnode;
}

2.2 打印单链表

SList.c 文件

#include "SList.h"

// 打印单链表
void SListPrint(SListNode* phead){
	SListNode* cur = phead;

	while (cur != NULL){
		printf("%d->", cur->data);  // 打印链表数据
		cur = cur->next; // 让 cur 指向下一个数据
	} // 当 cur 为空时，链表打印结束
	printf("NULL\n");
}

2.3 尾插

思路：

（1）如果链表本身是空链表，则把新申请的节点分配给 phead。需要注意的是：形参是实参的临时拷贝，形参的改变不影响实参。这里要改变实参 plist，形参 phead 是实参 plist 的一份临时拷贝，形参 phead 的改变不影响实参 plist，所以要传 plist 的地址，而 plist 本身就是指针，所以要传指针的地址，那么就要用二级指针来接收。

（2）如果链表不是空链表，此时就需要创建一个指针变量 tail 来遍历链表，找到链表的最后一个节点，然后把新创建的节点插入进去。

思路

SList.c 文件

#include "SList.h"

// 尾插
void SListPushBack(SListNode** pphead, SLTDataType x){
	assert(pphead);
    
    // 申请一个新节点
	SListNode* newnode = BuySListNode(x);

	if (*pphead == NULL){
		*pphead = newnode;
	}
	else{
		// 寻找尾节点
		SListNode* tail = *pphead;
		while (tail->next != NULL){
			tail = tail->next;
		}
		// 找到尾节点，将尾节点的指针域指向插入的新节点的地址
		tail->next = newnode;
	}
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 4; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);
}

int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.4 头插

思路： 头插相对于尾插简单一点，只需要把新创建的节点放入链表头部，需要注意的是头插和尾插一样，需要传二级指针。

思路

SList.c 文件

#include "SList.h"

// 头插
void SListPushFront(SListNode** pphead, SLTDataType x){
	assert(pphead);
    
    // 申请一个新节点
	SListNode* newnode = BuySListNode(x);

	newnode->next = *pphead; // newnode 的指针域指向链表的数据域（链表的头）
	*pphead = newnode; // 让 newnode 作为新链表的头
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 4; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);

	// 头插
	for (int i = 1; i < 4; i++){
		SListPushFront(&plist, i * 10);
	}
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.5 尾删

思路： 寻找最后一个节点，定义一个指针变量 tail 遍历链表，当 tail->next == NULL 时就找到了尾节点。但是当 free 最后一个节点时，无法找到倒数第二个节点，而尾删需要将倒数第二个节点的 next 置为空，所以还需要创建一个指针变量 prev，尾删后将 prev->next 置为空。

另外，尾删还需要分链表为空无节点、只有一个节点、多个节点三种情况判断。

思路

SList.c 文件

#include "SList.h"

// 尾删
void SListPopBack(SListNode** pphead){
	assert(pphead);
    
    // 链表为空时，粗暴的处理
	// assert(*pphead != NULL);

	// 链表为空时，温柔的处理
	if (*pphead == NULL){
		return;
	}
	// 只有一个节点
	else if ((*pphead)->next == NULL){
		free(*pphead);
		*pphead = NULL;
	}
	// 有多个节点
	else{
		// 先找到尾节点，再记录尾节点的前一个节点
		SListNode* tail = *pphead;
		SListNode* prev = NULL;
		while (tail->next != NULL){
			prev = tail;
			tail = tail->next;
		}
		// 找到尾节点，释放并置空；
		free(tail);
		tail = NULL;
		// 此时尾节点的前一个节点（prev）还保存着 tail 节点的数据的地址，要将它置空；
		prev->next = NULL;
	}
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 4; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);

	// 尾删
	SListPopBack(&plist);
	SListPopBack(&plist);
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.6 头删

思路： 当链表为空时，不用删除直接返回空链表。当链表不为空时，可以创建一个指针变量 next 来保存第二个节点的地址，即第一个节点的 next，然后 free 第一个节点，将 next 赋值给 *pphead。

SList.c 文件

#include "SList.h"

// 头删
void SListPopFront(SListNode** pphead){
	assert(pphead);
    
    if (*pphead == NULL){
		return;
	}
	else{
		// 记录头节点储存的下一个节点的地址
		SListNode* next = (*pphead)->next;
		free(*pphead); // 释放头节点
		*pphead = next; // 头节点的下一个节点作新的头节点
	}
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 4; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);

	// 头删
	SListPopFront(&plist);
	SListPopFront(&plist);
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.7 查找、修改

思路： 遍历链表。

SList.c 文件

#include "SList.h"

// 查找
SListNode* SListFind(SListNode* phead, SLTDataType x){
	SListNode* cur = phead;
	while (cur != NULL){
		if (cur->data == x){
			return cur;
		}
		else{
			cur = cur->next;
		}
	}
	return NULL;
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);
	SListPushBack(&plist, 4);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 5);
	SListPushBack(&plist, 2);
	// 打印单链表
	SListPrint(plist);

	// 查找
	SListNode* pos = SListFind(plist, 2);
	int i = 1;
	while (pos){
		printf("找到了，第 %d 个 pos 节点：%p->%d\n", i++, pos, pos->data);
		pos = SListFind(pos->next, 2);
	}
	
	// 修改
	pos = SListFind(plist, 3);
	if (pos){
		pos->data = 30;
	}
	
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.8 在 pos 位置之前插入一个节点

思路：

（1）pos 不在头节点 。pos 是节点的地址，通过 SListFind 函数找到 pos。同时还需要找到 pos 前一个节点的地址，只有这样才能将链表的节点依次链接起来。可以创建一个指针变量 posPrev，然后遍历链表，当 posPrev->next==pos 时，posPrev 就是 pos 前一个节点的地址，然后创建一个新的节点，实现节点的插入。

（2）pos 在头节点。此时相当于头插。

思路

SList.c 文件

#include "SList.h"

// 在 pos 位置之前插入一个节点 
void SListInsertBefore(SListNode** pphead, SListNode* pos, SLTDataType x){
	assert(pphead);
	assert(pos);
    
    // 申请一个新节点
	SListNode* newnode = BuySListNode(x);
	// 如果 pos 是头节点
	if (*pphead == pos){
		newnode->next = *pphead;
		*pphead = newnode;
		// pos 是第一个节点，相当于头插
		// SListPushFront(pphead, x);
	}
	// 如果 pos 不是头节点
	else{
		// 找到 pos 位置的前一个节点
		SListNode* posPrev = *pphead;
		while (posPrev->next != pos){
			posPrev = posPrev->next;
		}
		// 让新节点的指针域指向 pos，再让 pos 的前一个节点的指针域重新指向新节点的数据域地址，就插入到 pos 的前面了
		newnode->next = pos;
		posPrev->next = newnode;
	}
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 5; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);

	SListNode* pos = SListFind(plist, 3);
	if (pos){
		SListInsertBefore(&plist, pos, 10);
	}
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.9 在 pos 位置之后插入一个节点

思路：更加推荐在 pos 位置之后插入的方式。 因为相较于在 pos 位置之前插入来说更加方便，不需要寻找 pos 位置的上一个节点。

思路

SList.c 文件

#include "SList.h"

// 在 pos 位置之后插入一个节点 
void SListInsertAfter(SListNode* pos, SLTDataType x){
	assert(pos);
    
    // 申请一个新节点
	SListNode* newnode = BuySListNode(x);
	// 让新节点的指针域指向 pos 位置的下一个节点的数据域地址
	newnode->next = pos->next;
	// pos 的指针域指向新节点的数据域地址
	pos->next = newnode;
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 5; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);
	
	SListNode* pos = SListFind(plist, 3);
	if (pos){
		SListInsertAfter(pos, 10);
	}
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.10 删除 pos 位置的节点

思路： 当 pos 为第一个节点时，只需要调用头删。当 pos 不是第一个节点时，需要创建一个指针变量 posPrev 指向 pos 的前一个节点，然后将 posPrev->next 指向 pos 的下一个节点，再将 pos 节点 free 掉。

思路

SList.c 文件

#include "SList.h"

// 删除 pos 位置的节点
void SListErase(SListNode** pphead, SListNode* pos){
	assert(pphead);
	assert(pos);
    
    // 当 pos 为第一个节点时
	if (*pphead == pos){
		// 方法一：调用头删函数
		SListPopFront(pphead);

		// 方法二
		//pphead = pos->next;
		//free(pos);
	}
	else{
		// 找到 pos 位置的前一个位置（posPrev）
		SListNode* posPrev = *pphead;
		while (posPrev->next != pos){
			posPrev = posPrev->next;
		}
		// 让 pos 位置的前一个节点 posPrev 的指针域指向 pos 节点的指针域
		// 如果 pos 位置后还有节点，即指向了 pos 位置的下一个节点的数据域的地址
		posPrev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 4; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);
	
	SListNode* pos = SListFind(plist, 2);
	if (pos){
		SListErase(&plist, pos);
	}
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.11 删除 pos 位置之后的节点

思路： 需要创建一个指针变量 next 指向 pos 的指针域，即指向了 pos 位置的下一个节点的数据域的地址。然后将 next->next（即保存的 pos 之后第二个节点的数据域的地址）赋值给 pos->next，最后将 next 变量 free 掉。

SList.c 文件

#include "SList.h"

// 删除 pos 位置之后的节点
void SListEraseAfter(SListNode* pos){
	assert(pos);
    assert(pos->next);
    
    SListNode* next = pos->next;
	if (next){
		pos->next = next->next;
		free(next);
		next = NULL;
	}
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 4; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);
	
	SListNode* pos = SListFind(plist, 2);
	if (pos){
		SListEraseAfter(pos);
	}
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

2.12 销毁单链表

思路： 单链表的销毁并不能和顺序表一样直接释放，顺序表是开辟的连续的空间，链表不是。要将链表释放需要释放每一个结点；可以采用双指针。

思路

SList.c 文件

#include "SList.h"

// 销毁
void SListDestroy(SListNode** pphead){
	assert(pphead);

	SListNode* cur = *pphead;
	while (cur){
		SListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*pphead = NULL;
}

Test.c 文件

#include "SList.h"

void TestSList1(){
	// 空链表
	SListNode* plist = NULL;
	// 尾插
	for (int i = 0; i < 4; i++){
		SListPushBack(&plist, i);
	}
	// 打印单链表
	SListPrint(plist);
	
	SListDestroy(&plist);
	// 打印单链表
	SListPrint(plist);
}


int main(){
	TestSList1();

	return 0;
}

运行结果：

运行结果

3. 单链表的适用场景

单链表结构，适合头插头删，不适合在尾部或者中间某个位置插入或者删除。如果要使用链表结构存储数据，使用 双向链表 更为合适。
单链表会作为复杂数据结构的子结构（图的邻接表、哈希桶）。

疯狂的豆子2019
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——链表
张许平的博客
03-17 478
链表也是一种数据结构，相比较于数组，略显复杂。链表和数组都是非常基础、非常常用的数据结构。 1. 数组与链表的区别 从底层的存储结构上看，二者申请的内存空间不一样： 数组需要一块连续的内存空间来存储，对内存要求较高。 链表不需要一块连续的内存空间，它通过"指针"将一组零散的内存块串联起来。 例如，当我们申请一个100MB大小的数组，当内存空间中没有连续的、足够大的存储空间时，即便内存的...
c语言链表申请空间,C语言利用链表与文件实现登录注册
weixin_36237054的博客
05-21 406
C语言实现简登录和注册功能C语言实现注册登录使用链表使用文件版本二：利用链表此版本使用的链表，第一个版本使用的是数组这里我使用的线性链表，一定要注意在判断语句或赋值语句中不可将指针指向未定义的区域，这会产生很大问题，所以一般都需要在链表最后一个节点指向空指针#代码#include #include #include #include typedef struct LNode{char name[1...
链表创建为什么需要使用内存分配？
热门推荐
主要记录嵌入式学习与开发过程。
09-27 1万+
我们知道，在全局定义的结构体变量，存储全局数据区；在函数内定义的结构体变量，存储在栈区；使用malloc函数申请空间来存放结构体变量，则该结构体变量存储在堆空间中。那假如有1000个在函数内部（栈区）或者函数外部（全局数据区）定义好的结构体，能否直接创建链表？比如下面段代码，提前定义了结构体数组，然后串联成类似“链表”的形式，但假如节点数目大于6，则难以扩展。但是这样徒有链表的形式，不具备链表动态扩展的特点。我们说的链表，其节点数据一般放在堆空间中。...
关于为什么要在链表中用malloc来分配内存
tang20030306的博客
04-11 1720
不知道有没有人和我一样，在学习链表的时候心里搞不懂为什么要用malloc来分配内存，细细想了想，是因为知道用int也可以分配内存，总觉得可以用什么可以替代malloc来进行内存分配，想了想，突然就明白了了。这不就能完全理解单链表的这段代码了吗。下面是 malloc() 函数的声明。
单链表相关知识
qq_63846156的博客
11-10 244
单链表尾插尾删头插头删
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc 知识点摘要： 1. 数据结构的基本概念：数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。 2. 线性表的概念：线性表是一种基本...
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构实战--线性表的单链表实现
03-26
本实战项目聚焦于数据结构中的线性表，特别是通过单链表进行实现。线性表是一种基本的数据结构，由相同类型元素的有序序列组成，而单链表是其一种常见表示方式。 单链表是一种动态数据结构，每个元素（称为节点）...
数据结构c版（1）-线性表之单链表代码
11-19
在这个“数据结构C版（1）-线性表之单链表代码”中，我们将深入探讨线性表这一基础数据结构的C语言实现，特别是单链表。 单链表是一种线性数据结构，其中的元素并非在内存中连续存储，而是通过指针连接。每个元素...
动态创建链表，在需要时开辟空间。
06-09
这种链表在初始时不一定分配足够的空间, 但是在后续插入的时候需要动态申请存储空间，并且存储空间不一定连续, 在进行插入和删除时则不需要移动元素, 修改指针域即可,所以仍然具有链表的主要优点，链表结构可以是动态地分配存储的，即在需要时才开辟结点的存储空间，实现动态链接。
c语言中的新建节点为甚么需要malloc或new？
onlyoncelove的博客
03-10 3520
    今天早上我突然问自已一个问题，为什么链表中的节点不能像基本类型那样为其赋值，这关系到栈内存和堆内存。下面是我在网上看到的答案，感觉比较不错。    计算机中的内存分为两部分：一部分是栈（stack，也称堆栈），另一部分是堆（heap）。 栈，可以看作是一摞卡片，最上面的卡片表示程序的当前作用域，这往往就是当前正在执行的函数。当前函数中声明的所有变量都置于栈顶帧中，即占用栈顶帧的内...
第二十二篇，数据结构（起始篇）—单向链表。
weixin_44651073的博客
02-28 678
一、数据结构学习大纲。 1、数组与链表之间存储区别。 2、链表模型、使用场景。 3、链表种类？ 传统链表 --> 单向链表、单向循环链表、双向链表、双向循环链表。 非传统链表 --> 内核链表 4、栈/队列 5、二叉树 无论学习什么数据结构，其实都是在学习该结构的增删改查。 二、回顾学习过一些数据结构 -- 增删改查。 变量： int x = 0; 增：x = 10; 删：x = 0; 改：x = 20 查：printf("%d\n",x); 数组：int x[3] = {0}; 增..
用链表的目的是什么？省空间还是省时间？
南风fahaxiki
12-12 657
可以说，本科的算法数据结构这本书，其中一大半的篇幅都在教这个改进过程/思路——只不过绝大多数的师生乃至写教材的老师都没意识到这点，反而习惯性的分章节摘开、把明显具有演进关系的概念割裂成一个个final class讲解/学习，再加上考试指挥棒的作用，这才使得绝大多数人被误导到了错误的方向。但“随随便便插入数据”的二叉树很可能“偏”的非常厉害。错误的根源在于，你把链表当成了一种整体的、不可分割不可更改的完整概念——然后，就着这个概念，考虑它的用途它的优点它的弱点，总结出一二三四然后背诵。可申请少了又不够用啊。
为什么创建链表要申请空间，目的，原因
最新发布
2302_79344985的博客
02-26 498
创建链表需要申请空间的原因是因为链表是一种动态数据结构，它的大小可以根据需要进行动态调整。链表中的每个节点都需要存储数据以及指向下一个节点的指针，因此需要在内存中为每个节点分配一定的空间。如果数组大小不够，需要重新创建一个更大的数组，并将原数组中的数据复制到新数组中，这样会造成额外的时间和空间开销。当我们向链表中插入新的节点时，需要为新节点分配内存空间，并将其插入到链表中适当的位置。因此，链表通过动态申请和释放内存空间的方式，可以更加灵活地管理数据，适应不同大小和数量的数据需求。
静态链表
lulu_1085的博客
03-10 1504
先上两个百度百科两句话：1、便于在没有指针类型的高级程序设计语言中使用链表结构。2、这种存储结构，仍需要预先分配一个较大的(连续的)空间，但在作为线性表的插入和删除操作时不需移动元素，仅需修改“指针”，故仍具有链式存储结构的主要优点。第一句话说明了为什么需要静态链表。第二句话说明了静态链表的主要特性：不需要指针(用数组下标代替指针)，这样就有了链表的优点。同时它又是连续的，所以才能用数组下标代替指...
链表(开辟和不开辟新空间)
Timewilltellz的博客
10-30 2779
开辟新空间 1相当于创建了一个链表，因此需要创造一个内存空间 2要定义一个移动指针 3因为是新链表，所以如果将跳出的节点插入这个新链表中，可以用头插或者尾插创造一个新节点交换此节点的数据域，这样原节点和这个节点所在的链表不会发生改变。 不开辟新空间 1需要先 ...
动态链表的创建、节点内存空间申请以及释放
zxccaoya的博客
11-15 1万+
1.动态链表的创建和内存申请： typedef struct _STACK{     void* data;     int size;     struct _STACK* next;     struct _STACK* pre; } STACK; STACK *stack; STACK *_stack; void initStack() ｛ stack = (S

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值