0721|数据结构day7 查找+二叉树

已于 2023-07-23 16:04:20 修改
阅读量255 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构
于 2023-07-21 21:06:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smallxu_/article/details/131859910
版权

一、思维导图

二、今日练习

2.1 折半查找

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int half(int key,int *p,int low,int high)
{
	while(high<=low)
	{
		int mid=(low+high)/2;
		if(key==*(p+mid))
		{	
			return mid;
		}
		else if(key>*(p+mid))
			low=mid-1;
		else
			high=mid+1;
	}
	return -1;
}
int main(int argc, const char *argv[])
{
	//折半查找
	int arr[]={99,88,77,66,55,44,33,22,11};
	int low=sizeof(arr)/sizeof(arr[0])-1,high=0;
	int *p=arr;
	int key;
	printf("please enter key:");
	scanf("%d",&key);
	int sub=half(key,p,low,high);
	if(sub==-1)
		printf("key不存在！\n");
	else
		printf("find key in %d\n",sub);
	return 0;
}

2.2 哈希表查找

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
//哈希表是借助于单链表实现的
typedef int datatype;
typedef struct Node
{
	//数据域
	datatype data;
	//指针域
	struct Node *next;
}*node;

/*
 * function:    计算最大质数
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int max_prime(int m)
{
	for(int i=m;i>=2;i--)
	{
		int count=0;
		//i:m～2
		//判断i是否是质数，如果是则返回，不是则继续
		for(int j=2;j<=sqrt(i);j++)
		{
			if(i%j==0)
			{
				count++;//计算2～sqrt(i)之间约数的个数
				break;
			}
			if(count==0)
				return i;
		}
	}
}

/*
 * function:    节点创建
 * @param [ in] 
 * @param [out] 
 * @return      
 */
node create_node()
{
	node s=(node)malloc(sizeof(struct Node));
	if(NULL==s)
		return NULL;
	
	s->data=0;
	s->next=NULL;
	return s;
}


/*
 * function:    哈希表的插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
node insert_hash(int key,int p,node hash[])
{
	int sub=key%p;
	node L=hash[sub];
	//创建新节点s
	node s=create_node();
	s->data=key;
	if(L!=NULL)
	{
		s->next=L;
	}
	L=s;
	return L;
}

/*
 * function:    哈希表输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(node hash[],int p)
{
	for(int i=0;i<p;i++)
	{ 
		printf("%d: ",i);
		node L=hash[i];
		if(L==NULL)
		{
			puts("NULL!");
			continue;
		}
		while(L!=NULL)
		{
			printf("%d\t",L->data);
			L=L->next;
		}
		puts("NULL");
	}
}
/*
 * function:    哈希表查找
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int search_hash(datatype key,int p,node hash[])
{
	int sub=key%p;
	printf("sub=%d\n",sub);
	if(hash[sub]==NULL)
	{
		return -1;
	}
	node L=hash[sub];
	while(L!=NULL)
	{
		if(L->data==key)
		{
			return 0;
		}
		L=L->next;
	}
	return -1;
}
/*
 * function:    哈希表释放
 * @param [ in] 
 * @param [out] 
 * @return      
 */
node free_space(node hash[],int p)
{
	for(int i=0;i<p;i++)
	{
		while(hash[i]!=NULL)
		{
			node q=hash[i];
			hash[i]=hash[i]->next;
			free(q);
			q=NULL;
		}
	}
}
int main(int argc, const char *argv[])
{
	//把数组的元素存到哈希表中，再通过哈希表实现查找
	int arr[]={67,54,41,67,1093,2345,2345,123,34,123};
	int len=sizeof(arr)/sizeof(arr[0]);
	int m=len*4/3;
	int p=max_prime(m);
	
	//构建哈希表
	node hash[p];  //指针数组，存储p个指针
	for(int i=0;i<p;i++)
	{
		hash[i]=NULL;
	}
	//把数组元素存到哈希表
	//
	for(int i=0;i<p;i++)
	{
		hash[arr[i]%p]=insert_hash(arr[i],p,hash);
	}
	//输出哈希表
	output(hash,p);
	//查找
	datatype key;
	printf("pleast enter key:");
	scanf("%d",&key);

	int flag=search_hash(key,p,hash);
	if(flag==0)
		puts("success");
	else
		puts("error");
	//释放
	free_space(hash,p);
	output(hash,p);
	return 0;
}

2.3 利用递归输出5 4 3 2 1

效果等同于n=5 ; n<=0 ; n--

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void rec(int n)
{
	if(n==0)
		return;
	else
	{
		printf("%d\n",n);
	}
	rec(n-1);
}
int main(int argc, const char *argv[])
{
	//实现n的阶乘
	int n=5;
	rec(n);
	return 0;
}

调用过程：

 递归循环5次：

2.4 用递归实现n的阶乘【n！】

n！=n*n-1*n-2*n-3*...*1

5！=5*4*3*2*1=120

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int rec(int n)
{
	static int p=1;
	if(n==0)//n！：0！=1
		return 1;
	else
	{
		/*
		   p*=n;
		   rec(n-1);
		   return p;
		   */
		return n*=rec(n-1);
	}
}
int main(int argc, const char *argv[])
{
	//利用递归实现n的阶乘（5!=5*4*3*2*1）
	int n;
	printf("please enter n=");
	scanf("%d",&n);
	int p=rec(n);
	printf("%d!= %d\n",n,p);
	return 0;
}

2.5 用递归实现斐波那契数列

斐波那契数列 1 1 2 3 5 8 13.....

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int Fibonaci(int n)
{
	if(n==1 || n==2)
	{
		return 1;
	}
	else
	{
		return Fibonaci(n-1)+Fibonaci(n-2);
	}
}
int main(int argc, const char *argv[])
{
	//利用递归实现斐波那契数列
	int n;
	printf("please enter n=");
	scanf("%d",&n);
	int num=Fibonaci(n);
	printf("第%d项斐波那契数是：%d\n",n,num);
	for(int i=1;i<=n;i++)
	{
		printf("%d\t",Fibonaci(i));
	}
	puts("");
	return 0;
}

  

调用过程：

2.6 用递归实现建立树、先中后序遍历、输出、释放

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char datatype;
typedef struct Node
{
	//数据域
	datatype data;
	//左孩子
	struct Node *lchild;
	//右孩子
	struct Node *rchild;
}*Btree;

/*
 * function:    创建二叉树
 * @param [ in] 
 * @param [out] 
 * @return      返回根节点的地址
 */
Btree create_tree()
{
	datatype e;
	printf("Please enter tree data:");
	scanf(" %c",&e);
	if(e=='#')
		return NULL;

	Btree tree=(Btree)malloc(sizeof(struct Node));
	if(tree==NULL)
		return NULL;
	tree->data=e;//赋数据域
	//创建左子树
	puts("左孩子");
	tree->lchild=create_tree();
	//创建右子树
	puts("右孩子");
	tree->rchild=create_tree();
	return tree;
}
/*
 * function:    先序遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void first_output(Btree tree)
{
	if(tree==NULL)
	{
		return;
	}
	printf("%c\t",tree->data);
	first_output(tree->lchild);
	first_output(tree->rchild);
}

/*
 * function:    中序遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void mid_output(Btree tree)
{
	if(tree==NULL)
	{
		return;
	}
	mid_output(tree->lchild);
	printf("%c\t",tree->data);
	mid_output(tree->rchild);
}

/*
 * function:    后序遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void last_output(Btree tree)
{
	if(tree==NULL)
	{
		return;
	}
	last_output(tree->lchild);
	last_output(tree->rchild);
	printf("%c\t",tree->data);
}
/*
 * function:    计算n0，n1，n2
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void Count(Btree tree,int *n0,int *n1,int *n2)
{
	if(tree==NULL)
		return;
	else if(tree->lchild==NULL &&tree->rchild==NULL)
		++(*n0);
	else if(tree->lchild!=NULL &&tree->rchild!=NULL)
		++(*n2);
	else
		++(*n1);
	Count(tree->lchild,n0,n1,n2);
	Count(tree->rchild,n0,n1,n2);
}
/*
 * function:    树的度
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int High(Btree tree)
{
	if(tree==NULL)
		return 0;

	int left=High(tree->lchild)+1;
	int right=High(tree->rchild)+1;
	return left>right?left:right;
}
/*
 * function:    树的释放【采用后续遍历释放】
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Btree free_space(Btree tree)
{
	if(tree==NULL)
		return NULL;

	free_space(tree->lchild);
	free_space(tree->rchild);
	free(tree);
	tree=NULL;
}
int main(int argc, const char *argv[])
{
	//tree
	//创建并输入，递归
	Btree tree=create_tree();
	//先序遍历：根左右
	puts("先序遍历:");
	first_output(tree);
	//中序遍历：左根右
	puts("\n中序遍历：");
	mid_output(tree);
	//后序遍历：左右根
	puts("\n后序遍历：");
	last_output(tree);
	int n0=0,n1=0,n2=0;
	Count(tree,&n0,&n1,&n2);
	printf("n0=%d\tn1=%d\tn2=%d\n",n0,n1,n2);
	int h=High(tree);
	printf("高度是：%d\n",h);
	tree=free_space(tree);
	first_output(tree);
	puts("释放成功");
	return 0;
}

三、作业

3.1 【多选题】在一棵度为3的树中，度为3的结点数为2个，度为2的结点数为1个，度为1的结点数为2个，则度为0的结点数不可能为 (   )个。

A. 6

B. 7

C. 4

D. 5

解析：

选BCD

先算出这棵树中一共有几个节点：n=n0+n1+n2+n3

现在未知n=几？

由于在任意一颗二叉树中，叶子节点（n0）的数目比 度为2（n2）的节点的数目多1

∴ n=n×n3+n×n2+n×n1+1

     =3*2+2*1+1*2+1

     =11

n=n0+n1+n2+n3

11=n0+2+1+2

11=n0+5

∴ n0=6

排除BCD即可

建议画图

3.2【多选题】设树T的度为4，其中度为1，2，3和4的结点个数分别为4，2，2，1 则T中的叶子数不可能是 (   )个。

A. 5

B. 8

C. 6

D. 10

解析：

选ABC

先算出这棵树中一共有几个节点：n=n0+n1+n2+n3

现在未知n=几？

由于在任意一颗二叉树中，叶子节点（n0）的数目比 度为2（n2）的节点的数目多1

∴ n=n×n3+n×n2+n×n1+1

     =1*4+2*2+3*2+4*1+1

     =19

n=n0+n1+n2+n3

n0=19-4-2-2-1=10

∴ n0=10

建议画图

3.3 深度为5的完全二叉树最少有多少个结点 (C)

A. 32

B. 16

C. 31

D. 15

解析：

解析：

第一层：1个

第二层：2个

第三层：4个

第四层：8个

第五层：16个

总：31

3.4 已知一棵完全二又树有500个结点，则这棵树的深度是 (D)

A. 7

B. 8

C. 10

D. 9

3.5 若对一棵有16个结点的完全二叉树按层编号，则对于编号为7的结点x，它的双亲结点及右孩子结点的编号分别为(B)

A. 2,15
B. 3,15
C. 2,14
D. 3,14

3.6 【多选题】一个具有63个结点的二叉树的高h的值可能是 (ABD) 。

A. 63
B. 10
C. 5
D. 6

解析：

在深度为k的二叉树上，最多有2^k-1个节点（k>=1）

2^5-1=31

∴不是答案

3.7 已知一棵完全二叉树有5层，则第5层最少和最多分别有 (A)个结点

A. 1,16
B. 2,15
C. 1,31
D. 1,17

3.8 已知遍历结果如下，试画出对应的二叉树

前序: ABCEHFIJDGK

中序: AHECIFJBDKG

 3.9 已知树的先序遍历是GDAFEMHZ，中序遍历是ADEFGHMZ，则后序遍历的结果是 ( C )

A. AEFDMZHG

B. ADFEHZMG

C. AEFDHZMG

D. AMZHEFDG

3.10 已知某二又树的后序遍历序列是dabec，中序遍历序列是debac，它的先序遍历序列是 ( B )

A. acbed
B. cedba
C. decab
D. deabc

徐艺桐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构 day7 树+二叉树+哈希表
2203_75782206的博客
12-28 598
树，二叉树，哈希表
Java数据结构学习DAY5——二叉树(四)
graceyun的博客
03-22 267
1.6二叉树最大深度 题目描述： 力扣代码实现 在这里插入代码片 结果 1.7平衡二叉树 题目描述： 力扣代码实现 在这里插入代码片 结果 1.8 对称二叉树 题目描述： 力扣代码实现 在这里插入代码片 结果 2、 进阶面试题 二叉树的构建及遍历。 二叉树的分层遍历 。 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。 二叉树搜索树转换成排序双向链表。 根据一棵树的前序遍历与中序遍历构造二叉树。 根据一棵树的中序遍历与后序遍历构造二叉树。 二叉树创建字符串。 3、
Java数据结构学习DAY5——二叉树(一)
graceyun的博客
03-16 567
Java数据结构学习DAY5——二叉树 1. 树型结构（了解） 1.1 概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合Ti (1 <= i <= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，
day10（数据结构）查找方法
QR70892的博客
08-22 930
（数据结构）查找方法
Java数据结构学习DAY5——二叉树(二)
graceyun的博客
03-18 113
Java数据结构学习DAY5——二叉树(二) 1、 二叉树的基本操作 // 前序遍历 void preOrderTraversal(Node root); // 中序遍历 void inOrderTraversal(Node root); // 后序遍历 void postOrderTraversal(Node root); // 遍历思路-求结点个数 static int size = 0; void getSize1(Node root); // 子问题思路-求结点个数 int getSize2
数据结构day7
xiaohuoxingdezhu的博客
07-23 37
【代码】数据结构day7。
数据结构与算法Day08二叉树（树的基础）
weixin_49957376的博客
10-18 247
并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。4)如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。
嵌入式学习——数据结构（队列、二叉树）——day49
qq_47798402的博客
06-21 282
高速设备和低速设备利用缓冲区进行协调匹配。8. 树——一对多（与线性一对一不同）（二叉树的思想是递归）8.4 完全二叉树（从满二叉树中从左至右、从前置后插入）3. 串口数据的通信利用队列进行协调。2. 缓冲区——先进先出的队列。节点的度：该节点后继节点的个数。8.1 深度和（广）度（数的度（广度））7. 队列和栈的区别——队列应用更广泛。4. 顺序队列——循环队列（非重点）8.3 满二叉树（树都是饱满的）8.2 二叉树（（广）度为2）1. 满二叉树第k层节点个数。叶子节点：没有后继节点。
DAY17：二叉树（七）平衡二叉树+二叉树所有路径，理解递归和回溯
CFY1226的博客
06-07 119
关于根节点的深度究竟是1 还是 0，不同的地方有不一样的标准，leetcode的题目中都是以节点为一度，即根节点深度是1。这道题的解法中必须要有回溯的部分，例如示例中的二叉树，收集路径1->2->5，收集完毕之后需要把5弹出，再把2弹出，再回到根节点1节点继续收集根节点到叶子节点的路径，也就是重新加入3。我们希望得到所有从根节点到叶节点的路径，那么正确的结果应该是：[“1->2->4”, “1->2->5”, “1->3”]。，那么我们应该立即停止其他所有的检查并返回-1，表示整个树是不平衡的。
春节7天练丨Day5：二叉树和堆1
08-03
在IT领域，二叉树和堆是两种非常重要的数据结构，它们在算法设计和实现中起着关键作用。本文将详细讲解二叉树和堆的相关知识点，并提供代码实现。 首先，二叉树是一种特殊的树形数据结构，其中每个节点最多有两个子...
【数据结构】Day51
08-03
【数据结构】Day51和Day52的内容主要聚焦在数据结构中的树，特别是二叉树和表达式树。在这一部分的学习中，我们将深入理解这两种重要的数据结构及其应用。 4.2 叉树（Binary Trees） 二叉树是一种特殊类型的树，...
【二叉树详解】二叉树的创建、遍历、查找以及删除等-数据结构05
东白的博客
11-21 1099
二叉树 1. 二叉树简介 定义： 每一个结点的子节点数量不超过 2 二叉树的结点分为：左节点、右节点 满二叉树： 每个结点都有两个子结点的二叉树（除了叶子结点外） 完全二叉树： 除去最后一层，是一个满二叉树，并且最后一层结点左连续 (从左到右，从上到下，依次编号1,2,3,4…，这样的编号和满二叉树一一对应的二叉树叫完全二叉树) 2. 链式存储的二叉树 2.1 创建二叉树 思路： 首先必须有一个BinaryTree 二叉树的类-用于设置根节点(也可以是一颗空树) ​ 其次需要结点
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 872
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 633
四、实验结果。
树状数组记录
最新发布
volcan的博客
09-06 605
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 356
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 374
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
专题一_双指针_算法专题详细总结
2301_80636070的博客
09-06 865
利用双指针，cur=0，dest=-1，只要nums[cur]==0 dest就走两格；否则 dest走一格；但是无论怎么样cur都走一格。直到dest到达结尾处n-1 停止，即 判断dest>=n-1 处 break；
数据结构解析：树与二叉树的查找过程
"这篇讲义主要探讨了数据结构中的核心概念，包括树、图、查找和排序。在查找过程中，特别提到了B+树的特性，这种数据结构既支持缩小范围的查找，也支持顺序查找。在B+树中，无论查找是否成功，都需要遍历到叶子结点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值