数据结构day2

已于 2023-08-02 12:57:39 修改
阅读量49 收藏 1
点赞数 4
文章标签： 数据结构
于 2023-08-01 18:48:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51479108/article/details/132044017
版权

一、顺序表

    数据项：

        存储元素的内存首地址

        表的容量

        元素的数量

    运算：

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

    注意：

        1、要确保数据元素的连续性

        2、不能越界

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

#define TYPE int  //元素的类型
#define PH "%d "

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

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

	return arr;
}

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

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

//  插入(不连续或者满了会失败)
bool insert_array(Array* arr,size_t index,TYPE date)
{
	// 判断表是否满
	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];
	}*/
	memmove(arr->ptr+index+1,arr->ptr+index,(arr->cnt-index)*sizeof(TYPE));

	//插入数据
	arr->ptr[index]=date;
	arr->cnt++;
	return true;
}

//  删除
bool delete_array(Array* arr,size_t index)
{
	//判断下标是否存在
	if(index >= arr->cnt) return false;
	
	//数据内存向前移动
/*	for(int i=index;i< arr->cnt-1;i++)
	{
		arr->ptr[i]=arr->ptr[i+1];
	}*/
	
	memmove(arr->ptr+index,arr->ptr+index+1,(arr->cnt-index-1)*sizeof(TYPE));

	//数据个数减1
	arr->cnt--;
	return true;

}
//  访问
bool access_array(Array* arr,size_t index,TYPE* date)
{
	if(index >= arr->cnt) return false;

	*date =arr->ptr[index];
	return true;
}
//  查询
int query_array(Array* arr,TYPE date)
{
	for(int i=0;i<arr->cnt;i++)
		if(arr->ptr[i]==date) return i;
	return -1;
}
//  修改
bool modify_array(Array* arr,size_t index,TYPE date)
{
	if(index >= arr->cnt) return false;
	arr->ptr[index]=date;
	return true;
}
//  排序
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[j]<arr->ptr[i])
			{
				TYPE temp=arr->ptr[j];
				arr->ptr[j]=arr->ptr[i];
				arr->ptr[i]=temp;
			}
		}
	}
}
//  遍历
void show_array(Array* arr)
{
	for(int i=0;i<arr->cnt;i++)
	{
		printf(PH,arr->ptr[i]);
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	Array* arr=create_array(10);
	for(int i=0;i<5;i++)
	{
		insert_array(arr,0,i+1);
	}

	insert_array(arr,3,8);
	delete_array(arr,2);
	show_array(arr);

	int num=0;
	if(access_array(arr,5,&num))
		printf("%d\n",num);
	else
		printf("index error\n");

	printf("index=%d\n",query_array(arr,8));

	sort_array(arr);
    show_array(arr);
	clear_array(arr);
	show_array(arr);
	destroy_array(arr);
    arr=NULL;
	return 0;
}
运行的结果
5 4 8 2 1 
index error
index=2
1 2 4 5 8

二、链式表(链表) 

    数据元素(节点)的数据项：

        数据域：可以是各种类型的若干项数据项

        指针域：指向下一个节点的指针

   

    由若干个节点通过指针域连接起来就形成了链表

    不带头节点的链表：

        定义：第一个节点的数据域存储的是有效数据

        缺点：当插入、删除时可能会改变第一个有效节点，传递的参数需要传递二级指针，实现时需要区分是否是操作第一个有效节点，较为麻烦

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

#define TYPE int

// 设计链表的节点结构 node
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 del_value_list(Node** head,TYPE data)
{
	//  删除第一个值
	if((*head)->data==data)
	{
		Node* temp=*head;
		*head=(*head)->next;
		free(temp);
		return true;
	}
	// 遍历找到待删除节点的前一个节点
	for(Node* n=*head; n->next;n=n->next)
	{
		if(n->next->data==data)
		{
			Node* temp=n->next;
			n->next=temp->next;
			free(temp);
			return true;
		}
	}
	return false;
}

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

}

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

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

//  按位置删除
bool del_index_list(Node** head,size_t index)
{
	//  删除第一个值
	if(0==index)
	{
		Node* temp=*head;
		*head=temp->next;
		free(temp);
		return true;
	}

	Node* n=*head;
	for(int i=1;n->next;n=n->next,i++)
	{
		if(i==index)
		{
			Node* temp=n->next;
			n->next=temp->next;
			free(temp);
			return true;
		}
	}
	return false;
	/*while(--index)
	{
		n=n->next;
		if(NULL==n) return false;
	}
	if(NULL==n->next) return false;
		Node* temp=n->next;
		n->next=temp->next;
		free(temp);
		return true;
		*/
}

int main(int argc,const char* argv[])
{
	Node* head =create_node(10);
	for(int i=0;i<5;i++)
	{
		add_head_list(&head,i+1);
	}
	show_list(head);
	del_value_list(&head,1);
	show_list(head);

	int num=0;
	if(access_list(head,8,&num))
		printf("num=%d\n",num);
	else 
		printf("error\n");
	sort_list(head);
	show_list(head);
	del_index_list(&head,2);
	show_list(head);
	return 0;
}
运行结果
5 4 3 2 1 10 
5 4 3 2 10 
error
2 3 4 5 10 
2 3 5 10

    带头节点的链表：

        定义：第一个节点作为头节点，数据域不使用不存储有效数据，它的指针域永远指向链表的第一个有效数据节点，就算链表长度为0，头节点依然存在

        优点：当插入、删除时是不会改变头节点的指向，只需要改变它的next，因此无需传递头节点的二级指针，并且实现时无需区分两种情况

        注意：有效节点的处理必须从头节点的next开始

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

#define TYPE int

// 节点结构
typedef struct Node
{
	TYPE data;          //数据域
	struct Node* next;  //指针域
}Node;

//   创建节点
Node* creat_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=creat_node(data);
	node->next=head->next;
	head->next=node;
}

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

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

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

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

//  按相同值删除
int del_samevalue_list(Node* head,TYPE data)
{
	int cnt=0;
	Node* n=head;
	while(n->next)
	{
		if(data==n->next->data)
		{
			Node* temp=n->next;
			n->next=temp->next;
			free(temp);
			cnt++;
		}
		else
		{
			n=n->next;
		}
	}
	return cnt;
}


// 修改
int modify_list(Node* head,TYPE old,TYPE data)
{
	int cnt=0;
	Node* n=head->next;
	while(n)
	{
		if(old==n->data)
		{
			n->data=data;
			cnt++;
		}
		n=n->next;
	}
	return cnt;
}

// 访问  第index个位置是哪个值
bool access_list(Node* head, size_t index, TYPE* data)
{
	int i=0;
	for(Node* n=head->next; n ;n=n->next,i++)
	{
		if(i==index)
		{
			*data=n->data;
			return true;
		}
	}
	return false;
}

//  排序
void sort_list(Node* head)
{
	for(Node* i=head->next;i->next;i=i->next)
	{
		for(Node* j=i->next;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; n; n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");

}

int main(int argc,const char* argv[])
{
	//  head指向头节点 不使用为有效节点
	// head->next 指向第一个有效数据节点
	Node* head=creat_node(100);
	for(int i=0;i<10;i++)
	{
		add_head_list(head,i+1);
	}
	show_list(head);
	add_tail_list(head,12);
	insert_list(head,3,12);
	insert_list(head,6,12);
	insert_list(head,1,12);
	insert_list(head,9,12);
	show_list(head);
	del_index_list(head,5);
	show_list(head);
	del_value_list(head,1);
	modify_list(head,12,66);
	show_list(head);
	int num=-1;
	access_list(head,6,&num);
	printf("%d\n",num);
	sort_list(head);
	show_list(head);
	del_samevalue_list(head,66);
	show_list(head);
	return 0;
}
输出结果
10 9 8 7 6 5 4 3 2 1 
10 12 9 8 12 7 6 12 5 12 4 3 2 1 12 
10 12 9 8 12 6 12 5 12 4 3 2 1 12 
10 66 9 8 66 6 66 5 66 4 3 2 66 
66
2 3 4 5 6 8 9 10 66 66 66 66 66 
2 3 4 5 6 8 9 10

chen＋1
关注
数据结构 Day 3 主函数
06-12
main.c
数据结构 Day 3 预处理
06-12
head.h
数据结构 day2
Y571428的博客
03-12 743
2.3.4.
数据结构Day1作业
weixin_44559978的博客
03-11 778
【代码】数据结构Day1作业。
数据结构 day6
qq_51722235的博客
08-30 1017
顺序栈/链栈、顺序队列
数据结构day1
Johan1111的博客
03-11 806
思维导图。
计算机考研数据结构代码题总结--Day01
热门推荐
brotherand的博客
10-05 1万+
计算机考研数据结构代码题总结 链表 题目1 在带头节点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的节点不唯一，试编写算法实现。 .算法思路 1、图解 . 2、图解含义描述 实现带头节点的单链表的删除指定值的操作。 首先需要定义三个指针，其中pre指向的是头节点，p初始化指向为L头节点的下一个节点，q作为操作指针。如图所示 算法的思想便是对单链表进行遍历 遍历过程中对p指针的数据域进行比对 相等的数据域与X相等，那么便要进行删除操作。 关键操作 1、. 删除操作首先需要将q操作指针指向p
数据结构与算法Day2
nendie1的博客
01-26 1272
顺序表的基本形式 1.顺序表结构 包含顺序表表头信息以及数据区两个部分组成 2.顺序表两种实现形式 顺序表组成部分：表头信息以及数据区 表头信息包括容量以及元素个数 数据区既包含数据 一体式结构：表头信息+数据区 两个区域连接在一起 分离式结构：表头信息一个顺序表 数据区一个顺序表 其中表头信息有一个存储数据区第一个元素的物理地址 两种结构相比之下，分离式结构更适合修改数据，进行操作时时间复杂度比一体式结构要少 3.元素存储区替换 一体式结构在元素要修改时，需要改变整个顺序表的信息，即.
数据结构课设——航空订票
Stephen_Curry___的博客
01-07 2323
根据客户提供的情况(日期、航班),为客户办理退票手续,然后查 询该航班是否有人排队候补,首先询问排在第一的客户,若所退票额能满足该客户的要求 则为其办理订票手续,否则依次询问其他排队候补的客户。输入航班编号，需要定的票数，你想要定的舱位等级，姓名身份证号，星期几这些信息，如果该飞机该舱位还有空余，则订票成功，并输出乘客所有的机位。有关订票的客户信息(包括姓名、订票量、舱位等级(1,2 和 3) 及等候替补的客户名单(包括姓名、所需票量)（3）系统实现的主要操作和功能。系统实现的主要操作和功能如下。
数据结构代码题Day04---树
brotherand的博客
11-03 2585
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
计算机数据结构代码题----Day02
brotherand的博客
10-06 5734
计算机数据结构代码题----Day02 顺序表代码题 题目01 从顺序表中删除其数值在给定数值为s与t之间，包含(s和t)，要求（s<t）的所有元素，如果s或t的顺序不合理或者顺序表为空，则显示出错误信息。 1、算法图解 如下图 思路： 扫描顺序表，将S->t的数进行搜索， 扫描到该范围内进行记录数K+1， 若不是在s到t之间范围的数，那么就要进行前移动k个单位长度，与上一篇的删除数据进行设计。 实现步骤 1、核心代码： int k = 0; while(i<L.length){
数据结构代码题----Day04
brotherand的博客
10-08 4158
数据结构代码题总结 题目01 题目描述： 设在一个带头节点的单链表中所有元素的节点的数据值无序，试编写一个函数，删除表中所有介于给定两个数值之间的元素 1、算法思路 进行删除指定条件下的节点 先查找该指定节点 删除指定节点 2、查找指定节点 以条件区间【min，max】为匹配数值进行遍历链表查找， 3、删除元素 步骤主要是： 设置一个前驱指针进行next指向当前删除指针的next free释放当前删除指针的内存 为p重新赋值 其实现代码如下： //删除单链表中指定区间【min,max】的数据 //这
数据结构 Day 3 功能函数
06-12
function.c
【数据结构】Day51
08-03
【数据结构】Day51和Day52的内容主要聚焦在数据结构中的树，特别是二叉树和表达式树。在这一部分的学习中，我们将深入理解这两种重要的数据结构及其应用。 4.2 叉树（Binary Trees） 二叉树是一种特殊类型的树，...
数据结构，day1内容整理
07-25
数据结构，day1内容整理
数据结构模拟题［二］
mufengzhiyu666的博客
10-30 447
4． 设一棵树 T 中边的集合为 {(A ，B) ，(A，C)，(A ，D)，(B，E)， (C，F)，(C，G)} ，要求用孩子兄弟表。7. 设一组初始记录关键字序列为 (55 ，63， 44， 38，75， 80，31， 56) ，则利用筛选法建立的初始堆为。3． 设一组有序的记录关键字序列为 (13 ，18，24，35， 47，50，62， 83，90) ，查找方法用二分查找，要。6． 设有一组初始记录关键字为 (45 ，80， 48，40，22， 78)，要求构造一棵二叉排序树并给出构造过程。
线性数据结构之链表
最新发布
m0_61840987的博客
10-31 441
单链表、双向链表、循环链表、哨兵链表在不同场景下的应用优势。每种链表类型在特定应用场景中能够发挥其独特的性能优势，通过选择合适的数据结构可以使程序更高效。
【高阶数据结构】红黑树的插入
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
10-29 877
超多精美配图讲解红黑树的插入方法；红黑树的插入C++完整代码的实现。
数据结构+算法分析与设计［19-21年真题版］
mufengzhiyu666的博客
10-29 309
八、设有一组关键字{19，01，23，14，55，20，84，27，68，11，10，77}，采用哈希函数： H(Key)=Key MOD 13， 采用开放地址法的线性探测再散列方法解决冲突，试在0～18的散列地址空间中对该关键字序列构造哈希表。八、依次输入表（30，15，28，20，24，10，12，68，35，50，46，55）中的元素，生成一棵二叉树排序树。七、给出一组关键字（29，18，25，47，58，12，51，10），分别写出按下列各种排序方法进行排序时的变化过程： （15分）
数据结构C语言day
08-27
- *1* *2* *3* [数据结构-C语言代码 day 5-多项式加法](https://blog.csdn.net/yydslty/article/details/124612624)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值