顺序表和链表

最新推荐文章于 2025-06-10 10:53:21 发布
最新推荐文章于 2025-06-10 10:53:21 发布
阅读量409 收藏 4
点赞数 3
文章标签： 链表 数据结构 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_69520125/article/details/145393698
版权

目录

1、线性表

2、顺序表

2.1、顺序表概念

2.2、顺序表实现

3、链表

3.1、链表概念：

3.2、单链表实现：

3.3、双链表实现

1、线性表

就是n个具有相同特性的数据元素的有限序列。挨着存储的，常见的线性表：顺序表、链表、栈、队列。

2、顺序表

2.1、顺序表概念

顺序表是利用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下用数组存储。在数组上完成数据的增删查改。

顺序表分为：

  • 静态顺序表：使用定长数组存储元素
  • 动态顺序表：使用动态开辟的数组存储，按需申请

缺点：

  • 在头部或中间插入删除数据，需要挪动数据，效率低
  • 空间不够，扩容有一定消耗（异地扩容），还可能有一定空间浪费

2.2、顺序表实现

SeqList.h：

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

静态顺序表
//#define N 10
//typedef int SLDataType;
//struct SeqList
//{
//	SLDataType a[N];
//	int size;
//	int capacity;
//};

typedef int SLDataType;
#define INIT_CAPACITY 4

typedef struct SeqList
{
	SLDataType* a;
	int size; //有效数字个数
	int capacity;//容量大小
}SL;

//初始化顺序表
void SLInit(SL* ps);

void SLPrint(SL* ps);

//增删查改
void SLPushBack(SL* ps,SLDataType x);
void SLPopBack(SL* ps);
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);
void SLDestroy(SL* ps);

// 顺序表查找
int SLtFind(SL* ps, SLDataType x);

// 顺序表在pos位置插入x
void SLInsert(SL* ps, int pos, SLDataType x);

// 顺序表删除pos位置的值
void SLErase(SL* ps, int pos);

//扩容
void CheckCapacity(SL* ps);

SeqList.c：

#include"SeqList.h"

void SLInit(SL* ps)
{
	assert(ps);
	ps->a = (SLDataType*)malloc(INIT_CAPACITY * sizeof(SLDataType));
	if (ps -> a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->size = 0;
	ps->capacity = INIT_CAPACITY;
}

void SLDestroy(SL* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

void SLPrint(SL* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0;i < ps->size;i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void CheckCapacity(SL* ps)
{
	//扩容
	if (ps->size == ps->capacity)
	{
		SLDataType* tmp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * ps->capacity * 2);
		if (tmp == NULL)
		{
			free(ps->a);
			ps->a = NULL;
			ps->size = ps->capacity = 0;
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);

	ps->a[ps->size] = x;
	ps->size++;
}

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

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	
	ps -> a[0] = x;
	ps->size++;
}

void SLPopFront(SL* ps)
{
	assert(ps);
	//assert(ps->size > 0);
	if (ps->size == 0)
	{
		return;
	}

	int begin = 0;
	while (begin < ps->size-1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	int pos = 0;
	for (pos = 0;pos < ps->size;pos++)
	{
		if (ps->a[pos] == x)
		{
			return pos;
		}
	}
	return -1;//没找到，返回-1
}

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	CheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}

	ps->a[pos] = x;
	ps->size++;
}

void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

3、链表

3.1、链表概念：

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。就是一个结构中除了保存数据，还保存了下个结构的地址，把他们连接起来。

无头单向非循环链表（单链表）：就除了有自身的数据，还保存了下个结点的地址。

带头双向循环链表（双链表）：不仅存着下个结点的地址，还存着上个结点的地址，head存着最后结点的地址，又存着下个结点的地址。逻辑上结点之间双向循环连接。

3.2、单链表实现：

SList.h：

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

typedef int SLTDataType;

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

// 动态申请一个节点
SLTNode* BuySLTNode(SLTDataType x);

//打印单链表
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);

//pos之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//pos位置删除
void SLTErase(SLTNode** pphead, SLTNode* pos);

//pos位置后面插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
//pos位置后面删除
void SLTEraseAfter(SLTNode* pos);

//单链表删除
void SLTDestory(SLTNode** pphead);

SList.c：

#include"SList.h"

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	newnode->data = x;
	newnode->next = NULL;

	return newnode;

}

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

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}

}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);

	/*if (*pphead == NULL)
	{
		return;
	}*/

	//1、只有一个结点
	//2、有多个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//找尾
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		prev->next = NULL;
		free(tail);
		tail = NULL;
	}

}

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead != NULL);

	SLTNode* first = NULL;
	first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);

	if (pos == *pphead)
	{
		SLTPushFront(pphead,x);
	}
	else
	{
		//找到pos前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);

	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);

	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

void SLTDestory(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}

	*pphead = NULL;
}

3.3、双链表实现

List.h：

//带头双向循环的双链表

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

typedef int LTDataType;

typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;


//初始化双链表
LTNode* LTInit();

//打印双链表
void LTPrint(LTNode* phead);

//销毁链表
void LTDestroy(LTNode* phead);

//双链表头插
void LTPushFront(LTNode* phead, LTDataType x);
//头删
void LTPopFront(LTNode* phead);

//双链表尾插
void LTPushBack(LTNode* phead, LTDataType x);
//尾删
void LTPopBack(LTNode* phead);

//双向链表查找
LTNode* LTFind(LTNode* phead,LTDataType x);

//在pos之前插入
void LTInsert(LTNode* pos, LTDataType x);
//pos位置删除
void LTErase(LTNode* pos);

List.c：

#include"List.h"

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	node->next = NULL;
	node->prev = NULL;
	node->data = x;

	return node;
}

LTNode* LTInit()
{
	LTNode* head = BuyLTNode(-1);

	head->next = head;
	head->prev = head;

	return head;
}

void LTPrint(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	printf("<=>head<=>");
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void LTDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;

	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* newnode = BuyLTNode(x);
	
	LTNode* cur = phead;
	LTNode* next = phead->next;
	
	//cur  newnode  next
	cur->next = newnode;
	newnode->prev = cur;
	newnode->next = next;
	next->prev = newnode;
}

void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* cur = phead->next;
	LTNode* next = cur->next;
	//phead  cur  next
	phead->next = next;
	next->prev = phead;
	free(cur);
	cur = NULL;
}

void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* newnode = BuyLTNode(x);
	LTNode* tail = phead->prev;
	

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

void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;
	
	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
}

void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* newnode = BuyLTNode(x);

	LTNode* posprev = pos->prev;

	//posprev  newnode  pos
	posprev->next = newnode;
	newnode->prev = posprev;
	newnode->next = pos;
	pos->prev = newnode;
}

void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* posprev = pos->prev;
	LTNode* posnext = pos->next;
	posprev->next = posnext;
	posnext->prev = posprev;
	free(pos);
	pos = NULL;
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

顺序表和链表.pdf
04-24
本文档主要介绍顺序表和链表这两种基本的数据结构。在计算机科学中，数据结构是指在计算机中组织和存储数据的一种特殊方式，它允许高效地访问和修改数据。顺序表和链表作为线性表的两种实现方式，在实际应用中非常...
Java顺序表和链表
xinhang10的博客
11-14 2014
此文章对Java数据结构中的顺序表和链表进行了十分细致的讲解，并为大家演示了如何从0开始创建一个顺序表和链表，并将他们编写成一个完整的顺序表(链表)。在此基础上，作者还为大家贴心的准备了10个链表的练习题，并将他们详细的讲解了一遍，相信这对初入数据结构的同学们来说一定是一个好的练习。在练习题后面我们还为大家附上了力扣和牛客网的链表练习题链接，有需要的小伙伴可以自己点击。在文章的最后，我们为大家分析了链表和顺序表到底有什么区别……
顺序表和链表的比较
icbbm的博客
08-04 3800
综上所述，顺序表适用于数据元素较少、读取操作频繁的场景，而链表适用于数据元素较多、插入、删除操作频繁的场景。
顺序表和链表的区别
xsc2004zyj的博客
07-19 1001
顺序表和链表其实是两个相辅相成，互补的数据结构，因为他们彼此之前都有自己个优势，也有自己的不足，这里我们来了解一下顺序表和链表的区别。这里的链表指的是带头双向循环链表。
顺序表和链表的优缺点
weixin_57023347的博客
06-21 3941
顺序表 定义：在内存中用地址连续的一块存储空间顺序存放线性表的各元素。在程序设计语言中，一维数组在内存中占用的存储空间是一维连续的存储空间，因此我们用一维数组存储数据来表示顺序表。 优点： 由于顺序表是用数组来存储数据，内存空间连续，当访问数据时可以达到使用数组下标的方式随机访问。 CPU高速缓存的命中率高。 解释： 数据保存在内存中，数据是在CPU里进行运算的(逻辑和算术)。但是CPU速度太快，内存的速度跟不上CPU的速度。于是在CPU和内存之间存在一些寄存器和缓存器，用来保存数据。当CPU要使用数
（C语言）顺序表和链表
博主qq1077644249
08-09 843
线性表（linear list）是n个具有相同特性的数据元素的有限序列。顺序表、链表、栈、队列、字符串。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。静态顺序表：使用定长数组存储元素。动态顺序表：使用动态开辟的数组存储。......
数据结构与算法 - 顺序表与链表的区别
Distinguished_z的博客
10-13 973
顺序表与链表各有优缺，很难说明二者谁更优；准确来说这两个结构之间是相辅相承的关系； 1、顺序表(动态顺序表)： 逻辑结构上是线性的，物理结构上也上一定是线性结构 支持随机访问(利用下标) 但是在任意位置上插入或者删除数据需要一个一个地挪动数据以保证顺序表结构的连续性，时间复杂度为O(N)，效率不高； 并且插入数据，会面临扩容的问题，扩容本身就存在消耗，就地扩容消耗不大(开辟空间，返回该空间的地址)，但倘若是异地扩容，便会找新空间，拷贝旧空间的数据到新空间中，释放旧空间中的数据，返回新空间的地址；并且扩容的
线性表——顺序表和链表
qq_65285898的博客
08-21 3714
顺序表和链表的解释与实现
【数据结构】顺序表和链表的优缺点
Eraser的博客
04-21 2607
经过这么多对比，可以发现顺序表和链表就是互补的存在，两个都有存在的意义和自己擅长的领域。
顺序表和链表（单链表、双链表）的区别|数据结构
qq_74222272的博客
10-26 1820
包含顺序表、单链表和双向链表的区别以及常用的方法函数。
C语言：定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表.zip
09-07
在本资源"C语言：定义一个包含学生信息（学号，姓名，成绩）的顺序表和链表.zip"中，我们将探讨如何使用C语言实现两种常见的数据结构——顺序表和链表，用于存储和管理学生信息。 首先，我们来理解顺序表。顺序表是...
数据结构实验 顺序表和链表
10-08
顺序表和链表的基本实现 数据结构实验 顺序表和链表中，我们可以学习到顺序表和链表的基本操作，包括创建、初始化、销毁、求长、判空、输出、获取元素、插入元素和删除元素等操作。下面是对顺序表和链表的详细介绍...
数据结构顺序表和链表的相关操作
06-30
实现顺序表和链表的建立、取元素、修改元素、插入、删除等顺序表的基本操作。 设计要求: 首先设计一个含有多个菜单项的主菜单程序，然后再为这些菜单项配上相应的功能。 基本操作： 1.依次从键盘读入数据，建立...
数据结构-如果将堆结构应用到TOP-K问题上会怎样？
2201_75587951的博客
06-05 919
本文讲解了如何利用堆结构高效解决TOP-K问题（求前K个最大/最小元素）。针对大数据量场景（如100亿数据），传统排序方法内存消耗过大，而堆结构只需维护K个元素的空间。具体实现时：找前K个最大元素建小堆，将剩余元素逐个与堆顶（最小值）比较，更大则替换并调整；反之，找前K个最小元素建大堆。该方法避免了全局排序，时间复杂度优化至O(NlogK)。文中给出c语言代码实现包括建堆、调整和比较替换流程，适用于海量数据场景。
数据结构-C语言-链表OJ
2201_75587951的博客
06-08 517
本篇讲解了链表分割和合并两个有序链表的问题，并涉及到了哨兵结点的运用，后面会继续讲解其他题目
数据结构-相交链表OJ-如何用环形链表来解决相交链表？
2201_75587951的博客
06-09 612
今天讲解了能够将时间复杂度为控制在 O(m + n) 、空间复杂度 控制在O(1) 的解决相交链表的两种解法，同时涉及了快慢指针的思想
【数据结构】图算法（代码）
最新发布
m0_73911405的博客
06-10 943
这里我用的上一章节中图的邻接矩阵的结构，进行遍历的。这里其实跟二叉树中，层序遍历思想差不多，都是前一个节点带后面的节点(A带B,C,D之后依次类推)当然这里有一个难点就是当我们遍历到B的时候我们插入队列的时候有AEC，但是我们只想要E，因为A已经pop掉了，C在队列中。我们该如何操作？用个数组标记一下全部元素，当前要插入队列中的元素是否用过，也就是说当我们元素插入到队列的时候标记一下。代码理解一下测试结果。
数据结构之栈
weixin_41965831的博客
06-07 708
本文系统介绍了栈的数据结构及其应用。首先讲解了栈的基本概念（LIFO）和常用方法（push/pop/peek等），并给出了基于数组的栈模拟实现代码。重点阐述了5种典型应用场景：1）递归转循环实现逆序打印；2）括号匹配验证；3）逆波兰表达式计算；4）栈序列合法性判断；5）最小栈设计。最后区分了数据结构栈、JVM虚拟机栈和栈帧的概念。全文通过代码示例展示了栈在实际开发中的灵活运用，突出了其作为基础数据结构的重要性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值