线性表（顺序表与链表）

已于 2024-03-20 18:32:52 修改
阅读量111 收藏 4
点赞数 14
分类专栏： 数据结构/算法 C/C++ 文章标签： 链表 数据结构
于 2023-11-07 20:14:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73225182/article/details/134274302
版权

 数据结构、算法总述：数据结构/算法 C/C++-CSDN博客

概念

线性表(List)：零个或多个数据元素的有限序列

1.顺序表

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

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

typedef int SLDataType;

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

void SLInit(SL* psl);//增容
void SLDestroy(SL* psl);//销毁

void SLPrint(SL* psl);
void SLCheckCapacity(SL* psl);

// 头尾插入删除
void SLPushBack(SL* psl, SLDataType x);
void SLPushFront(SL* psl, SLDataType x);
void SLPopBack(SL* psl);
void SLPopFront(SL* psl);

// 任意下标位置的插入删除
void SLInsert(SL* psl, int pos, SLDataType x);
void SLErase(SL* psl, int pos);

// 找到返回下标
// 没有找到返回-1
int SLFind(SL* psl, SLDataType x);

实现：

void SLInit(SL* psl)
{
	assert(psl);

	psl->a = NULL;
	psl->size = 0;
	psl->capacity = 0;
}

void SLDestroy(SL* psl)
{
	assert(psl);

	if (psl->a != NULL)
	{
		free(psl->a);
		psl->a = NULL;
		psl->size = 0;
		psl->capacity = 0;
	}
}

void SLPrint(SL* psl)
{
	assert(psl);

	for (int i = 0; i < psl->size; i++)
	{
		printf("%d ", psl->a[i]);
	}
	printf("\n");
}

void SLCheckCapacity(SL* psl)
{
	assert(psl);

	if (psl->size == psl->capacity)
	{
		int newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(psl->a, sizeof(SLDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		psl->a = tmp;
		psl->capacity = newCapacity;
	}
}

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

	SLCheckCapacity(psl);

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

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

	SLCheckCapacity(psl);

	// 挪动数据
	int end = psl->size - 1;
	while (end >= 0)
	{
		psl->a[end + 1] = psl->a[end];
		--end;
	}

	psl->a[0] = x;
	psl->size++;
}

void SLPopBack(SL* psl)
{
	assert(psl);

	// 温柔的检查
	/*if (psl->size == 0)
	{
		return;
	}*/

	// 暴力检查
	assert(psl->size > 0);

	psl->size--;
}


void SLPopFront(SL* psl)
{
	assert(psl);

	// 暴力检查
	assert(psl->size > 0);

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

	psl->size--;
}

// 注意pos是下标
// size是数据个数，看做下标的话，他是最后一个数据的下一个位置
void SLInsert(SL* psl, int pos, SLDataType x)
{
	assert(psl);
	assert(pos >= 0 && pos <= psl->size);

	SLCheckCapacity(psl);

	// 挪动数据
	int end = psl->size - 1;
	while (end >= pos)
	{
		psl->a[end + 1] = psl->a[end];
		--end;
	}

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

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

	// 挪动覆盖
	int begin = pos + 1;
	while (begin < psl->size)
	{
		psl->a[begin - 1] = psl->a[begin];
		++begin;
	}

	psl->size--;
}

int SLFind(SL* psl, SLDataType x)
{
	assert(psl);

	for (int i = 0; i < psl->size; i++)
	{
		if (psl->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}

 优缺点：

优点：

1.无须为表中元素之间的逻辑关系而增加额外的存储空间

2.可以快速地存取表中任意位置的元素

缺点：

1.插入和删除操作需要移动大量元素

2.当线性表长度变化较大时，难以确定存储空间的容量

3.造成存储空间的“碎片”

2.链表

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

链表分类：

 单向或双向

带头或不带头

循环或非循环

 

单链表 （指针实现）

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

typedef int SLNDataType;

// Single List
typedef struct SListNode
{
	SLNDataType val;
	struct SListNode* next;
}SLNode;

void SLTPrint(SLNode* phead);

void SLTPushBack(SLNode** pphead, SLNDataType x);
void SLTPushFront(SLNode** pphead, SLNDataType x);
void SLTPopBack(SLNode** pphead);
void SLTPopFront(SLNode** pphead);

SLNode* SLTFind(SLNode* phead, SLNDataType x);

// 在pos的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x);

// 删除pos位置
void SLTErase(SLNode** pphead, SLNode* pos);

// 后面插入 后面删除
void SLTInsertAfter(SLNode* pos, SLNDataType x);
void SLTEraseAfter(SLNode* pos);


void SLTDestroy(SLNode** pphead);

实现：

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

SLNode* CreateNode(SLNDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

void SLTPushBack(SLNode** pphead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		// 找尾
		SLNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

void SLTPushFront(SLNode** pphead, SLNDataType x)
{
	SLNode* newnode = CreateNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SLTPopBack(SLNode** pphead)
{
	// 空
	assert(*pphead);

	// 1、一个节点
	// 2、一个以上节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLNode* tail = *pphead;
		while (tail->next->next != NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}

void SLTPopFront(SLNode** pphead)
{
	assert(*pphead);

	// 一个以上节点 + 一个
	SLNode* tmp = *pphead;
	free(tmp);
	*pphead = (*pphead)->next;
}

SLNode* SLTFind(SLNode* phead, SLNDataType x)
{
	SLNode* cur = phead;
	while (cur)
	{
		if (cur->val == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}

	return NULL;
}

void SLTInsert(SLNode** pphead, SLNode* pos, SLNDataType x)
{
	// 严格限定pos一定是链表里面的一个有效节点
	assert(pphead);
	assert(pos);
	assert(*pphead);

	if (*pphead == pos)
	{
		// 头插
		SLTPushFront(pphead, x);
	}
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		SLNode* newnode = CreateNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

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

	if (*pphead == pos)
	{
		// 头删
		SLTPopFront(pphead);
	}
	else
	{
		SLNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

void SLTInsertAfter(SLNode* pos, SLNDataType x)
{
	assert(pos);
	SLNode* newnode = CreateNode(x);

	newnode->next = pos->next;
	pos->next = newnode;
}

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

	SLNode* tmp = pos->next;
	pos->next = pos->next->next;

	free(tmp);
	tmp = NULL;
}

void SLTDestroy(SLNode** pphead)
{
	assert(pphead);

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

	*pphead = NULL;
}

双向链表（指针实现）

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

typedef int LTDataType;

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

LTNode* LTInit();
void LTPrint(LTNode* phead);

//头尾删插
void LTPushBack(LTNode* phead, LTDataType x);
void LTPopBack(LTNode* phead);
void LTPushFront(LTNode* phead, LTDataType x);
void LTPopFront(LTNode* phead);

//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

//pos前插入
void LTInsert(LTNode* pos, LTDataType x);

//删除pos位
void LTErase(LTNode* pos);

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

实现：

#include"List.h"

LTNode* CreateLTNode(LTDataType x)
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->val = x;
	newnode->next = NULL;
	newnode->prev = NULL;

	return newnode;
}

LTNode* LTInit()
{
	LTNode* phead = CreateLTNode(-1);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void LTPrint(LTNode* phead)
{
	assert(phead);
	printf("哨兵位<=>");

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

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

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

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

	LTInsert(phead, x);
}

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

	// 空
	assert(phead->next != phead);

	//LTNode* tail = phead->prev;
	//LTNode* tailPrev = tail->prev;

	//free(tail);
	//tailPrev->next = phead;
	//phead->prev = tailPrev;

	LTErase(phead->prev);
}

void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	//LTNode* newnode = CreateLTNode(x);
	//LTNode* first = phead->next;

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

	LTInsert(phead->next, x);
}

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

	//LTNode* first = phead->next;
	//LTNode* second = first->next;

	//phead->next = second;
	//second->prev = phead;
	//free(first);
	//first = NULL;
	LTErase(phead->next);
}

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

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

		cur = cur->next;
	}

	return NULL;
}

// 在pos前面的插入
void LTInsert(LTNode* pos, LTDataType x)
{
	assert(pos);

	LTNode* posPrev = pos->prev;
	LTNode* newnode = CreateLTNode(x);

	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

// 删除pos位置
void LTErase(LTNode* pos)
{
	assert(pos);

	LTNode* posNext = pos->next;
	LTNode* posPrev = pos->prev;

	posPrev->next = posNext;
	posNext->prev = posPrev;
	free(pos);
}

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

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

	free(phead);
}

顺序表与链表的区别 

不同点顺序表链表
存储空间上物理上一定连续逻辑上连续，物理上不一定
随机访问

支持；O(1)

不支持；O(N)
任意位置上插入或删除

可能需要搬移元素，效率低

O(N)

只需修改指针指向
插入

动态顺序表，

空间不够时需要扩容

没有容量的概念
应用场景元素高效存储+频繁访问频繁插入删除
缓存利用率高低

算法模板（数组模拟）

单链表

// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;

// 初始化
void init()
{
    head = -1;
    idx = 0;
}

// 在链表头插入一个数a
void insert(int a)
{
    e[idx] = a, ne[idx] = head, head = idx ++ ;
}

// 在位置k后添加节点x
void add(int k,int x)
{
    e[idx] = x, ne[idx] = ne[k], ne[k] = idx ++ ;
}

// 将头结点删除，需要保证头结点存在
void remove()
{
    head = ne[head];
}

 题目：826. 单链表 - AcWing题库icon-default.png?t=N7T8https://www.acwing.com/problem/content/828/

双向链表

// e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
int e[N], l[N], r[N], idx;

// 初始化
void init()
{
    //0是左端点，1是右端点
    r[0] = 1, l[1] = 0;
    idx = 2;
}

// 在节点k的右边插入一个数x
void insert(int k, int x)
{
    e[idx] = x;
    l[idx] = k, r[idx] = r[k];
    l[r[k]] = idx, r[k] = idx ++ ;
}

// 删除节点k
void remove(int k)
{
    l[r[k]] = l[k];
    r[l[k]] = r[k];
}

 题目：

827. 双链表 - AcWing题库icon-default.png?t=N7T8https://www.acwing.com/problem/content/829/

禊月初三
关注
  • 14
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
数据结构Java线性表顺序表与链表小结PPT学习教案.pptx
10-05
数据结构Java线性表顺序表与链表小结PPT学习教案.pptx
线性表——顺序表和链表
qq_65285898的博客
08-21 2899
顺序表和链表的解释与实现
5.线性表：顺序表与链表
speedwalkman的专栏
07-02 731
本章主要介绍线性表的定义，线性表的顺序存储和链式存储，线性表的前驱和后继。以及顺序表(顺序存储结构)与链表（单链表），顺序表与数组的关系和区别和顺序表与链表（单链表）的基本操作。
线性表--顺序表与链表
Pert的博客
10-14 928
物理结构是逻辑结构在计算机中的存储形式 数据的存储结构中的顺序存储结构能正确反映数据元素之间的逻辑关系，而链式存储结构不能 线性表 （1、线性表是具有（ 零个 ）或 （多个 ）数据元素的（ 有限 ）序列。 ** 线性表中数据元素之间的关系是（ 一对一 ）的关系，即除了第一个和最后一个数据元素之外，其他数据元素都是（ 首尾相连 ）的** （2、线性表的基本特征： ** 1、第一个数据元素没有前驱元素** ** 2、最后一个数据元素没有后继元素** ** 3、其余每个数据元素只有一个前驱元.
线性表、顺序表和链表
adong6561975的博客
02-07 706
线性表的定义 线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，其中n为表长，当n=0时该线性表是一个空表。若用L命名线性表，则其一般可以表示为 L=(a1,a2,...,ai,ai+1,...,an) ...
线性表、顺序表与链表
一只向往森林的菜鸟
04-08 233
线性表、顺序表与链表1.认识 List 线性表1.1 概念1.2存储结构2.ArrayList:顺序表3.链表3.1概念分类4顺序表和链表的区别与联系 1.认识 List 线性表 1.1 概念 线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛应用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串等。 1.2存储结构 线性表在逻辑上是线性结构，也就是说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式
数据结构实验线性表（用java创建顺序表与链表并解决实验题目）
05-10
（1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点...
04 2 线性表3-其它链表1
08-03
第二章 线性表2.1 线性表的类型定义2.2 线性表的顺序表示和实现2.3 线性表的链式表示和实现2.4 一元多项式的表示和实现上节复习链表是线性表的链式存储表
2第二章 线性表（顺序表 链表）.pdf
04-20
2第二章 线性表（顺序表 链表）.pdf
北京工业大学 数据结构与算法 （电控学院） 第二章线性表实验 顺序表 链表 约瑟夫环
03-29
顺序表；2.线性链表；3.约瑟夫环。 北工大电控学院《数据结构与算法》课程的其它章节程序实验及作业代码亦已在本站上传，需要的同学可进入作者的空间或通过搜索获取。本代码为上传者原创，仅供个人学习参考使用，...
P2【练习力扣933】【数据结构】【队列queue】C++版
qq_50891451的博客
05-18 471
，范围是 [-2900,100]，返回 2。]，范围是 [-2999,1]，返回 1。]，范围是 [1,3001]，返回 3。]，范围是 [2,3002]，返回 3。类来计算特定时间范围内最近的请求。的调用都使用比之前更大的。
数据结构——二叉树知识点详解！
hu_ju_hong的博客
05-15 656
数据结构二叉树概念超详细讲解！同时也是学习数据结构——堆的必修课！
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
最新发布
qq_50891451的博客
05-22 390
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
P0【知识点】【数据结构】【数组Array】讲解C++版
qq_50891451的博客
05-16 223
大O表示法 O(1) < O(logN) < O(N) < O(NlogN) < O(N^2) < O(2^N)at() 这个方法返回的是一个引用，可以吧一个常量 int 赋值给它。数组索引（Access）：是通过数组的下标去找这个元素。大O表示法 O(1) < O(N) < O(N^2)数组搜索（Search）：是找这个元素的位置（索引）3.插入 Insert O(N)4.删除 Delete O(N)1.访问access O(1)2.搜索search O(N)【485】最大连续1的个数。
数据结构——AVL树
mastershooter的博客
05-16 981
在结点的定义中，我们直接定义成KV模型的结点，并新增一个平衡因子，还有一个_parent指针，也就是说，该结点拥有三个指针+一对键值对+一个平衡因子，在初始化时指针都初始化为空，平衡因子设定成0。//左子树指针//右子树指针//每个结点都包含了一个父结点地址//键值对int _bf;//平衡因子//构造函数, _kv(kv), _bf(0){}
P6【知识点】【数据结构】【树tree】C++版
qq_50891451的博客
05-22 100
普通二叉树：每个结点最多两个孩子满二叉树：除了叶子结点，每个节点都有两个孩子，且叶子节点在同一层上完全二叉树：从树的根节点，从上到下，从左到右依次填满节点形成的二叉树。
图论算法＜六＞：数据结构之图Graph详解及代码实现
欧特GO
05-16 717
数据结构之图Graph详解及代码实现,包括概念、术语、基础实现代码、BFS/DFS。
数据结构 之 Map & Set
AUGENSTERN_dc的博客
05-18 959
Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的 搜索方式有： 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢 二分查找，时间复杂度为,但搜索前必须要求序列是有序的 上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找比如： 根据姓名查询考试成绩 通讯录，即根据姓名查询联系方式 不重复集合，即需要先搜索关键字是否已经在集合中 可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本
P4【知识点】【数据结构】【哈希表】C++版
qq_50891451的博客
05-20 743
此博客参考。
C++线性表是链表嘛
09-01
除了链表，还有顺序表等其他实现线性表的方式。在C语言中，链表可以通过定义一个结构体来表示每个节点，每个节点包含数据和指向下一个节点的指针。通过不断创建新节点并将它们连接起来，就可以实现链表。所以可以说...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

禊月初三

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值