数据结构day3

最新推荐文章于 2024-10-31 13:56:46 发布
最新推荐文章于 2024-10-31 13:56:46 发布
阅读量64 收藏
点赞数 5
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51479108/article/details/132059433
版权

1.功能受限的表结构

    对表结构的功能加以限制，形成特殊的表结构

   (1) 栈：

        只有一个出入口的表结构，先进后出，FILO表

        1.顺序栈：

            数据项：

                存储元素的内存首地址

                栈的容量

                栈顶位置

            运算：

                创建、销毁、入栈、出栈、栈顶、栈空、栈满、数量

#include <stdio.h>    //顺序栈
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

// 栈的结构体
typedef struct ArrayStack
{
	TYPE* ptr;   //栈存放内容的指针
	size_t cal;  //容量
	size_t top;   //栈顶位置下标
}ArrayStack;

// 创建
ArrayStack* create_array_stack(size_t cal)
{
	ArrayStack* stack=malloc(sizeof(ArrayStack));
	stack->ptr=malloc(sizeof(TYPE)*cal);
	stack->cal=cal;
	stack->top=0;
	return stack;
}

// 销毁
void destroy_array_stack(ArrayStack* stack)
{
	free(stack->ptr);
	free(stack);
}

// 栈空
bool empty_array_stack(ArrayStack* stack)
{
	return !stack->top;
}

// 栈满
bool full_array_stack(ArrayStack* stack)
{
	return stack->top>=stack->cal;
}

// 入栈
bool push_array_stack(ArrayStack* stack,TYPE data)
{
	 if(full_array_stack(stack)) return false;
	 stack->ptr[stack->top++]=data;
	 return true;
}

// 出栈
bool pop_array_stack(ArrayStack* stack)
{
	if(empty_array_stack(stack)) return false;
	stack->top--;
	return true;
}

// 查看栈顶的数据
bool top_array_stack(ArrayStack* stack,TYPE* data)
{
	if(empty_array_stack(stack)) return false;
	*data=stack->ptr[stack->top-1];
	return true;
}
// 数量
size_t size_array_stack(ArrayStack* stack)
{
	return stack->top;
}

int main(int argc,const char* argv[])
{
	ArrayStack* stack=create_array_stack(10);
	push_array_stack(stack,3);
	int num=0;
	top_array_stack(stack,&num);
	printf("%d\n",num);
	int a[5]={1,2,3,4,5},b[5]={3,2,4,5,1};
	if(is_pop(a,b,5))  //判断
		printf("yes");
	else
		printf("no");
	return 0;
}
输出结果
3
yes

        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;
}

//	设计链式栈
typedef struct ListStack
{
	Node* top;		//	指向栈顶指针
	size_t size;	//	栈的节点数量
}ListStack;

//	创建栈
ListStack* create_list_stack(void)
{
	ListStack* stack = malloc(sizeof(ListStack));
	stack->top = NULL;
	stack->size = 0;
	return stack;
}
//	栈空
bool empty_list_stack(ListStack* stack)
{
	return 0 == stack->size;
}
//	入栈
void push_list_stack(ListStack* stack,TYPE data)
{
	Node* node = create_node(data);
	node->next = stack->top;
	stack->top = node;
	stack->size++;
}
//	出栈
bool pop_list_stack(ListStack* stack)
{
	if(empty_list_stack(stack)) return false;

	Node* temp = stack->top;
	stack->top = temp->next;
	free(temp);
	stack->size--;
	return true;
}
//	栈顶
TYPE top_list_stack(ListStack* stack)
{
	return stack->top->data;
}
//	节点数
size_t size_list_stack(ListStack* stack)
{
	return stack->size;
}
//	销毁栈
void destroy_list_stack(ListStack* stack)
{
	while(pop_list_stack(stack))
	free(stack);
}

int main(int argc,const char* argv[])
{
	ListStack* stack = create_list_stack();
	for(int i=0; i<10; i++)
	{
		push_list_stack(stack,i+1);
		printf("top:%d size:%d\n",
			top_list_stack(stack),size_list_stack(stack));
	}
	printf("----------------\n");
	while(!empty_list_stack(stack))
	{
		printf("top:%d size:%d\n",
			top_list_stack(stack),size_list_stack(stack));
		pop_list_stack(stack);
	}
	destroy_list_stack(stack);
}
输出结果
top:1 size:1
top:2 size:2
top:3 size:3
top:4 size:4
top:5 size:5
top:6 size:6
top:7 size:7
top:8 size:8
top:9 size:9
top:10 size:10
----------------
top:10 size:10
top:9 size:9
top:8 size:8
top:7 size:7
top:6 size:6
top:5 size:5
top:4 size:4
top:3 size:3
top:2 size:2
top:1 size:1

        3.栈的应用：

        1、栈内存的数据存储方式

        2、函数的调用

        3、生产者与消费者模型(仓库：可用栈实现)

        4、表达式解析

            a+b*c/2 中缀表达式

            计算机中以后缀表达式存储 中缀转后缀表达式使用栈

        4.常见的栈的笔试题：

            1、某序列为入栈序列，判断哪个序列为正确\不正确的出栈序列

                            i

                入栈： 1 2 3 4 5        a

                      3  2  1 4 5        b

                            j

                出栈： 1 2 3 4 5 yes

                      3 2 1 5 4 yes

                       5 4 2 1 3 no

            2、实现一个函数，判断序列b是否是序列a的出栈序列

            int a[5] = {1,2,3,4,5},b[5]={1,2,3,4,5};

            is_pop(a,b,5)

            bool is_pop(int* a,int* b,int len)

            {

                //  创建一个栈

                //  按照a的顺序一个个入栈

                    //  入栈一个就按b的顺序出栈

                //  结束后判断是否栈空

            }

// 判断序列b是否是序列a的出栈序列
bool is_pop(const int* a,const int* b,size_t len)
{
	ArrayStack* stack=create_array_stack(len);
	int j=0;
	for(int i=0;i<len;i++)
	{
		push_array_stack(stack,a[i]);
		int top_num=-1;
		while(top_array_stack(stack,&top_num)&&top_num==b[j])
		{
			j++;
			pop_array_stack(stack);
		}
	}
	bool flag=empty_array_stack(stack);
	destroy_array_stack(stack);
	return flag;
}
            3、两个顺序栈，如何安排入栈方向可以让内存使用率最大化？

                 让两个顺序栈相邻，且入栈方向相对入栈，能够让内存空间利用率最大化

           栈相关的概念：

                假设栈容量为cal

            空增栈：

                top: 0开始  先入栈，再top++

            满增栈：

                top: -1开始  先top++，再入栈

            空减栈：

                top: cal-1开始  先入栈，再top--

            满减栈：

                top: cal开始  先top--，再入栈

(2)队列：

        只有两个口进出数据，一个专门进入数据，另一个专门出数据，先进先出，FIFO表

    1.顺序队列：

        存储元素的连续内存的首地址

         数据项：

        容量

        队头位置    (出队)

        队尾位置    (入队)

        [元素数量]

        运算：

                创建、销毁、清空、出队、入队、队空、队满、队头、队尾、元素数量

        需要注意的问题

        1、存储元素是由一维数组+队头位置front+队尾位置rear来表示，入队rear+1,出队front+1，为了让队列能够反复使用，我们需要把一维数组想象成一个环，因此+1后都需要对容量cal求余

            front = (front+1)%cal

            rear = (rear+1)%cal

       

        2、判断队空和队满问题

            如果不处理该问题，那么队空和队满的条件都是 front==rear，就无法区分是队空还是队满

            方法1：存储元素的内存多增加一个位置空间(常考)

                队空：front==rear

                队满：(rear+1)%cal == front

                代价：需要额外申请存储一个元素的内存

                计算数量：(rear-front+cal)%cal

                队尾数据下标：(rear-1+cal)%cal

            方法2：顺序队列结构中增加一个记录元素数量的数据项，通过数量与容量对比判断队空、队满

   

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

#define TYPE int

// 设计顺序队列结构
typedef struct ArrayQueue
{
	TYPE* ptr;
	size_t cal;
	size_t front;   //head/begin 队头位置
	size_t rear;    //back/tail  队尾位置  也可以int类型 从-1开始
	size_t cnt;
}ArrayQueue;

//  创建顺序队列
ArrayQueue* creat_array_queue(size_t cal)
{
	ArrayQueue* queue=malloc(sizeof(ArrayQueue));

	queue->ptr=malloc(sizeof(TYPE)*cal);
	queue->cal=cal;
	queue->front=0;
	queue->rear=0;
	queue->cnt=0;

	return queue;
}

// 销毁
void destroy_array_queue(ArrayQueue* queue)
{
	free(queue->ptr);
	free(queue);
}

// 队空
bool empty_array_queue(ArrayQueue* queue)
{
	return 0==queue->cnt;
}

// 队满
bool full_array_queue(ArrayQueue* queue)
{
	return queue->cnt==queue->cal;
}

// 入队
bool push_array_queue(ArrayQueue* queue,TYPE data)
{
	if(full_array_queue(queue))  return false;
	queue->ptr[queue->rear]=data;
	queue->rear=(queue->rear+1)%queue->cal;
	queue->cnt++;
	return true;
}

// 出队
bool pop_array_queue(ArrayQueue* queue)
{
	if(empty_array_queue(queue))  return false;
	queue->front=(queue->front+1)%queue->cal;
	queue->cnt--;
	return true;
}

// 查看队头
TYPE head_array_queue(ArrayQueue* queue)
{
	return queue->ptr[queue->front];
}

// 查看队尾
TYPE tail_array_queue(ArrayQueue* queue)
{
	return queue->ptr[(queue->rear-1+queue->cal)%queue->cal];
}

// 数量
size_t size_array_queue(ArrayQueue* queue)
{
	return queue->cnt;
}

int main(int argc,const char* argv[])
{
	ArrayQueue* queue=creat_array_queue(5);
	for(int i=0; i<10;i++)
	{
		push_array_queue(queue,i+1) && printf("tail:%d size:%d\n",
				tail_array_queue(queue),size_array_queue(queue));  //入队成功才打印
	}
	printf("\n");
	while(!empty_array_queue(queue))
	{
		printf("front:%d size:%d\n",
				head_array_queue(queue),size_array_queue(queue));
		pop_array_queue(queue);
	}
		printf("size:%d\n",size_array_queue(queue));

	destroy_array_queue(queue);
	queue=NULL;
	return 0;
}
输出结果
tail:1 size:1
tail:2 size:2
tail:3 size:3
tail:4 size:4
tail:5 size:5

front:1 size:5
front:2 size:4
front:3 size:3
front:4 size:2
front:5 size:1
size:0

    2.链式队列：

        由若干个节点组成的队列结构，只能操作队头节点、队尾节点

        链式队列结构(数据项)：

            队头指针

            队尾指针

            节点数量

        运算：

                创建、销毁、队空、入队、出队、队头、队尾、数量

           

#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;
}

//设计链式队列
typedef struct ListQueue
{
	Node* head;//队头
	Node* tail;//队尾
	size_t cnt;//节点数量
}ListQueue;

//创建队列
ListQueue* create_list_queue(void)
{
	ListQueue* queue=malloc(sizeof(ListQueue));
	queue->head=NULL;
	queue->tail=NULL;
	queue->cnt=0;
	return queue;
}

//队空
bool empty_list_queue(ListQueue* queue)
{
	return 0==queue->cnt;
}

//入队
void push_list_queue(ListQueue* queue,TYPE data)
{
	Node* node=creat_node(data);
	if(0==queue->cnt)
	{
		queue->head=node;
		queue->tail=node;
	}
	else
	{
		queue->tail->next=node;
		queue->tail=node;
	}
	queue->cnt++;
}

//出队
bool pop_list_queue(ListQueue* queue)
{
	if(empty_list_queue(queue)) return false;
	Node* temp=queue->head;
	queue->head=temp->next;
	free(temp);
	queue->cnt--;
	if(0==queue->cnt) queue->tail=NULL;
	return true;
}

//队头
TYPE head_list_queue(ListQueue* queue)
{
	return queue->head->data;
}

//队尾
TYPE tail_list_queue(ListQueue* queue)
{
	return queue->tail->data;
}

//数量
size_t size_list_queue(ListQueue* queue)
{
	return queue->cnt;
}

//销毁队列
void destroy_list_queue(ListQueue* queue)
{
	while( pop_list_queue(queue));
	free(queue);
}

int main(int argc,const char* argv[])
{
	ListQueue* queue=create_list_queue();
	for(int i=0;i<10;i++)
	{
		push_list_queue(queue,i+10);
		printf("tail:%d ,size:%u\n",
				tail_list_queue(queue),size_list_queue(queue));
	}
	printf("-------------------\n");
	while(!empty_list_queue(queue))
	{
		printf("head:%d ,size:%u\n",
				head_list_queue(queue),size_list_queue(queue));
		pop_list_queue(queue);
	}
	printf("size:%d\n",size_list_queue(queue));

	destroy_list_queue(queue);
	queue=NULL;
	return 0;
}
输出结果
tail:10 ,size:1
tail:11 ,size:2
tail:12 ,size:3
tail:13 ,size:4
tail:14 ,size:5
tail:15 ,size:6
tail:16 ,size:7
tail:17 ,size:8
tail:18 ,size:9
tail:19 ,size:10
-------------------
head:10 ,size:10
head:11 ,size:9
head:12 ,size:8
head:13 ,size:7
head:14 ,size:6
head:15 ,size:5
head:16 ,size:4
head:17 ,size:3
head:18 ,size:2
head:19 ,size:1
size:0

    3.队列的应用：

        1、数据排队处理-消息排队

        2、树的层序遍历

        3、图的广度优先遍历BFS

        4、封装线程池、数据池

    4.常考的笔试题、面试题：

        请使用两个栈来模拟一个队列的出队、入队功能(栈结构的功能都已实现，可以直接使用)

        typedef struct Queue

        {

            ArrayStack* s1;

            ArrayStack* s2;

        }Queue;

//2个栈组成队列结构
typedef struct Queue
{
	ArrayStack* s1;
	ArrayStack* s2;
}Queue;

// 创建队列
Queue* create_queue(size_t cal)
{
	Queue* queue=malloc(sizeof(Queue));
	queue->s1=create_array_stack(cal);
	queue->s2=create_array_stack(cal);
	return queue;
}

// 入队
bool push_queue(Queue* queue,TYPE data)
{
	if(full_array_stack(queue->s1))
	{
		//s1满 s2非空
		if(!empty_array_stack(queue->s2))  return false;
		//s1满 s2空
		while(!empty_array_stack(queue->s1))
		{
			TYPE top=0;
			top_array_stack(queue->s1,&top);
			push_array_stack(queue->s2,top);
			pop_array_stack(queue->s1);
		}
	}
	return push_array_stack(queue->s1,data)&&printf("tail:%d\n",data);
}

// 出队
bool pop_queue(Queue* queue)
{
	if(empty_array_stack(queue->s2))
	{
		if(empty_array_stack(queue->s1)) return false;
		while(!empty_array_stack(queue->s1))
		{
			TYPE top=0;
			top_array_stack(queue->s1,&top);
			push_array_stack(queue->s2,top);
			pop_array_stack(queue->s1);
		}
	}
	return pop_array_stack(queue->s2);
}

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
数据结构代码题Day04---树
brotherand的博客
11-03 2585
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
数据结构课设——航空订票
Stephen_Curry___的博客
01-07 2323
根据客户提供的情况(日期、航班),为客户办理退票手续,然后查 询该航班是否有人排队候补,首先询问排在第一的客户,若所退票额能满足该客户的要求 则为其办理订票手续,否则依次询问其他排队候补的客户。输入航班编号，需要定的票数，你想要定的舱位等级，姓名身份证号，星期几这些信息，如果该飞机该舱位还有空余，则订票成功，并输出乘客所有的机位。有关订票的客户信息(包括姓名、订票量、舱位等级(1,2 和 3) 及等候替补的客户名单(包括姓名、所需票量)（3）系统实现的主要操作和功能。系统实现的主要操作和功能如下。
计算机数据结构代码题----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】的数据 //这
数据结构第一天
C/C++/Linux/MySQL
11-23 1304
研究数据结构第一天——Day 1 今天是我自学数据结构的第一天，学习了几个名词，说实话真心没看懂。 第一步，我先看了前言，据作者说c语言不是描述数据结构的好工具，所以虽然这本书是以c语言为工具讲述的数据结构但是，加入c++的工具比如引用调用&。 第二步，本书向我讲解了什么叫抽象数据类型，说实话真心没看懂，但是也有些理解，就是抽象数据结构大概就是，一个数学模型但是还有其对其操作。 解决问题...
数据结构 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_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值