DS-顺序表/链表

已于 2023-05-23 23:52:47 修改
阅读量74 收藏
点赞数
文章标签： 链表 数据结构 算法
于 2023-05-12 22:09:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Emilia_is_angel/article/details/130650805
版权

一.线性表

线性表 (linear list) 是n个具有相同特性的数据元素的有限序列。

线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

二.顺序表

1.顺序表的概念与结构

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

顺序表一般可分为：

静态顺序表：使用定长数组存储元素

动态顺序表：使用动态开辟的数组存储。

2.接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

SeqList.h

typedef int SLDateType;//定义数据类型
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;
// 顺序表扩容
void SeqListexpand(SeqList* ps);

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);//初始化
void SeqListDestroy(SeqList* ps);//释放
bool SeqListEmpty(SeqList* ps);//判空
void SeqListPrint(SeqList* ps);//打印
void SeqListPushFront(SeqList* ps, SLDateType x);//头插
void SeqListPushBack(SeqList* ps, SLDateType x);//尾插
void SeqListPopFront(SeqList* ps);//头删
void SeqListPopBack(SeqList* ps);//尾删
int SeqListLength(SeqList* ps);//表长

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置的值
int SeqListGet(SeqList* ps, int pos);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

// 归并顺序表
void SeqListMerge(SeqList* ps1, SeqList* ps2, SeqList* ret);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS
#include "SeqList.h"

//顺序表扩容
void SeqListexpand(SeqList* ps)
{
	assert(ps);
	int* temp = realloc(ps->a, SEQ_MAX * sizeof(SLDateType) * 2);
	if (!temp)
	{
		perror("realloc-error");
		exit(1);
	}
	ps->a = temp;
	ps->capacity *= 2;
	return;
}

void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a = (SLDateType*)malloc(SEQ_MAX, sizeof(SLDateType));
	if (!ps->a)
	{
		perror("malloc-error");
		exit(1);
	}
	ps->size = 0;
	ps->capacity = SEQ_MAX;
	return;
}
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	int* temp = ps->a;
	ps->a = NULL;
	free(ps->a);
	ps->size = ps->capacity = 0;
	return;
}

bool SeqListEmpty(SeqList* ps)
{
	assert(ps);
	if (ps->size == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void SeqListPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
	return;
}
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);
	if (ps->size >= ps->capacity)
	{
		SeqListexpand(ps);
	}
	ps->size++;
	for (int i = ps->size - 1; i > 0; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	return;
}
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	if (ps->size >= ps->capacity)
	{
		SeqListexpand(ps);
	}
	ps->a[ps->size++] = x;
	return;
}
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
	return;
}
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size);
	ps->size--;
	return;
}


int SeqListLength(SeqList* ps)
{
	assert(&ps);
	return ps->size;
}

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	if (pos >= 0 && pos <= ps->size)
	{
		if (ps->size >= ps->capacity)
		{
			SeqListexpand(ps);
		}
		for (int i = ps->size; i > pos; i--)
		{
			ps->a[i] = ps->a[i - 1];
		}
		ps->size++;
		ps->a[pos] = x;
	}
	return;
}

// 顺序表在pos位置的值
int SeqListGet(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	return ps->a[pos];
}

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	if (pos >= 0 && pos <= ps->size)
	{
		assert(ps->size);
		for (int i = pos; i < ps->size - 1 ; i++)
		{
			ps->a[i] = ps->a[i + 1];
		}
		ps->size--;
	}
	return;
}

// 归并顺序表
void SeqListMerge(SeqList* ps1, SeqList* ps2, SeqList* ret)
{
	assert(ps1 && ps2 && ret);
	int i = 0, j = 0, k = 0;
	int sl1_len = SeqListLength(ps1), sl2_len = SeqListLength(ps2);
	while (i < sl1_len && j < sl2_len)
	{
		if (ps1->a[i] <= ps2->a[j])
		{
			SeqListPushBack(ret, ps1->a[i++]);
		}
		else
		{
			SeqListPushBack(ret, ps2->a[j++]);
		}
	}
	while (i < sl1_len)
	{
		SeqListPushBack(ret, ps1->a[i++]);
	}
	while (j < sl2_len)
	{
		SeqListPushBack(ret, ps2->a[j++]);
	}
	return;
}

三.链表

1.链表的概念与结构

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

2.链表的分类

链表的结构非常多样，以下情况组合起来就有8种链表结构：

单向或者双向

带头或者不带头

循环或者非循环

3.链表的实现

SLIst.h

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

typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表的长度
int SListLength(SListNode* plist, int pos);
// 单链表第pos个元素的值
SLTDateType SListGetElem(SListNode* plist, int pos);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);

// 单链表的销毁
void SListDestroy(SListNode* plist);

// 单链表的判空
bool SListEmpty(SListNode* plist);

// 归并链表
SListNode* SListMerge(SListNode* ps1, SListNode* ps2);

SList.c

#include "SList.h"

//动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* Nextnode = malloc(sizeof(SListNode));
	if (!Nextnode)
	{
		perror("malloc fail");
		return NULL;
	}
	Nextnode->data = x;
	Nextnode->next = NULL;
	return Nextnode;
}

//打印单链表
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;
	while (cur)
	{
		printf("%d -> ", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
	return;
}

// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* Newnode = BuySListNode(x);
	SListNode* tail = *pplist;
	if (!*pplist)
	{
		*pplist = Newnode;
	}
	else
	{
		while (tail->next)
		{
			tail = tail->next;
		}
		tail->next = Newnode;
	}
	return;
}

// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* Newnode = BuySListNode(x);
	Newnode->next = *pplist;
	*pplist = Newnode;
}
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	SListNode* tail = *pplist;
	if (!*pplist)
	{
		return;
	}
	else if (!(*pplist)->next)
	{
		*pplist = NULL;
	}
	else
	{
		while (tail->next->next)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
	return;
}
// 单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	if (!*pplist)
	{
		return;
	}
	else
	{
		SListNode* first = *pplist;
		*pplist = (*pplist)->next;
		free(first);
		first = NULL;
	}
}
// 单链表的长度
int SListLength(SListNode* plist, int pos)
{
	assert(plist);
	int count = 0;
	SListNode* cur = plist->next;
	while (cur = cur->next)
	{
		++count;
	}
	return count;
}
// 单链表第pos个元素的值
SLTDateType SListGetElem(SListNode* plist, int pos)
{
	assert(plist);
	SListNode* cur = plist;
	while (pos--)
	{
		assert(cur);
		cur = cur->next;
	}
	assert(cur);
	return cur->data;
}
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	assert(plist);
	SListNode* cur = plist;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	return NULL;
}

// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SListNode* Nextnode = BuySListNode(x);
	Nextnode->next = pos->next;
	pos->next = Nextnode;
	return;
}

// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	assert(pos->next);
	SListNode* temp = pos->next;
	pos->next = pos->next->next;
	free(temp);
	return;
}

// 单链表的销毁
void SListDestroy(SListNode* plist)
{
	SListNode* next = NULL;
	while (plist)
	{
		next = plist->next;
		free(plist);
		plist = next;
	}
}

bool SListEmpty(SListNode* plist)
{
	assert(plist);
	if (plist->next == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}
}

// 归并链表
SListNode* SListMerge(SListNode* ps1, SListNode* ps2)
{
	SListNode* ret = NULL;
	SListNode* tps1 = ps1;
	SListNode* tps2 = ps2;
	while (tps1 != NULL && tps2 != NULL)
	{
		if (tps1->data < tps2->data)
		{
			SListPushBack(&ret, tps1->data);
			tps1 = tps1->next;
		}
		else
		{
			SListPushBack(&ret, tps2->data);
			tps2 = tps2->next;
		}
	}
	while (tps1)
	{
		SListPushBack(&ret, tps1->data);
		tps1 = tps1->next;
	}
	while (tps2)
	{
		SListPushBack(&ret, tps2->data);
		tps2 = tps2->next;
	}
	return ret;
}

4.顺序表与链表的区别

不同点顺序表链表
存储空间上物理上一定连续逻辑上连续，但物理上不一定连续
随机访问支持O(1)不支持：O(N)
任意位置插入或者删除元素可能需要搬移元素，效率低O(N)只需修改指针指向
插入动态顺序表，空间不够时需要扩容没有容量的概念
应用场景元素高效存储+频繁访问任意位置插入和删除频繁
缓存利用率高低
爱蜜莉雅丶Emilia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jmu-ds-顺序表区间元素删除（方法一）
Stephanie17395的博客
10-08 2723
 若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。 输入格式: 三行数据，第一行是顺序表的元素个数，第二行是顺序表的元素，第三行是x和y。 输出格式: 删除元素值在[x,y]之间的所有元素后的顺序表。 输入样例: 10 5 1 9 10 67 12 8 ...
DS-数据结构线性表完美版资料.ppt
12-01
DS-数据结构线性表完美版资料.ppt 线性表是一种常用的数据结构，属于线性结构的范畴。线性表是具有相同数数据类型的n（n≥0）个数数据元素的有有限序列，通常记为：（a1, a2, …, ai-1, ai, ai+1, …, an）。其中，...
DS--顺序表和链表
yirenDM的博客
03-19 824
/**************** Project: List(Sequence List and LinkList) Data: 2021/09/14,2021/11/11整理完毕 Author: Alex_yrdm ****************/ /***************** Part1: Sequence List *****************/ /* Sequence List dynamic allocation: void show(SqList L);
《DS复习---顺序表和链表》
三七年华
08-15 147
本节主要有以下内容： 一、线性表 二、顺序表 三、链表 四、顺序表和链表的区别和联系 一、线性表（Linear List） 1.概念：线性表是n个具有相同特性的数据元素的有限序列。 2.分类：顺序表、链表... 3.特点：线性表在逻辑上是线性结构，也就是说是连续的一条直线。但在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 二、顺序表...
【DS】第二章-顺序表和链表
qq_41669298的博客
10-21 188
第二章 顺序表和链表 顺序表 什么是顺序表   顺序表是物理地址全部连续的存储数据的方式。顺序表分为动态顺序表以及动态的顺序表，静态的顺序表一般很少使用，因为其大小一旦固定不能再进行改变。   顺序表在开发中十分经常使用，因为其方便简单，并且易于操作。数组就是顺序表的一种，因为其在逻辑结构上是线性的，在物理结构上是连续的。由于十分常用在Cpp的STL库中封装了以顺序表为数据结构的vector容器供...
算法题目总结——jmu-ds-顺序表区间元素删除（附带测试点）
ljhsq的博客
03-18 740
jmu-ds-顺序表区间元素删除题目答案测试点注意 题目 答案 #include<stdio.h> #include<math.h> int main() { int n,x,y; scanf("%d",&n); int a[n],temp,i,j,b[n]; for(i=0;i<n;i++) scanf("%d",&a[i]); scanf("%d %d",&x,&y); int count=0,flag=0; i=0,j=0
jmu-ds-顺序表区间元素删除 (15 分)
weixin_51424996的博客
11-07 134
若一个线性表L采用顺序存储结构存储，其中所有的元素为整数。设计一个算法，删除元素值在[x,y]之间的所有元素，要求算法的时间复杂度为O(n)，空间复杂度为O(1)。 输入格式: 三行数据，第一行是顺序表的元素个数，第二行是顺序表的元素，第三行是x和y。 输出格式: 删除元素值在[x,y]之间的所有元素后的顺序表。 输入样例: 10 5 1 9 10 67 12 8 33 6 2 3 10 输出样例: 1 67 12 33 2 C语言代码： #include<stdio.h>
合并K个升序链表---2022/02/26
qq_44118744的博客
02-26 229
文章目录题目描述解题思路代码实现性能评估 题目描述 给你一个链表数组，每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中，返回合并后的链表。 题目来源 解题思路 这里有两种解法可以考虑： 首先是队列优先。思路是，把所有链表的头节点放入优先队列中。（补充说明：优先队列与先进先出队列不一样，每次取出的是具有最高优先级的元素。默认情况下，优先队列元素按照自然顺序排序，即数字小的在队头，字符串则按字典序排序。如果需要改变优先级的设定，需要实现Comparator接口。）而后将节点值值最小（涉及到优先级重
jmu-ds- 顺序表删除重复元素(pta,函数)
nizhijun123456的博客
06-27 861
/创建顺序表//输出顺序表//删除顺序表重复元素L：顺序表a：输入数组n。
LeetCode-143-重排链表
玉树临风，仙风道骨
01-21 288
重排链表 题目描述：给定一个单链表 L 的头节点 head ，单链表 L 表示为： L0 → L1 → … → Ln-1 → Ln 请将其重新排列后变为： L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → … 不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例说明请见LeetCode官网。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/reorder-list/ 著作权归领扣网络所有。商业转载请联系官方授权，非商业
lrucacheleetcode-ds-algo:ds-东西
06-29
哈希表提供O(1)的平均时间复杂度来定位元素，而链表则用于维护访问顺序。以下是一个简单的LRU缓存Python实现示例： ```python class Node: def __init__(self, key, value): self.key = key self.value = value ...
DS-Algo-practice-jun
03-28
- **链表**：由一系列节点组成，每个节点包含数据和指向下一个节点的指针。 - **栈**：后进先出（LIFO）的数据结构，主要操作包括压栈（push）和弹栈（pop）。 - **队列**：先进先出（FIFO）的数据结构，主要用于...
go-ds-algo
02-19
【描述】"go-ds-algo" 项目包含了各种常用数据结构（如数组、链表、栈、队列、树、图等）以及常见算法（如排序、查找、图算法等）的实现。通过这个项目，开发者可以学习到如何在 Go 语言环境下有效地设计和实现这些...
DS-Project-Fall-2015
02-15
队列则可能用于事件处理，如怪物的行动顺序；而树结构，如二叉搜索树，可能会用于地图的组织和搜索；图则可以用于表示城堡的地形和路径，以及角色之间的关系。 在算法方面，我们可能用到排序、搜索、图遍历等经典...
c语言（7.23）
fhgfyrsg的博客
07-23 595
【代码】c语言（7.23）
数据结构：（1）线性表
weixin_71751116的博客
07-24 1044
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
【初阶数据结构】复杂度算法题篇
最新发布
2301_79849925的博客
07-24 332
我们可以先将所有元素翻转，这样尾部的 kmodn 个元素就被移至数组头部，然后我们再翻转 [0,kmodn−1] 区间的元素和 [kmodn,n−1] 区间的元素即能得到最后的答案。该方法基于如下的事实：当我们将数组的元素向右移动 k 次后，尾部 kmodn 个元素会移动至数组头部，其余元素向后移动 kmodn 个位置。时间复杂度：O(n)空间复杂度：O(1)
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 440
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
DS循环链表—约瑟夫环
09-14
初始化时，将所有人按顺序添加到链表中。 2. 选择一个起始位置，例如从第一个人开始。 3. 开始数数，每次数到指定的数字时，移除当前节点，并将指针移到下一个节点。 4. 重复步骤3，直到只剩下最后一个节点为止。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值