个人笔记2（数据结构）

最新推荐文章于 2024-08-20 20:01:22 发布
最新推荐文章于 2024-08-20 20:01:22 发布
阅读量61 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： c语言 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63539102/article/details/126702771
版权

目录

1.线性表

2.顺序表

3.单链表

4.双向链表

1.线性表

后面还会学二叉树、哈希表等非线性结构。

线性结构：数据是挨着放的，但在内存不一定是挨着放的，是指在结构上是挨着放的，顺序表在内存中就是挨着放的，链表不是。

2.顺序表

顺序表可以理解为数组。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。数据必须从第一个位置开始连续存储。

顺序表一般可分为：

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

在实际当中不实用，对它进行改进：

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

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

接口实现：

在每个函数起始可以加一个 assert(ps != NULL); 或 assert(ps)； 是防止传一个结构体空指针，称之为防御式编程。

初始化顺序表：

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

检查：

检查容量空间，满了要扩容

void SeqListCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}

尾插：

void SeqListPushBack(SL* ps, SLDataType x)
{
	SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;
}

也可以复用“在任意位置插入”函数：

void SeqListPushBack(SL* ps, SLDataType x)
{
    SeqListInsert(ps, size, x);
}

尾删：

越界是不一定报错的，系统对越界的检查是设岗抽查

void SeqListPopBack(SL* ps)
{
	//assert(ps->size > 0); 暴力检查
	//可以直接知道哪行出问题
	if (ps->size == 0)
	{
		printf("SeqList is empty\n");
		return;
	}//温柔检查
	ps->size--;
}

也可以复用“删除任意位置”函数：

void SeqListPopBack(SL* ps)
{
	eqListErase(ps, ps->size - 1);
}

头插：

void SeqListPushFront(SL* ps, SLDataType x)
{
	seqlistcheckcapacity(ps);
	//挪动数据
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

 也可以复用“在任意位置插入”函数：

void SeqListPushFront(SL* ps, SLDataType x)
{
	SeqListInsert(ps, 0, x);
}

头删：

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

 也可以复用“删除任意位置”函数：

void SeqListPopFront(SL* ps)
{
    SeqListErase(ps, 0);
}

打印顺序表：

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

销毁顺序表：

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

在任意位置插入：

void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SeqListCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

删除任意位置：

void SeqListErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);
	int begin = pos;
	while (begin < ps->size-1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size++;
}

查找：

int SeqListFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
		if (ps->a[i] == x)
			return i;
	return -1;
}

修改：

void SeqListModify(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}

3.单链表

顺序表优点：物理空间连续，下标随机访问

顺序表缺点：1.空间不够需要扩容，扩容有一定性能消耗，其次一般扩容2倍，存在一些空间浪费。2.头部或者中间位置插入删除效率低下。

改善方案：1.按需申请释放空间。2.头部或者中间位置插入删除不需要挪动数据。

创建结构体：

 

接口实现：

所有传二级指针的函数都应该断言一下assert(pphead); 防止误用

创建新结点：

SLTNode* BuySListNode(SListDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	assert(newnode);
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

尾插：

void SListPushBack(SLTNode** pphead, SListDataType x)
{
	SLTNode* newnode = BuySListNode(x);
	if (*pphead == NULL)
		*pphead = newnode;
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
			tail = tail->next;
		tail->next = newnode;
	}
}

头插：

void SListPushFront(SLTNode** pphead, SListDataType x)
{
	SLTNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

尾删：

void SListPopBack(SLTNode** pphead)
{
	assert(*pphead);
	if ((*pphead)->next == NULL) //只有一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else //多个结点
	{
		/*SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;*/
		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
			tail = tail->next;
		free(tail->next);
		tail->next = NULL;
	}
}

头删：

void SListPopFront(SLTNode** pphead)
{
	//assert(*pphead != NULL);
	if (*pphead == NULL)
		return;
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

查找：

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

在pos位置之前插入：

void SListInsert(SLTNode** pphead, SLTNode* pos, SListDataType x)
{
	assert(pos); //如果pos等于空，就相当于尾插
	if (pos == *pphead)//头插
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

删除pos位置的值：

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);
	if (pos == *pphead)
		SListPopFront(pphead);
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
	}
}

在pos位置之后插入：

void SListInsertAfter(SLTNode* pos, SListDataType x)
{
	assert(pos);
	SLTNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;

	/*SLTNode* newnode = BuySListNode(x);
	SLTNode* next = pos->next;
	pos->next = newnode;
	newnode->next = next; 不在乎链接顺序*/
}

删除pos位置之后的值：

void SListEraseAfter(SLTNode* pos)
{
	assert(pos);
	if (pos->next == NULL)
		return;
	else
	{
		SLTNode* del = pos->next;
		pos->next = del->next;
		free(del);
	}
}

打印：

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

4.双向链表

双向带头结点循环链表

创建结构体：

接口实现：

 

打印：

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

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

创建新结点：

LTNode* BuyListNode(LTDateType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	node->data = x;
	node->next = NULL;
	node->prev = NULL;
	return node;
}

初始化：

LTNode* ListInit()
{
	LTNode* phead = BuyListNode(-1);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

尾插：

void ListPushBack(LTNode* phead, LTDateType x)
{
	assert(phead);

	LTNode* newnode = BuyListNode(x);
	LTNode* tail = phead->prev;
	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

也可以复用“在pos位置之前插入”函数：

void ListPushBack(LTNode* phead, LTDateType x)
{
	ListInsert(phead, x);
}

头插：

void ListPushFront(LTNode* phead, LTDateType x)
{
	assert(phead);

	LTNode* newnode = BuyListNode(x);
	LTNode* next = phead->next;
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = next;
	next->prev = newnode;
}

也可以复用“在pos位置之前插入”函数：

void ListPushFront(LTNode* phead, LTDateType x)
{
	ListInsert(phead->next,x);
}

判断链表是否为空：

bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

尾删：

void ListPopBack(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

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

也可以复用“删除pos位置的结点”函数：

void ListPopBack(LTNode* phead)
{
	ListErase(phead->prev);
}

头删：

void ListPopFront(LTNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));

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

也可以复用“删除pos位置的结点”函数：

void ListPopFront(LTNode* phead)
{
	ListErase(phead->next);
}

在pos位置之前插入：

void ListInsert(LTNode* pos, LTDateType x)
{
	assert(pos);

	LTNode* newnode = BuyListNode(x);
	LTNode* posPrev = pos->prev;
	posPrev->next = newnode;
	newnode->prev = posPrev;
	newnode->next = pos;
	pos->prev = newnode;
}

删除pos位置的结点：

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

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

求链表长度：

int ListSize(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	int size = 0;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

销毁链表： 

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

顺序表和（双向）链表的区别：

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

顺序表优点：下标随机访问、CPU高速缓存命中率高

顺序表缺点：头部或中间插入删除效率低、扩容有一定程度性能消耗（异地扩容需要拷贝完整顺序表）、可能存在一定程度空间浪费

链表优点：任意位置插入删除是O(1)、按需申请释放

链表缺点：不支持下标随机访问

安慕蜥
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构—个人学习笔记
qq_53092934的博客
03-15 2080
学习笔记目录 数据结构第一章绪论 1.1 数据结构的研究内容 数据结构的研究内容为： 研究非数值计算的程序设计问题中计算机的操作对象以及它们之间关系和操作 1.2 基本概念及术语 数据结构的两个层次 逻辑结构： 数据元素间抽象化的相互关系，与数据的存储无关，独立于及玄机，它是从具体问题抽象出来的数学模型。 存储结构（物理结构）： 数据元素及其关系在计算机存储器中的存储方式。 逻辑结构 划分方法一 （1）线性结构—— 有且仅有一个开始和一个终端结点，并且所有结点都最多只有一个直接前趋和一个后继。 例如：线
1.绪论——青岛大学王卓老师数据结构课程课堂笔记
fjhkrje的博客
03-23 2791
• 数据结构：数组、链表、栈、队列、散列表、二叉树、堆、跳表、图、Tire树 • 算法： 递归、排序、二分查找、搜索、哈希算法、贪心算法、分治算法、回溯算法、动态规划、字符串匹配算法。 1.1数据结构研究 无法用数学公式或者方程来描述，是一些”非数值计算”的程序设计问题，描述非数值计算问题的数学模型不是数学方程，而是诸如表、树和图之类的具有逻辑关系的数据。 数据结构是一门研究非数值计算的程序设计中计算机的操作对象以及它们之间的关系和操作的学科 1.2基本概念和术语 1.2.1 数据、数据元素、数据项和数据.
数据结构学习笔记
liu320yj的博客
06-26 3656
数据结构指相互之间存在一种或多种特定关系的数据元素的集合，包括常用的数组、链表、栈、队列、二叉树等
408数据结构笔记整理
clh0980507的博客
06-28 2159
个人复习笔记
数据结构期末复习笔记
zyw2002的博客
11-28 4820
背景：2021春季期末与好友多喝岩浆xx共同整理的复习笔记。 主要参考了老师的课件, 还有一些博客。(万分感谢好友，老师，还有乐于分享的博主们！) github 下载地址：复习笔记pdf+图解数据结构doc 百度网盘下载地址：链接：复习笔记pdf 提取码：m6yn 感想：一般来说大学应试的数据结构考的都是基本的知识点，不会特别难，但真正的学习数据结构光靠应试的复习是远远不够的。说实话我第一遍听课的时候也觉的很多知识似懂非懂，但是在期末考试提前很久就开始自己复习了，通过画图把每一个算法都去弄懂，尤其像KMP.
【数据结构】个人笔记目录
shangguanxiu的博客
12-31 1885
数据结构个人目录
数据结构--笔记汇总
会思想的苇草i的博客
02-20 861
这里是个人学习数据结构的一些笔记感悟，在此推荐青岛大学–王卓老师的数据结构课程视频，个人认为是比较通俗易懂的。 数据结构-青岛大学王卓 搭配笔记可以帮助更快掌握数据结构这门课程的相关知识点。 数据结构（C语言版）-- 数据结构基础 数据结构（C语言版）-- 线性表笔记 数据结构（C语言版）-- 栈和队列笔记 数据结构（C语言版）-- 串、数组和广义表笔记 数据结构（C语言版）-- 树和二叉树笔记 数据结构（C语言版）-- 图笔记 数据结构（C语言版）-- 查找笔记 数据结构（C语言版）-- 排序笔记 数据结
866数据结构笔记 - 第一章 绪论
qq_45331246的博客
10-08 2323
866数据结构、湖南大学考研、绪论
【尚硅谷】Java数据结构与算法笔记03 - 链表
热门推荐
知不足而奋进，望远山而前行
12-07 1万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
数据结构知识点-个人笔记.pdf
03-13
本部分笔记主要涵盖了数据结构的基本概念、线性表的概念和特点以及存储结构。 首先，数据结构的基本概念包括数据、数据项、数据元素和数据对象。数据是所有能够输入计算机并被计算机程序处理的符号的总称，可以是...
数据结构笔记 绪论+算法.docx
12-31
2. 数据对象和数据结构： 数据对象是性质相同的数据元素的集合，是数据的子集。数据结构则是这些数据元素按照特定关系组成的集合，包括逻辑结构和物理结构。逻辑结构描述数据元素之间的抽象关系，如集合、线性、树形...
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
计算机考研数据结构手写笔记
11-23
### 1.1数据结构的概念 - **数据结构**——研究数据(特别是非数值数据)的组织，存储及运算方法。 - **数据**——描述客观事物的数值，字符以及能输入到计算机中且能被处理的各种符号集合。 - **数据元素**——...
耶鲁大学C语言和数据结构笔记
06-24
"耶鲁大学C语言和数据结构笔记" 本资源主要介绍了耶鲁大学CPSC 223课程的笔记，涵盖了C语言和数据结构的基础知识。课程讲述了基本的编程技术和数据结构，旨在帮助学生学习C语言和数据结构的基础知识。 数据结构 ...
C/C++ 多线程[1]---线程创建+线程释放+实例
Edwinwzy的博客
08-17 880
这篇博客写一下多线程的一个demo。多线程还是很有用的，C++程序员进阶的必通之路。大学里面学的那些小玩意儿，单线程就能搞定所有，真正的大型项目，还是会有很多多线程相关的。记住这个多线程demo的简单使用，那么后面进一步拓展就手到擒来了。
C/C++控制台贪吃蛇游戏的实现
最新发布
fzy20110826的博客
08-20 1108
本文对给定的贪吃蛇游戏代码进行详细分析。该游戏使用 C++语言编写，通过控制台界面实现了经典的贪吃蛇游戏玩法，包括登录、注册、游戏介绍、游戏操作和计分等功能。
C语言异常处理背后技术详解
极客代码
08-19 672
异常处理是一种编程语言机制，用于处理程序执行过程中出现的非预期情况。这些非预期情况可能是由外部输入错误、内存访问越界、除以零等引起的。异常处理机制允许程序在检测到这些非预期情况时，执行特定的处理流程，从而避免程序崩溃，提高程序的健壮性和可靠性。本文第一部分介绍了C语言异常处理的基础知识，包括异常处理的定义、C语言异常处理的常用方法（返回值、全局变量、栈展开）。通过这些方法，我们可以在C语言中实现基本的异常处理。然而，这些方法都有其局限性，不能完全满足复杂的异常处理需求。
C:数组传参的本质
JonlyMay的博客
08-17 1079
数组传参的本质
C++与数据结构复习笔记：面试必备
"C++及数据结构的复习笔记，包含了C++基础、数据结构以及相关面试题，适合初学者和应届毕业生复习准备。" 本文档是作者Laotan根据谭浩强的《C++程序设计》和邓俊辉的《数据结构（C++语言版）》结合CSDN上的相关博客...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

安慕蜥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值