第五周总结01

已于 2023-04-03 17:46:55 修改
阅读量45 收藏
点赞数
文章标签： 数据结构 算法 c语言
于 2023-04-02 20:16:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Laser_song/article/details/129915602
版权

数据结构

什么是数据结构

数据结构的起源

  • 1968年，美国高德纳教授，《计算机程序设计艺术》 第一卷《基本算法》出版，开创了数据结构与算法的先河

  • 数据结构是一门研究数据之间关系和操作的学科，而非计算方法

  • 数据结构 + 算法 = 程序 由沃思提出，凭借该论点获得图灵奖，这句话揭示了程序的本质

  • 推荐书籍：程杰《大话数据结构》

数据结构的基本概念

数据：

  • 所有能够输入到计算机中，能被程序处理的，能描述客观事物特征的符号

数据项：

  • 有独立含义数据的最小单位，也叫数据域、域

数据元素：

  • 组成数据的，有一定含义的基本单位，也叫节点、结点、记录

  • 一个数据元素由若干个数据项组成

数据结构：

  • 相互之间存在一种或者多种特定关系的数据元素的集合

算法：

  • 数据结构具备的某些功能，能够解决某种特定问题的方法

数据结构研究的三个方面

  • 数据的逻辑结构

  • 数据的存储结构（物理结构）

  • 数据结构的运算

逻辑结构与存储结构

数据的逻辑结构：

集合：

  • 数据元素同属于一个集体，但是元素之间没有任何关系

线性结构(表)：

  • 数据元素之间存在一对一的关系

树型结构(树)：

  • 数据元素之间存在一对多的关系

图型结构(图)：

  • 数据元素之间存在多对多的关系

数据的物理结构：

*顺序结构：

  • 数据元素存储在连续的内存中，用数据元素的相对位置来表示之间的关系

    • 优点：支持随机访问、访问效率高、适合查找数据

    • 缺点：对内存要求高、空间利用率低，插入和删除很麻烦

*链式结构：

  • 数据元素存储在彼此相互独立的内存空间中，每个独立的数据元素称为节点，每个节点中增加一个数据项用于存储其他节点的地址(指针域)，用于表示数据节点之间的关系

    • 优点：对内存要求低、空间利用率高，插入和删除很方便
    • 缺点：不支持随机访问，只能从前到后逐个访问

逻辑结构与物理结构的关系：

  • 表 顺序、链式
  • 树 链式、顺序
  • 图 顺序 + 链式、顺序
  • 每种逻辑结构采用什么存储结构没有明确规定，通常是根据实现的难度以及空间、时间方面的要求，来选择最合适的物理结构

数据结构的运算

​ 建立数据结构 create

​ 销毁数据结构 destroy

​ 清空数据结构 clean

​ 插入元素 insert add

​ 删除元素 delete

​ 访问元素 access

​ 修改元素 modify

​ 查询元素 query

​ 数据结构排序 sort

​ 遍历数据结构 show or print or ergodic

顺序表和链式表的实现

顺序表：

  • 数组

数据项：

  • 存储连续元素的内存首地址
  • 表的容量
  • 元素的数量

运算：

  • 创建、销毁、清空、插入、删除、访问、查询、修改、排序、遍历

    • 注意：
      • 1、从始至终保持元素的连续性
      • 2、不能越界
    • 优点：支持随机访问，修改、访问、排序效率高、不容易出现内存碎片
    • 缺点：对内存要求较高，插入、删除元素时不方便、效率低

顺序表举例：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

#define TYPE int

// 设计顺序表结构
typedef struct Array
{
	TYPE* ptr;	// 存储元素的内存首地址
	size_t cal;	// 表的容量
	size_t cnt; // 元素的数量
}Array;

// 创建
Array* create_array(size_t size)
{
	// 分配表结构内存
	Array* arr = malloc(sizeof(Array));
	// 分配存储元素的内存
	arr->ptr = malloc(sizeof(TYPE)*size);
	// 记录容量
	arr->cal = size;
	// 初始化数量
	arr->cnt = 0;
	return arr;
}

// 销毁
void destroy_array(Array* arr)
{
	free(arr->ptr);
	free(arr);
}

// 清空
void clean_array(Array* arr)
{
	arr->cnt = 0;
}

// 插入
bool insert_array(Array* arr,size_t index,TYPE val)
{
	// 满？
	if(arr->cnt >= arr->cal) return false;
	// 判断下标，为了确保表中元素的连续性
	if(index > arr->cnt) return false;
	/*
	for(int i=arr->cnt; i>index; i--)
	{
		arr->ptr[i] = arr->ptr[i-1];
	}
	*/
	//void *memmove(void *dest, const void *src, size_t n);
	// 后移
	memmove(arr->ptr+index+1,arr->ptr+index,(arr->cnt-index)*sizeof(TYPE));
	arr->ptr[index] = val;
	arr->cnt++;
	return true;
}

// 删除
bool delete_array(Array* arr,size_t index)
{
	if(index >= arr->cnt) return false;
	// 前移
	memmove(arr->ptr+index,arr->ptr+index+1,
		(arr->cnt-index-1)*sizeof(TYPE));
	arr->cnt--;
	return true;
}

// 访问
bool access_array(Array* arr,size_t index,TYPE* val)
{
	if(index >= arr->cnt) return false;
	*val = arr->ptr[index];
	return true;
}
// 修改
bool modify_array(Array* arr,size_t index,TYPE val)
{
	if(index >= arr->cnt) return false;
	arr->ptr[index] = val;
	return true;
}

// 查询
int query_array(Array* arr,TYPE val)
{
	for(int i=0; i<arr->cnt; i++)
	{
		if(val == arr->ptr[i]) return i;
	}
	return -1;
}

// 排序
void sort_array(Array* arr)
{
	for(int i=0; i<arr->cnt-1; i++)
	{
		for(int j=i+1; j<arr->cnt; j++)
		{
			if(arr->ptr[i]>arr->ptr[j])
			{
				TYPE temp = arr->ptr[i];
				arr->ptr[i] = arr->ptr[j];
				arr->ptr[j] = temp;
			}
		}
	}
}

// 遍历
void show_array(Array* arr)
{
	for(int i=0; i<arr->cnt; i++)
	{
		printf("%d ",arr->ptr[i]);
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	TYPE val = -10;
	Array* arr = create_array(10);
	for(int i=0; i<5;i++)
	{
		insert_array(arr,0,i);
	}
	
	//show_array(arr);
	//access_array(arr,1,&val);
	//printf("%d\n",val);
	//insert_array(arr,5,88);
	//show_array(arr);
	//delete_array(arr,0);
	//show_array(arr);
	//modify_array(arr,1,5);
	//show_array(arr);
	//printf("%d\n",query_array(arr,4));
	//sort_array(arr);
	//show_array(arr);
}

链式表List：

  • 链表

每个节点Node数据项：

  • 数据域：可以是若干个任意类型的数据项
  • 指针域：指向下一个节点
  • 把若干个节点通过指针域连接在一起就形成了链式表

不带头节点的链式表：

  • 第一个节点的数据域存储的是有效数据的链表

  • 缺点：头插入节点时，会修改指向第一个节点的指针，参数就需要传递二级指针；

  • 删除节点时，需要分两种情况：

    • 1、待删除的是第一个节点时，也会修改指向第一个节点的指针，就需要传递二级指针
    • 2、待删除的不是第一个节点时，就正常删除
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

// 设计单链表的节点
typedef struct Node
{
	TYPE data;// 节点的数据域
	struct Node* next;// 节点的指针域
	
}Node;

// 创建节点
Node* create_node(TYPE data)
{
	// 分配存储节点的内存
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

// 头添加
void add_head_list(Node** head,TYPE data)
{
	Node* node = create_node(data);
	node->next = *head;
	*head = node;
}

// 按值删除
bool delete_value_list(Node** head,TYPE data)
{
	// 如果删除头节点
	if((*head)->data == data)
	{
		Node* temp = *head;
		*head = temp->next;
		free(temp);
		return true;
	}

	for(Node* n=*head; NULL!=n->next; n=n->next)
	{
		if(n->next->data == data)
		{
			// 备份待删除节点
			Node* temp = n->next;
			// 连接待删除节点的前一个和后一个节点
			n->next = temp->next;
			// 删除待删除节点
			free(temp);
			return true;
		}
	}
	return false;
}

// 按位置删除
bool delete_index_list(Node** head,size_t index)
{
	// 如果删除头节点
	if(0 == index)
	{
		Node* temp = *head;
		*head = temp->next;
		free(temp);
		return true;
	}
	
	Node* n = *head;
	while(--index > 0)
	{
		if(NULL == n->next) return false;
		n = n->next;
	}
	if(NULL == n->next) return false;
	// n是待删除节点的前一个

	// 备份待删除节点
	Node* temp = n->next;
	// 连接待删除节点的前一个和后一个节点
	n->next = temp->next;
	// 删除待删除节点
	free(temp);
	return true;
}

//访问
bool access_list(Node* head,size_t index,TYPE* val)
{
	Node* n = head;
	for(int i=0; i<index; i++)
	{
		n = n->next;
		if(NULL == n) return false;
	}
	*val = n->data;
	return true;
}

//遍历
void show_list(Node* head)
{
	for(Node* n=head; NULL!=n; n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}

// 排序
void sort_list(Node* head)
{
	for(Node* i=head; NULL!=i->next; i=i->next)
	{
		for(Node* j=i->next; NULL!=j; j=j->next)
		{
			if(i->data > j->data)
			{
				TYPE temp = i->data;
				i->data = j->data;
				j->data = temp;
			}
		}
	}
}

int main(int argc,const char* argv[])
{
	Node* head = NULL;
	for(int i=0;i<10; i++)
	{
		add_head_list(&head,i+10);
	}
	//delete_value_list(&head,19);
	//delete_index_list(&head,9);
	show_list(head);
	TYPE val = -10;
	access_list(head,0,&val);
	printf("%d\n",val);
	sort_list(head);
	show_list(head);
	/*
	Node* n1 = create_node(10);
	Node* n2 = create_node(20);
	Node* n3 = create_node(30);
	Node* n4 = create_node(40);
	Node* n5 = create_node(50);

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = n5;

	for(Node* n=n1; NULL!=n;n=n->next)
	{
		printf("%d ",n->data);
	}*/
}

带头节点的链式表：

  • 第一个节点的数据域不用于存储有效数据的链表，该头节点是专门用于指向第一个有效数据的节点

  • 优点：无论是否头插入还是头删除，头节点永远不变，变的只是头结点的next，所以不用传递二级指针，也不用额外处理头删除

  • 缺点：额外会多一个头节点

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

#define TYPE int

// 带头节点的链表

// 设计单链表的节点
typedef struct Node
{
	TYPE data;// 节点的数据域
	struct Node* next;// 节点的指针域
	
}Node;

// 创建节点
Node* create_node(TYPE data)
{
	// 分配存储节点的内存
	Node* node = malloc(sizeof(Node));
	// 初始化
	node->data = data;
	node->next = NULL;
	return node;
}

// 头添加
void add_head_list(Node* head,TYPE data)
{
	Node* node = create_node(data);
	node->next = head->next;
	head->next = node;
}

// 尾添加
void add_tail_list(Node* head,TYPE data)
{
	Node* n = head;
	Node* tail = create_node(data);
	while(NULL != n->next) n = n->next;
	n->next = tail;
}

// 按位置删除
bool del_index_list(Node* head,size_t index)
{
	Node* n = head;
	for(int i=0; i<index; i++)
	{
		n = n->next;
		if(NULL == n->next) return false;
	}
	Node* temp = n->next;
	n->next = temp->next;
	free(temp);
	return true;
}

// 按值删除
bool del_value_list(Node* head,TYPE val)
{
	Node* n = head;
	for(Node* i=n; NULL!=n->next; n=n->next)
	{
		if(val == n->next->data)
		{
			Node* temp = n->next;
			n->next = temp->next;
			free(temp);
			return true;
		}
	}
	return false;
}

// 插入
bool insert_list(Node* head,size_t index,TYPE val)
{
	Node* n = head;
	Node* node = create_node(val);
	for(int i=0; i<index; i++)
	{
		n = n->next;
		if(NULL == n->next) return false;
	}
	node->next = n->next;
	n->next = node;
	return true;
}

// 按位置修改
bool modify_index_list(Node* head,size_t index,TYPE val)
{
	Node* n = head->next;
	for(int i=0; i<index; i++)
	{
		n = n->next;
		if(NULL == n) return false;
	}
	n->data = val;
	return true;
}

// 按值修改
bool modify_value_list(Node* head,TYPE old,TYPE val)
{
	for(Node* n=head->next; NULL!=n; n=n->next)
	{
		if(old == n->data)
		{
			n->data = val;
			return true;
		}
	}
	return false;
}

// 访问
bool access_list(Node* head,size_t index,TYPE* val)
{
	Node* n = head->next;
	for(int i=0; i<index; i++)
	{
		if(NULL == n) return false;
		n = n->next;
	}
	if(NULL == n) return false;
	*val = n->data;
	return true;
}

// 查询
int query_list(Node* head,TYPE val)
{
	Node* n = head->next;
	for(int i=0; n; i++,n=n->next)
	{
		if(val == n->data) return i;
	}
	return -1;
}

// 排序
void sort_list(Node* head)
{
	for(Node* i=head->next; NULL!= i->next; i=i->next)
	{
		for(Node* j=i->next; NULL!=j; j=j->next)
		{
			if(i->data < j->data)
			{
				TYPE temp = i->data;
				i->data = j->data;
				j->data = temp;
			}
		}
	}
}

// 遍历
void show_list(Node* head)
{
	for(Node* n=head->next; NULL!=n; n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	// 头节点
	Node* head = create_node(0);
	for(int i=0; i<10; i++)
	{
		//add_head_list(head,i+10);
		add_tail_list(head,i+10);
	}
	//del_index_list(head,5);
	//del_value_list(head,25);
	//insert_list(head,25,5);
	//modify_index_list(head,9,5);
	//modify_value_list(head,98,5);
	/*
	TYPE num = -10;
	access_list(head,5,&num);
	printf("%d\n",num);
	*/
	//printf("%d\n",query_list(head,19));
	sort_list(head);
	for(Node* i=head->next; NULL!=i; i=i->next)
	{
		printf("%d ",i->data);
	}
	//show_list(head);
}

注意：做题时，如果没有说明是否带头节点，那么两种情况都进行考虑

Laser_song
关注
python实践周总结_Python 一周总结
weixin_42444815的博客
01-29 2099
在写之前：大学的颓废造成目前毕业后的现状，我自己心里也清楚我喜欢互联网热爱编程，大学杂念太多做的事情也太多所以现在抛除所有杂念，一心学习python，四个月我希望自己可以天天高质量的学习，保持积极的态度，让自己学有所成，可以顺利通关。2017-7---2017-11 加油！python一周总结：01：python简介，特点，开发环境及版本Python是一种动态解释型的编程语言。Python可以在...
祝文龙第五周总结报告.docx
09-30
祝文龙第五周总结报告.docx
第五周day01总结
hongqixiaozi的博客
08-19 122
前端实习第五周总结
qq_43957263的博客
12-21 4948
经过一个多月的打磨，我现在基本上算是已经稳定下来并且习惯了现在的生活。每天朝九晚六，算是体会到了什么叫做社畜。 由于这几天我负责的小程序前端项目要上线，所以就一直在提交测试、修改，再提交、再修改；一直过了几天这样的日子。然后终于在昨天第一次被迫加班到九点的情况下，这个项目终于是部署上线了。所以才有时间更新这篇博客，原本是上周就应该分享更新的。 这两天还有上周，由于项目上线，要改的还有要交流的比较多；我算是深深的感受到了交流的重要性。真的是太难了。。。和大家...
24寒假训练第五周总结
2301_80353190的博客
02-25 403
2.19训练赛24牛客寒假训练营52.23训练赛总结：这是寒假训练最后完整的一周，也是训练以来的第五周，现在对付训练赛有种得心应手的感觉，做出来的题目越来越多，也许是之前努力训练学习的结果，所以我相信努力就会有回报，补题就会有提升，不过牛客训练营依旧是很头疼啊，这也反映了我的算法能力还是不够扎实稳定，有很多需要补充练习的地方，还有一些数学思维需要训练提升，甚至补起那些题也觉得十分吃力，所以学习的路上从来没有一下子就成功的，从来都是稳扎稳打慢慢提升，一直坚持学习，最后才能在赛场上大显光彩战胜对手，我希望自己可
Java第五周总结
DoNotGankMe的博客
12-18 207
Java第五周知识点总结
第三周学习总结
wcxyky的博客
08-12 543
总结下来第三周，主要是把第三章大致学习了一遍，又系统复习了一遍前两章，并且学了数据结构进阶这部分的前两节多。 怎么说那，感觉有点不太友好，就是知识点也学了一遍，但不会应用到题目中去。一做题还是想到原来自己那一套，这些新学知识点的应用好像从来没有出现在我脑子里一样。 还是自己学的太少，见得太少，练得太少感觉，导致自己每次只会跟着人家后面出水题。可不管怎样，先补充上知识要紧。 新的一周还是继续学...
第五周学习总结
weixin_43739146的博客
03-31 1129
第五周学习总结   这周，我感觉我整个人都游走在崩溃的边缘，精神都有点恍惚了（毕竟经常熬夜“敲代码”），最近感觉脑袋都蒙了，什么都不会了，写着写着就不会写了。其实不只是精神状态的原因，对于基础知识的学习并不扎实也是导致我项目开发遇到诸多问题的重要原因之一。   在这次考核中，我充分地认识到了其实自己在学习方面一直都存在真很多误区。比如，对于知识的没有做到深刻充分的理解，在写项目的过程中没有养成良好...
JS第五周知识点总结
qq_44930306的博客
08-07 709
本文总结了PHP、Cookie、Ajax、Promise相关的基础知识点，希望大家可以互相学习！
第四周总结
Flying____fish的博客
01-24 1956
第四周总结 在家学习的第二周即将就要结束了，在家学习果然是锻炼自己学习意志和时间管理的好地方，“计划永远跟不上变化”这句话果然没毛病，学习速度着实有点低，当收到本学习阶段任务的是时候确实慌了，学习进度都不要好意思开口了。 有问题就要解决问题，仔细想了一下这几天的学习情况。 首先是学习时间上，在家的一些零碎事务避无可避，不过这些并不是主要原因，除去这些时间一天中还剩不少时间是可以坐下来的，比较严重的一个问题是有点好高骛远了，进度没赶上，竟然试图区了解后面的一些开发框架的东西，比如Vue、React、Node、
第五周总结
weixin_44362072的博客
06-17 823
学校迎来了单招周，因为我是学生会的所以这周我去帮学弟学妹了，在这一周，老师让我们自己预习下面的课程，有些知识还是需要老师来教授。就我而言，我的理解能力可能没有一些同学那样强，笨鸟先飞。所以，在下一周，还是要继续预习书本，以便于能更好的学习这门课程。 ...
Java学习第五周学习总结
10-16
主要内容是异常，包括了一个游戏项目
中学第五周教学工作总结.doc
02-15
【中学第五周教学工作总结】 本周的教学工作总结主要涵盖了教学活动、实习生的工作表现、教学反馈、教师培训以及对新课堂模式的探讨。以下是对这些知识点的详细说明： 1. 实习生工作与团队协作：实习生葛小朋和...
新学期第八小组第七周小组的工作总结PPT.pptx
03-13
5. 团队建设：小组的团队建设活动，如户外拓展、趣味运动会等，可以增进小组成员之间的友谊和默契，提高小组的整体实力和工作效率。 6. 反思和改进：小组的反思和改进对小组的工作进度和质量至关重要。小组应不断...
志愿者组织部第四周工作总结和第五周工作计划.doc
02-16
志愿者组织部第四周工作总结和第五周工作计划.doc
数据结构：树的定义及其性质
pranaa的博客
09-24 708
树是一种重要的非线性数据结构，树作为一种逻辑结构，同时也是一种分层结构。具有以下两个特点：1.树的根结点没有前驱，除根结点意外的节点只有一个前驱2.树中所有结点都可以有0个或多个后继树结构在多个领域都有广泛应用，如表示文件系统的结构、数据库的索引、层次数据关系等。具体来说，树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。
数据结构之——栈
m0_71974552的博客
09-24 1187
栈：数据结构的基石
matlab的‌基础语法和数据类型
weixin_45710581的博客
09-25 582
MATLAB中的函数用于封装可重复使用的代码块。
数据结构：详解搜索二叉树
最新发布
Another_Shi的博客
09-28 778
搜索二叉树的结构跟二叉树差不多——两个指针来指向左右子树，一个对象来存放数据。
Python基础操作记录与第二周学习总结
资源摘要信息:"Python简单操作记录" 1. Python语言介绍 Python是一种解释型、面向对象、高级编程语言，由Guido van ...通过了解和掌握这些基础知识，可以有效地进行第二周的操作记录工作，提高开发效率和代码质量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值