数据结构--顺序表和链表

最新推荐文章于 2024-09-02 10:47:36 发布
最新推荐文章于 2024-09-02 10:47:36 发布
阅读量386 收藏 3
点赞数 7
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69544758/article/details/129480643
版权

目录

一、 线性表

1.线性表
线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
在这里插入图片描述

二、 顺序表

2.1概念及结构

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

  1. 静态顺序表：使用定长数组存储元素。
    在这里插入图片描述
  2. 动态顺序表：使用动态开辟的数组存储。
    3.

2.2顺序表的实现

.h文件

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

#define INIT_CAPACITY 4
typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);

void SeqListPrint(SeqList* ps);
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);

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

.c文件

#include"SeqList.h"

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps)
{
	ps->a = (SLDateType*)malloc(sizeof(SLDateType)* INIT_CAPACITY);
	ps->capacity = INIT_CAPACITY;
	ps->size = 0;
}
void SeqListDestroy(SeqList* ps)
{
	free(ps->a);
	ps->capacity = INIT_CAPACITY;
	ps->size = 0;
}

void SeqListPrint(SeqList* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	if (ps->size == ps->capacity)
	{
		ps->capacity *= 2;
		SLDateType* temp = (SLDateType*)realloc(ps->a,sizeof(SLDateType) * ps->capacity);
		ps->a = temp;
	}
	ps->a[ps->size++] = x;

}
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	if (ps->size == ps->capacity)
	{
		ps->capacity *= 2;
		SLDateType* temp = (SLDateType*)realloc(ps->a, sizeof(SLDateType) * ps->capacity);
		ps->a = temp;
	}
	ps->size++;
	for (int i = ps->size - 1; i > 0; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
}
void SeqListPopFront(SeqList* ps)
{
	assert(ps->size > 0);
	for (int i = 0; i < ps->size-1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
	
}
void SeqListPopBack(SeqList* ps)
{
	assert(ps->size > 0);
	ps->size--;
}

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

2.3顺序表的总结

1.中间/头部的插入删除，时间复杂度为O(N)
2.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

三、 链表

3.1链表的概念及结构

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

3.2链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
在这里插入图片描述
在这里插入图片描述

3.3单链表的实现

.h文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
typedef int DATETYPE;
typedef struct LINKLIST
{
	DATETYPE date;
	struct LINKLIST* next;

}LinkList;

//打印链表
void Print_Linklist(LinkList* list);

//头插链表
void PushFront_LinkList(LinkList** list, DATETYPE value);

//头删链表
void PopFront_LinkList(LinkList** list);

//尾插链表
void PushBack_LinkList(LinkList** list, DATETYPE value);

//尾删链表
void PopBack_LinkList(LinkList** list);

//查找
LinkList* Find_LinkList(LinkList* list, DATETYPE value);

//在pos位置之前插入结点
void InsertByPos_LinkList(LinkList** list, int pos, DATETYPE value);

//在pos位置之前插入结点
void InsertByPointer_LinkList(LinkList** list, LinkList* pos, DATETYPE value);

//在pos后面插入，这个更合适也跟简单
void InsertByPointerAfter_LinkList(LinkList* pos, DATETYPE value);

//删除pos位置链表
void Erase_LinkList(LinkList** list, LinkList* pos);

//删除pos位置后的链表
void EraseAfter_LinkList(LinkList* pos);

//销毁链表
void Destory_LinkList(LinkList** list);

.c文件

#include"SList.h"
//打印链表
void Print_Linklist(LinkList* list)
{
	LinkList* pCurrent = list;
	while (pCurrent != NULL)
	{
		printf("%d ", pCurrent->date);
		pCurrent = pCurrent->next;
	}
	printf("NULL\n");
}

//头插链表
void PushFront_LinkList(LinkList** list, DATETYPE value)
{
	//创建新结点
	LinkList* newnode = (LinkList*)malloc(sizeof(LinkList));
	newnode->date = value;
	newnode->next = *list;
	(*list) = newnode;
}

//尾插链表
void PushBack_LinkList(LinkList** list, DATETYPE value)
{
	//创建新结点
	LinkList* newnode = (LinkList*)malloc(sizeof(LinkList));
	newnode->date = value;
	newnode->next = NULL;
	LinkList* pCurrent = *list;
	if (*list == NULL)
	{
		*list = newnode;
	}
	else
	{
		//查找结点
		while (pCurrent->next != NULL)
		{
			pCurrent = pCurrent->next;
		}
		pCurrent->next = newnode;
	}

}

//头删链表
void PopFront_LinkList(LinkList** list)
{
	assert(*list);
	LinkList* phead = *list;
	*list = phead->next;
	free(phead);

}

//尾删链表
void PopBack_LinkList(LinkList** list)
{
	assert(*list);
	LinkList* pCurrent = *list;
	LinkList* previous = NULL;
	if ((*list)->next == NULL)
	{
		free((*list)->next);
		*list = NULL;
	}
	else
	{
		//找结点
		while (pCurrent->next != NULL)
		{
			previous = pCurrent;
			pCurrent = pCurrent->next;
		}
		free(pCurrent);
		previous->next = NULL;
	}
}

//查找
LinkList* Find_LinkList(LinkList* list, DATETYPE value)
{
	assert(list);
	LinkList* pCurrent = list;
	while (pCurrent != NULL)
	{
		if (pCurrent->date == value)
		{
			return pCurrent;
		}
		pCurrent = pCurrent->next;
	}
	return NULL;
}

//在pos位置之前插入结点
void InsertByPos_LinkList(LinkList** list, int pos, DATETYPE value)
{
	assert(pos >= 0);
	LinkList* pCurrent = *list;
	//创建新的结点
	LinkList* newnode = (LinkList*)malloc(sizeof(LinkList));
	newnode->date = value;
	newnode->next = NULL;
	if (pos==0)
	{
		//头插
		newnode->next = *list;
		*list = newnode;
	}
	else
	{
		//找结点
		for (int i = 1; i < pos; i++)
		{
			pCurrent = pCurrent->next;
		}
		newnode->next = pCurrent->next;
		pCurrent->next = newnode;
	}
}

//在pos位置之前插入结点
void InsertByPointer_LinkList(LinkList** list, LinkList* pos, DATETYPE value)
{
	assert(pos);
	LinkList* pCurrent = *list;
	//创建新的结点
	LinkList* newnode = (LinkList*)malloc(sizeof(LinkList));
	newnode->date = value;
	newnode->next = NULL;
	if (pos == *list)
	{
		//头插
		newnode->next = *list;
		*list = newnode;
	}
	else
	{
		//找结点
		while (pCurrent->next != pos)
		{
			pCurrent = pCurrent->next;
		}
		newnode->next = pos;
		pCurrent->next = newnode;
	}
}

//在pos后面插入，这个更合适也跟简单
void InsertByPointerAfter_LinkList(LinkList* pos, DATETYPE value)
{
	assert(pos);
	//创建新结点
	LinkList* newnode = (LinkList*)malloc(sizeof(LinkList));
	newnode->date = value;
	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos位置链表
void Erase_LinkList(LinkList** list, LinkList* pos)
{
	assert(pos);
	if (pos == *list)
	{
		*list = (*list)->next;
		free(pos);
	}
	else
	{
		//找结点
		LinkList* pCurrent = *list;
		while (pCurrent->next != pos)
		{
			pCurrent = pCurrent->next;
		}
		pCurrent->next = pos->next;
		free(pos);
	}
}

//删除pos位置后的链表
void EraseAfter_LinkList(LinkList* pos)
{
	assert(pos);
	LinkList* next = pos->next;
	pos->next = next->next;
	free(next);
}

//销毁链表
void Destory_LinkList(LinkList** list)
{
	LinkList* pCurrent = *list;
	while (pCurrent != NULL)
	{
		//缓存下一个结点
		LinkList* next = pCurrent->next;
		free(pCurrent);
		pCurrent = next;
	}
	*list = NULL;
}

3.4双向带头循环链表的实现

.h文件

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int DATATYPE;
typedef struct DoubleLinkedLists
{
	struct DoubleLinkedLists* pre;
	struct DoubleLinkedLists* next;
	DATATYPE value;
}LinkList;
//初始化链表
LinkList* Init_LinkList();
//头插
void PushFront_LinkList(LinkList* list, DATATYPE value);
//尾插
void PushBack_LinkList(LinkList* list, DATATYPE value);
//头删
void PopFront_LinkList(LinkList* list);
//尾删
void PopBack_LinkList(LinkList* list);
//打印链表
void Print_LinkList(LinkList* list);
//销毁链表
void Destroy_LinkList(LinkList* list);
//查找
LinkList* Find_LinkList(LinkList* list, DATATYPE value);
//在pos位置前插入
void Insert_LinkList(LinkList* pos, DATATYPE value);
//删掉pos位置结点
void Erase_LinkList(LinkList* pos);

.c文件

#include"DoubleLinkedLists.h"
//初始化链表
LinkList* Init_LinkList()
{
	LinkList* Phead = (LinkList*)malloc(sizeof(LinkList));
	Phead->next = Phead;
	Phead->pre = Phead;
	Phead->value = 0;
	return Phead;
}
//头插
void PushFront_LinkList(LinkList* list, DATATYPE value)
{
	assert(list);

	//LinkList* Newnode = (LinkList*)malloc(sizeof(LinkList));
	//Newnode->value = value;

	//LinkList* next = list->next;

	//list->next = Newnode;
	//Newnode->pre = list;
	//Newnode->next = next;
	//next->pre = Newnode;

	Insert_LinkList(list->next, value);
}
//尾插
void PushBack_LinkList(LinkList* list, DATATYPE value)
{
	assert(list);

	//LinkList* Newnode = (LinkList*)malloc(sizeof(LinkList));
	//Newnode->value = value;

	//LinkList* tail = list->pre;

	//tail->next = Newnode;
	//Newnode->pre = tail;
	//Newnode->next = list;
	//list->pre = Newnode;
	Insert_LinkList(list, value);
}
//头删
void PopFront_LinkList(LinkList* list)
{
	assert(list);
	assert(list->next != list);

	//LinkList* next = list->next;

	//list->next = next->next;
	//next->next->pre = list;

	//free(next);

	Erase_LinkList(list->next);

}
//尾删
void PopBack_LinkList(LinkList* list)
{
	assert(list);
	//防止哨兵位结点被删除
	//assert(list->next != list);
	//LinkList* tail = list->pre;

	//tail->pre->next = list;
	//list->pre = tail->pre;

	//free(tail);

	Erase_LinkList(list->pre);
}
//打印链表
void Print_LinkList(LinkList* list)
{
	LinkList* cur = list->next;
	while (cur != list)
	{
		printf("%d ", cur->value);
		cur = cur->next;
	}
	printf("\n");
}

//查找
LinkList* Find_LinkList(LinkList* list, DATATYPE value)
{
	LinkList* cur = list->next;
	while (cur != list)
	{
		if (cur->value == value)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//在pos位置前插入
void Insert_LinkList(LinkList* pos, DATATYPE value)
{
	LinkList* newnode = (LinkList*)malloc(sizeof(LinkList));
	newnode->value = value;

	LinkList* pospre = pos->pre;

	pospre->next = newnode;
	newnode->pre = pospre;

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

//删掉pos位置结点
void Erase_LinkList(LinkList* pos)
{
	LinkList* pospre = pos->pre;
	LinkList* posnext = pos->next;

	pospre->next = posnext;
	posnext->pre = pospre;

	free(pos);
}


//销毁链表
void Destroy_LinkList(LinkList* list)
{
	assert(list);
	LinkList* cur = list->next;
	while (cur != list)
	{
		LinkList* next = cur->next;
		free(cur);
		cur = next;
	}
	list->next = NULL;
	list->pre = NULL;
}

3.5关于链表的一些题

http://t.csdn.cn/X0YR5

四、 总结

不同点顺序表链表
存储空间上物理上一定连续逻辑上连续，单物理上不一定连续
随机访问O(1)O(n)
任意位置插入或删除元素可能需要搬移元素，效率低O（n ）只需要修改指针指向
插入动态顺序表，内存不够时需要扩容没有容量的概念，不浪费空间
应用场景元素高效存储+频繁访问任意位置插入和删除频繁
缓存利用率高低
龙里出生的蛋
关注
数据结构---顺序表和链表
qq_47406941的博客
01-02 874
一、线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列，是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 二、顺序表 1.基本概念 2.实现 三、链表 ...
数据结构和算法-2.顺序表与链表
08-10
这份笔记深入解析了计算机科学中两种最基本的数据结构——顺序表与链表的原理、实现以及实际应用。通过对比顺序表和链表的不同特点，你将了解到它们各自的优势与适用场景。例如，笔记详细阐述了顺序表的扩展机制、...
数据结构---顺序表，链表
includeevey的博客
08-03 2633
2w字带你走进链表
数据结构之顺序链表
PurpleDream的博客
02-09 387
数据结构 顺序表，链表。
最新发布
maydayisyouandme的博客
09-02 1020
队列初学之后，我在回顾下之前的顺序表，链表之类的各种概念及其实现提示：以下是本篇文章正文内容，下面案例可供参考//单链表结点的存储结构//数据域//指向下一个结点的指针域大致讲述了各种表的基础概念，并且列举了链表和不定长顺序表的基础操作。这次先到此为止，下次总给双向循环链表的代码，小生浅薄，有不足之处，望诸位看官多多包涵不吝赐教。salute！！！！
《数据结构》——顺序表和链表
bang___bang_的博客
08-06 383
本人的学习线性表记录
数据结构试验1-链表和顺序表
03-08
在这个实验中，我们将专注于两种基本的数据结构：链表和顺序表。这两种结构在编程和算法设计中起着至关重要的作用。 首先，我们来看**链表**。链表是一种线性数据结构，与数组不同，它在内存中不是连续存储的。每个...
数据结构_1.顺序链表
鲁信的专栏
12-10 781
<br />所有的链表都应该有一下功能：<br />（1）获取链表长度<br />（2）清楚链表全部项<br />（3）判断链表是否为空<br />（4）判断链表是否已满<br />（5）在链表末尾添加新项<br />（6）在链表指定位置插入新项<br />（7）在链表指定位置删除项目<br />（8）根据输入项的序号返回链表项<br />（9）根据输入列表项的值返回该项的序号<br />在这里定义一个借口，约束所有的链表类都必须实现该借口，列表代码如下：<br /> <br /> interface IL
数据结构与算法-顺序链表
weixin_30378311的博客
02-27 86
我们首先来看几个概念： 线性数据结构的特点： (1)存在唯一的一个被称作“第一个”的数据元素； (2)存在唯一的一个被称为“最后一个”的数据元素； (3)除第一个之外，集合中的每个数据元素均只有一个前驱； (4)除了最后一个之外，集合中每个数据元素均只有一个后继。 线性表: 线性表是最基本、最简单、也是最常用的一种线性数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和...
数据结构：顺序表+链表
Eliaukqwe的博客
07-09 901
LinkedList本质上是一个双向链表，由于链表没有将元素存储在连续的空间之中，元素存储在单独的节点之中，然后通过引用节点将节点连接起来了，因此在插入或删除元素的时候，不需要搬移元素，效率较高//尾插45//在3这个位置插入10这个数字//删除2位置这个元素//获取下标为2的元素的值//把下标为2的位置的值改为199//查看此链表中是否含有199这个数字//返回这个链表中第一次出现199这个元素的下标。
数据结构01单链表和顺序表
sunshinecandy的博客
01-10 219
1单链表 1.1单链表介绍 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结 点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位 置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址 数据。定义如下： typedefstructNode { intdata; structNode*next; }Node,*Li...
数据结构——顺序表，链表
Lucky_mzc的博客
03-06 444
一. 数据结构概述 数据结构（Data Structure）是一门研究数据的组织和管理的学科。往往从外在表现为一组数据的集合或者容器。 概念解释： 元素（Element）：被管理的原子数据，元素类型不限。 集合（Collection）：存放元素的容器，需要利用一定的数据结构知识对元素进行组织。 遍历（Traversal）/ 迭代（Iterate）：在数据结构的语境下，往往表示对一个集合中的所有元素都按 照一定的顺序处理一次。 数据逻辑结构：指反映数据元素之间的逻辑关系的数据结构，其中的逻辑结构是
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
在数据结构中，顺序表和链表是两种重要的线性数据结构。线性表是由n个具有相同特性数据元素的有限序列组成，逻辑上呈现线性顺序，但在物理存储上可以是连续或非连续的。顺序表和链表是线性表的两种常见实现方式。 1...
【数据结构】顺序表和链表
muyuteacher的博客
05-22 325
顺序表和链表是数据结构中常用的两种数据存储方式。顺序表是一种线性数据结构，它由一组相同类型的数据元素组成，这些元素按照一定的顺序排列。顺序表的实现方式是用数组来存储元素，同时记录表的长度和容量。链表的大小可以动态地改变，可以在表的任意位置插入或删除元素
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值