顺序表和链表

原创 于 2025-11-24 17:46:44 发布 · 271 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构

1.线性表

线性表是n个具有相同特性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构，线性表在逻辑上是线性结构的，也就是说是连续的一条直线，但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

2.顺序表

顺序表的底层结构是数组，对数组的封装，实现了常用的增删查改等接口。

顺序表分为静态顺序表和动态顺序表：
（1）静态顺序表：使用定长数组储存元素。

对静态顺序表的结构体定义：

typedef int SLDataType;
#define N 7
typedef struct SeqList{
    SLDataType a[N];   //定长数组
    int size;          //有效数据个数
}SL;

静态顺序表缺陷：空间给少了不够用，给多了造成空间浪费。

（2）动态顺序表：可以按需申请空间。

对动态顺序表的结构体定义：

typedef int SLDataType;
typedef struct SeqList
{
    SLDataType* a;
    int size;          //有效数据个数
    int capacity;      //空间容量
}SL;

3.动态顺序表的实现

//SeqList.h
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* arr;
	int size;
	int capacity;
}SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
//打印
void SLPrint(SL s);
//头部插入删除/尾部插入删除
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);

//指定位置之前插入删除数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
//查找
int SLFind(SL* ps, SLDataType x);
//SeqList.c

#include "SeqList.h"

void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->capacity = 0;
	ps->size = 0;
}
void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newNode = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newNode * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->arr = tmp;
		ps->capacity = newNode;
	}
}

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;
}

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheckCapacity(ps);
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

void SLPrint(SL s)
{
	for (int i = 0; i < s.size; i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;

}


void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;

}
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}


int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			//找到啦
			return i;
		}
	}
	//没有找到
	return -1;
}

4.单链表

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

这就是链表的结构图，与顺序表不同的是，链表里的每个节点都是独立申请下来的空间，节点的组成主要有两个部分：当前节点要保存的数据和保存下一个节点的地址（指针变量）。

图中指针变量plist保存的是第一个节点的地址，我们称plist此时指向第一个节点，如果我们希望plist指向第二个节点时，只需要修改plist保存的内容为0x0012FFA0。

链表中每个节点都是独立申请的（需要插入数据时才会去申请一块节点的空间），我们需要通过指针变量来保存下一个节点位置才能从当前节点找到下一个节点。

此时我们可以用结构体定义每个节点对应的结构体代码，假设当前节点为整型：

struct SLIstNode
{
    int data;          //节点数据
    struct SListNode* next;      //指针变量用来保存下一个节点的地址
};

链式结构在逻辑上是连续的，在物理结构上不一定连续。

节点一般是从堆上申请的

从堆上申请来的空间是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续。

5.单链表的实现

//SList.h

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

//定义节点的结构
//数据 + 指向下一个节点的指针
typedef int SLTDataType;

typedef struct SListNode {
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

void SLTPrint(SLTNode* phead);

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(SLTNode** pphead);
//头删
void SLTPopFront(SLTNode** pphead);

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);

//销毁链表
void SListDesTroy(SLTNode** pphead);
//SList.c

#include "SList.h"


void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newNode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newNode == NULL)
	{
		perror("malloc");
		return;
	}
	newNode->next = NULL;
	newNode->data = x;
	
	return newNode;
}


void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newNode = SLTBuyNode(x);

	if (*pphead == NULL)
	{
		*pphead = newNode;
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next)
		{
			cur = cur->next;
		}
		cur->next = newNode;
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newNode = SLTBuyNode(x);
	
	newNode->next = *pphead;
	*pphead = newNode;

}

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead && *pphead);
	
    if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* cur = *pphead;
		SLTNode* prev = *pphead;
		while (prev->next)
		{
			cur = prev;
			prev = prev->next;
		}
		free(prev);
		prev = NULL;
		cur->next = NULL;
	}
	

}


void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* cur = (*pphead)->next;
		free(*pphead);
		*pphead = cur;
	}
}


//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)//等价于pcur != NULL
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//pcur == NULL
	return NULL;
}
//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	//若pos == *pphead;说明是头插
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//prev -> newnode -> pos
		newnode->next = pos;
		prev->next = newnode;
	}
}
//在指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = SLTBuyNode(x);
	//pos -> newnode -> pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	//pos是头结点/pos不是头结点
	if (pos == *pphead)
	{
		//头删
		SLTPopFront(pphead);
	}
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//prev pos pos->next
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	//pos del del->next
	pos->next = del->next;
	free(del);
	del = NULL;
}
//销毁链表
void SListDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);

	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//pcur
	*pphead = NULL;
}

6.链表的分类

这三种可以进行随机组合最终有8种组合（2*2*2）链表结构。虽然有这么多链表结构，但是我们实际最常用的还是两种结构：单链表和双向带头循环链表。

7.双向链表

这里的双向链表就是指双向带头循环链表。

带头链表里面的头节点实际为哨兵位，哨兵位节点不存储任何有效元素只是为了遍历循环列表避免死循环。

8.双向链表的实现

//List.h

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

typedef int LTDataType;
//定义双向链表节点的结构
typedef struct ListNode
{
	LTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;


//声明双向链表中提供的方法

//初始化
//void LTInit(LTNode** pphead);
LTNode* LTInit();
void LTDesTroy(LTNode* phead);

void LTPrint(LTNode* phead);

//插入数据之前，链表必须初始化到只有一个头结点的情况
//不改变哨兵位的地址，因此传一级即可
//尾插
void LTPushBack(LTNode* phead, LTDataType x); 
//头插
void LTPushFront(LTNode* phead, LTDataType x); 

//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);


//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);
//删除pos节点
void LTErase(LTNode* pos);
LTNode* LTFind(LTNode* phead, LTDataType x);
//List.c

#include"List.h"

void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

//申请节点
LTNode* LTBuyNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	node->data = x;
	node->next = node->prev = node;

	return node;
}
//初始化
//void LTInit(LTNode** pphead)
//{
//	//给双向链表创建一个哨兵位
//	*pphead = LTBuyNode(-1);
//}
LTNode* LTInit()
{
	LTNode* phead = LTBuyNode(-1);
	return phead;
}

//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//phead phead->prev newnode
	newnode->prev = phead->prev;
	newnode->next = phead;

	phead->prev->next = newnode;
	phead->prev = newnode;
}
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	LTNode* newnode = LTBuyNode(x);

	//phead newnode phead->next
	newnode->next = phead->next;
	newnode->prev = phead;

	phead->next->prev = newnode;
	phead->next = newnode;
}

//尾删
void LTPopBack(LTNode* phead)
{
	//链表必须有效且链表不能为空（只有一个哨兵位）
	assert(phead && phead->next != phead);

	LTNode* del = phead->prev;
	//phead del->prev del
	del->prev->next = phead;
	phead->prev = del->prev;

	//删除del节点
	free(del);
	del = NULL;
}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead && phead->next != phead);
	
	LTNode* del = phead->next;
	
	//phead del del->next
	phead->next = del->next;
	del->next->prev = phead;

	//删除del节点
	free(del);
	del = NULL;
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}
//在pos位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode = LTBuyNode(x);
	//pos newnode pos->next
	newnode->next = pos->next;
	newnode->prev = pos;

	pos->next->prev = newnode;
	pos->next = newnode;
}
//删除pos节点
void LTErase(LTNode* pos)
{
	//pos理论上来说不能为phead，但是没有参数phead，无法增加校验
	assert(pos);
	//pos->prev pos pos->next
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;

	free(pos);
	pos = NULL;
}
void LTDesTroy(LTNode* phead)
{
	assert(phead);

	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//此时pcur指向phead，而phead还没有被销毁
	free(phead);
	phead = NULL;
}

9.顺序表和链表的区别

不同点顺序表链表
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O(1)不支持O(1)
任意位置插入或者删除元素可能需要搬移元素效率低O(N)只需要修改指针指向
插入动态顺序表，空间不够时需要扩容没有容量概念
应用场景元素高效存储+频繁访问任意位置插入和删除频繁
缓存利用率高低

顺序表和链表的区别
xsc2004zyj的博客
07-19 1085
顺序表和链表其实是两个相辅相成，互补的数据结构，因为他们彼此之前都有自己个优势，也有自己的不足，这里我们来了解一下顺序表和链表的区别。这里的链表指的是带头双向循环链表。
数据结构 | 顺序表及链表
Nice_W的博客
12-28 1242
数据结构中的线性表是一种非常基础的数据结构，在实际运用中也非常广泛，本文主要介绍线性表中顺序表和链表。
数据结构：顺序表和链表
最新发布
2401_88251472的博客
07-18 1033
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是⼀种在实际中⼴泛使⽤的 数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，线性 表在物理上存储时，通常以数组和链式结构的形式存储。逻辑结构：一定是线性的物理结构：不一定是线性的。
【数据结构】顺序表和链表详解
m0_62934529的博客
04-28 3686
1. 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2. 顺序表 2.1 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表的物理结构和逻辑结构是
链表面试题（1）----顺序表和链表的区别及其优缺点
baidu_39630193的博客
08-01 1万+
1.顺序表存储（典型的数组）      原理：顺序表存储是将数据元素放到一块连续的内存存储空间，相邻数据元素的存放地址也相邻（逻辑与物理统一）。      优点：（1）空间利用率高。（局部性原理，连续存放，命中率高）             （2）存取速度高效，通过下标来直接存储。      缺点：（1）插入和删除比较慢，比如：插入或者删除一个元素时，整个表需要遍历移动元素来重新排一次顺序
顺序表和链表.pdf
04-24
本文档主要介绍顺序表和链表这两种基本的数据结构。在计算机科学中，数据结构是指在计算机中组织和存储数据的一种特殊方式，它允许高效地访问和修改数据。顺序表和链表作为线性表的两种实现方式，在实际应用中非常...
精选资源
C语言：定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表.zip
09-07
在本资源"C语言：定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表.zip"中，我们将探讨如何使用C语言实现两种常见的数据结构——顺序表和链表，用于存储和管理学生信息。 首先，我们来理解顺序表。顺序表是...
数据结构实验 顺序表和链表
10-08
顺序表和链表的基本实现 数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍...
顺序表与链表
m0_56931704的博客
09-06 1600
顺序表与链表 一.顺序表 1.定义：将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中 顺序表可以分为静态顺序表和动态顺序表 2.结构定义： #define MAXSIZE 100 typedef int ElemType; typedef struct Seqlist {//静态顺序表 ElemType data[MAXSIZE]; size_t size
经典面试题之顺序表和链表的优缺点
HanSion.Z
04-14 2万+
★什么是顺序表？顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组连续地址的存储单元依次存储数据元素的线性结构。表中的任一元素的地址都可以通过这个公式得到：LOC（di）=LOC（d1）+（i-1）*L 　1≤i≤n 其中，L是元素占用存储单元的长度。                              ★什么是链表？链表是一种链式存储的数据结构，用一组地址任意的存储单元存放线性表中...
线性表：顺序表和链表的定义，接口实现，功能讲解，二者区别，分别适用于什么场景。
qq_39487033的博客
08-20 2781
线性表 顺序表的定义 顺序表，我把它简单的理解为一个结构体里，存了两个成员，一个数组data（为了保存数据），一个整型sz（记录数组中数据的个数）。因为顺序表有连续排列的顺序，所以用数组保存数据更方便。定义代码如下： typedef int DATA_TYPE; typedef struct PSeqList { DATA_TYPE data[MAX]; int sz...
java数据结构与算法之顺序表与链表深入分析
热门推荐
zejian的博客
11-05 3万+
开篇直接奔主题，无论是顺序表还是链表，它们都是线性表的一种，用比较官方的话来讲，线性表是其组成元素间具有线性关系的一种线性结构，而我们恰好可以采用顺序存储和链式存储结构来表示线性表。接下来将从以下几点出发分析线性表的设计与实现。 线性表抽象数据类型概述 线性表的顺序存储设计与实现顺序表 1 顺序存储结构的设计原理概要 2 顺序存储结构的实现分析 3 顺序存储结构的效率分析 线性表的链式存
数据结构的C实现_顺序表
孟凡驰的博客
03-22 1万+
//线性顺序表 #include #include #define LIST_INIT_SIZE 1000 //线性表存储空间的初始分配量 #define LISTINCRESEMENT 100 //线性表存储空间的分配增量 #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int elemType;//元素类型 typedef
数据结构---顺序表和链表
boke_fengwei
04-01 697
1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元...
链表和顺序表的一些区别
斜阳雨陌
07-03 1万+
顺序表与链表是非常基本的数据结构，它们可以被统称为线性表。 线性表（Linear List）是由 n（n≥0）个数据元素（结点）a[0]，a[1]，a[2]…，a[n-1] 组成的有限序列。 顺序表和链表，是线性表的不同存储结构。它们各自有不同的特点和适用范围。针对它们各自的缺点，也有很多改进的措施。 一、顺序表 顺序表一般表现为数组，使用一组地址连续的存储单元依次存储数据元素
(数据结构)顺序表和链表(C实现)
爱上小公举
08-21 2672
目录 1.线性表 2.顺序表 3.链表 4.顺序表和链表的区别与联系 1.线性表 线性表是 n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 注意...
数据结构中的顺序表和链表(Python语言)
weixin_43187669的博客
07-18 1697
文章目录
顺序表与链表（顺序表）
qq_64262956的博客
07-21 1456
顺序表实现（初阶数据结构）
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值