40.查找练习题（王道2023数据结构第7章）

news2024/9/25 7:26:35

试题1（王道7.2.4节综合练习5）：

写出折半查找的递归算法。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 10
#define ElemType int
#define Status int

typedef struct{
	int data[MAXSIZE];  //存储空间的基地址
	int length;  //当前长度 
}SqList;

void CreatList(SqList &L){  //建立线性表
	L.length = 6;
	L.data[0] = 2;
	L.data[1] = 3;
	L.data[2] = 5;
	L.data[3] = 7;
	L.data[4] = 9;
	L.data[5] = 11;
}

int BinarySearch(SqList L,ElemType x,int low,int high){
	int mid = (low + high) / 2;
	if(low > high)
		return -1;
	else if(L.data[mid] == x)
		return mid;
	else if(L.data[mid] < x)
		BinarySearch(L, x, mid + 1, high);
	else
		BinarySearch(L, x, low, mid - 1);
}

int main(){
	SqList L;
	CreatList(L);
	printf("%d", BinarySearch(L, 7, 0, 5));
}

输出：

3

试题2（王道7.2.4节综合练习6）：

线性表中各结点检索概率不等时，可用如下策略提高顺序检索的效率：若找到指定的结点，则将该结点与前驱结点（若存在）交换，使得经常被检索的结点尽量位于表的前端。试设计在顺序结构和链式结构的线性表上实现上述策略的顺序检索算法。

此题可以联系链表练习题的第20题：

【试题再现】试题20：设头指针为L的带有表头结点的非循环双向链表，其每个结点中除有prior（前驱指针），data（数据），next（后继指针）域外，还有一个访问频度域freq。在链表被启用前，其值均初始化为零。每当在连表中进行一次Locate(L,x)运算时，令元素值为x的结点中freq域的值增1，并使此链表中结点保持按访问频度非递增的顺序排列，同时最近访问的结点排在频度相同的结点的前面，以便使频繁访问的结点总是靠近表头。试编写符合上述要求的Locate(L,x)运算的算法，该运算为函数过程，返回找到结点的地址，类型为指针型。

31.链表练习题（2）（王道2023数据结构2.3.7节16-25题）-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_54708219/article/details/133151369顺序表实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 10
#define ElemType int
#define Status int

typedef struct{
	int data[MAXSIZE];  //存储空间的基地址
	int length;  //当前长度 
}SqList;

void CreatList(SqList &L){  //建立线性表
	L.length = 6;
	L.data[0] = 2;
	L.data[1] = 3;
	L.data[2] = 5;
	L.data[3] = 7;
	L.data[4] = 9;
	L.data[5] = 11;
}

void PrintList(SqList L){
	for (int i = 0; i < L.length;i++){
		printf("%d ", L.data[i]);
	}
}

int Search(SqList &L,ElemType x){
	int t;
	for (int i = 0; i < L.length;i++){
		if(L.data[i] == x){
			t = L.data[i - 1];  //交换
			L.data[i - 1] = x;
			L.data[i] = t;
			return i;
		}	
	}
	return -1;
}

int main(){
	SqList L;
	CreatList(L);
	PrintList(L);
	printf("\n");
	printf("%d\n", Search(L, 7));
	PrintList(L);
}

输出：

2 3 5 7 9 11 
3
2 3 7 5 9 11

链表实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 10
#define ElemType int
#define Status int

//单链表的数据结构
typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;
 
//初始化
int InitList(LinkList &L)
{
	L = (LNode *)malloc(sizeof(LNode));
	L->next = NULL;
	return 1;
}
 
//输出
void PrintList(LinkList L)
{
	printf("当前单链表的所有元素：");
	LNode *p;
	p = L->next;
	while (p != NULL)
	{
		printf("[%d] ", p->data);
		p = p->next;
	}
	printf("\n");
}

int Create(LinkList &L)
{
	int n, e;
	LNode *temp = L;//声明一个指针指向头结点，用于遍历链表 　　
 
	printf("请输入要输入元素的个数：");
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		LNode *a = (LNode*)malloc(sizeof(LNode));
		printf("请输入第%d元素的值：", (i));
		scanf("%d", &e);
		a->data = e;
		temp->next = a;
		a->next = NULL;
		temp = temp->next;
	}
	return 1;
}

int Search(LinkList L,ElemType x){
	LinkList p = L;
	LinkList q = L;
	LinkList r;
	int i = 0;
	while(p!=NULL){
		if(p->data != x){
			p = p->next;
			i = i + 1;
		}
		else{
			if(i > 1){
				for (int j = 1; j <= i - 2; j++){
					q = q->next;
				}  //q指向第i-2个元素
				r = q->next;  //r指向第i-1个元素
				q->next = p;
				q = p->next;  //q指向第i+1个元素
				p->next = r;
				r->next = q;
			}
			return i;
		}
	}
	return -1;
}

int main(){
	LinkList L;
	InitList(L);
	Create(L);
	PrintList(L);
	printf("元素在链表第%d个位置\n", Search(L, 7));
	PrintList(L);
}

输出：

请输入要输入元素的个数：6
请输入第1元素的值：2
请输入第2元素的值：3
请输入第3元素的值：5
请输入第4元素的值：7
请输入第5元素的值：9
请输入第6元素的值：11
当前单链表的所有元素：[2] [3] [5] [7] [9] [11]
元素在链表第4个位置
当前单链表的所有元素：[2] [3] [7] [5] [9] [11]

试题3（王道7.3.4节综合练习6）：

设计算法，判断给定的二叉树是否是二叉排序树。

看其中序遍历序列是否是递增有序的即可：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 10
#define ElemType int

//二叉排序树的结构体定义
typedef struct BiTNode{
    ElemType data;  //数据域
    BiTNode *lchild;  //指向左子树根节点的指针
	BiTNode *rchild;  //指向右子树根节点的指针
}BiTNode, *BiTree;

int BST_Insert(BiTree &T,ElemType k){  //构造一棵二叉排序树
	if(T==NULL){
		T = (BiTree)malloc(sizeof(BiTNode));
		T->data = k;
		T->lchild = NULL;
		T->rchild = NULL;
		return 1;
	}
	else if(k==T->data){
		return 0;
	}
	else if(k<T->data){
		return BST_Insert(T->lchild, k);
	}
	else{
		return BST_Insert(T->rchild, k);
	}
}

int if_BST(BiTree T){
	int a[10];
	int i = 0;
	if (T!=NULL){
		if_BST(T->lchild);
		a[i] = T->data;
		i = i + 1;
		if_BST(T->rchild);
	}
	for (int j = 1; j <= i-1;j++){  //实际上a数组中元素是0到i-1
		if(a[j-1] >= a[j]){
			return 0;
		}
	}
	return 1;
}

int main(){
	BiTree T=NULL;
	int a[5] = {4, 2, 1, 3, 5};  //以王道第10题做验证
	for (int i = 0; i <= 4;i++){
		BST_Insert(T, a[i]);
	}
	printf("%d",if_BST(T));
	return 0;
}

输出：

1

试题4（王道7.3.4节综合练习7）：

设计算法求指定结点在给定二叉排序树的层次。

老问题了，直接上递归：

int levelofNode(BiTree T, ElemType x,int level){
	if(T==NULL)
		return -1;
	else{
		if(T->data==x)
			return level;
		else{
			if(T->data<x)
				return levelofNode(T->rchild, x, level + 1);
			else
				return levelofNode(T->lchild, x, level + 1);
		}
	}
}

int main(){
	BiTree T=NULL;
	int a[5] = {4, 2, 1, 3, 5};  //以王道第10题做验证
	for (int i = 0; i <= 4;i++){
		BST_Insert(T, a[i]);
	}
	printf("%d",levelofNode(T,3,1));
	return 0;
}

输出：

3

试题5（王道7.3.4节综合练习8）：

利用二叉树的遍历思想编写一个判断二叉树是否是平衡二叉树的算法。

这里利用层次遍历每一个结点，检查平衡因子绝对值是否小于1。全部通过才返回True。

int Depth(BiTree T){
    if(T==NULL)
        return 0;
    else{
        return (Depth(T->lchild) >= Depth(T->rchild)) ? Depth(T->lchild) + 1 : Depth(T->rchild) + 1;
    }
}

int abs(int x){
	return x >= 0 ? x : -x;
}

bool ifBalanceTree(BiTree T){  //层次遍历每一个结点
	int balance = 0;
	Queue q;
    InitQueue(q);
    BiTree p = T;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
		balance = abs(Depth(p->lchild) - Depth(p->rchild));
		if(balance > 1)
			return false;
		if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
	return true;
}

int main(){
	BiTree T=NULL;
	int a[5] = {1, 2, 3, 4, 5};  //以王道第10题做验证
	for (int i = 0; i <= 4;i++){
		BST_Insert(T, a[i]);
	}
	printf("%d",ifBalanceTree(T));
	return 0;
}

输出：

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

试题6（王道7.3.4节综合练习9）：

设计算法求给定二叉排序树最小和最大的关键字。

最小关键字在最左下，最大关键字在最右下，抓住这一点判断即可。此题不需要从头遍历把所有结点全部输出。

int maxvalue(BiTree T){  //求最大关键字
	BiTree p=T;
	while (p->rchild!=NULL){
		p = p->rchild;
	}
	return p->data;
}

int main(){
	BiTree T=NULL;
	int a[5] = {4, 2, 1, 3, 5};  //以王道第10题做验证
	for (int i = 0; i <= 4;i++){
		BST_Insert(T, a[i]);
	}
	printf("%d",maxvalue(T));
	return 0;
}
int minvalue(BiTree T){  //求最小关键字
	BiTree p=T;
	while (p->lchild!=NULL){
		p = p->lchild;
	}
	return p->data;
}

int main(){
	BiTree T=NULL;
	int a[5] = {4, 2, 1, 3, 5};  //以王道第10题做验证
	for (int i = 0; i <= 4;i++){
		BST_Insert(T, a[i]);
	}
	printf("%d",minvalue(T));
	return 0;
}

试题7（王道7.3.4节综合练习10）：

设计一个算法，从大到小输出二叉排序树中所有值不小于k的关键字。

倒序访问：显然先访问右子树，然后根结点，最后左子树，然后检查并输出。

void printoverk(BiTree T,int k){  //求最小关键字
	if(T!=NULL){
		printoverk(T->rchild, k);
		if(T->data>k){
			printf("%d ", T->data);
		}
		printoverk(T->lchild, k);
	}
}

int main(){
	BiTree T=NULL;
	int a[5] = {4, 2, 1, 3, 5};  //以王道第10题做验证
	for (int i = 0; i <= 4;i++){
		BST_Insert(T, a[i]);
	}
	printoverk(T, 2);
	return 0;
}

输出：

5 4 3

试题8（王道7.3.4节综合练习11）：

编写一个递归算法，在一棵具有n个结点的二叉排序树上查找第k小的元素，并返回该结点的指针。要求算法的平均时间复杂度是O(log_2n)，二叉排序树每个结点中除了data,lchild,rchild外，增设一个count成员，保存以该结点为根的子树的结点个数。

函数的参数有两个：二叉树指针T和查找第k个最小元素。

//求树的结点数（递归）
int Number_Node(BiTree T){
    if(T==NULL)
        return 0;
    else{
        return Number_Node(T->lchild) + Number_Node(T->rchild) + 1;
    }
}

int BST_Insert(BiTree &T,ElemType k){  //构造一棵二叉排序树
	if(T==NULL){
		T = (BiTree)malloc(sizeof(BiTNode));
		T->data = k;
		T->lchild = NULL;
		T->rchild = NULL;
		return 1;
	}
	else if(k==T->data){
		return 0;
	}
	else if(k<T->data){
		return BST_Insert(T->lchild, k);
	}
	else{
		return BST_Insert(T->rchild, k);
	}
}

void BST_Insertcount(BiTree &T){  //修改count的数值
    Queue q;
    InitQueue(q);
    BiTree p = T;
    InsertQueue(q, p);
    while(!IsQueueEmpty(q)){
        p = DeleteQueue(q, p);
        p->count = Number_Node(p);
        if(p->lchild!=NULL)
            InsertQueue(q, p->lchild);
        if(p->rchild!=NULL)
            InsertQueue(q, p->rchild);
    }
}
    
BiTree SearchSmallk(BiTree T,int k){  //寻找第k小的元素
    if(k<1||k>T->count)  //k不合法，直接返回空
        return NULL;
    if(T->lchild == NULL){
        if(k == 1)
            return T;
        else
            return SearchSmallk(T->rchild, k - 1);  //第k小的元素必在右子树
    }
    else{
        if(T->lchild->count == k-1)
            return T;
        else if(T->lchild->count < k-1)
            return SearchSmallk(T->rchild, k - T->lchild->count - 1);  //第k小的元素必在右子树
        else
            return SearchSmallk(T->lchild, k);  //第k小的元素必在左子树
    }
}

int main(){
	BiTree T=NULL;
    BiTree p;
    int a[5] = {4, 2, 1, 3, 5};  //以王道第10题做验证
	for (int i = 0; i <= 4;i++){
		BST_Insert(T, a[i]);
	}
    BST_Insertcount(T);
    p = SearchSmallk(T, 3);
    printf("%d", p->data);
    return 0;
}

输出：

3

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1133929.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

单例模式详解【2023年最新】

单例模式详解【2023年最新】

一、单例模式概念 单例模式是一种创建型设计模式&#xff0c;它确保一个类只有一个实例&#xff0c;并提供一个全局访问点来访问该实例。它的目的是限制一个类只能创建一个对象&#xff0c;以确保在整个应用程序中只有一个共享的实例。 单例模式通常用于以下情况&#xff1a;…
阅读更多...
服务容错框架Sentinel入门

服务容错框架Sentinel入门

概述 Sentinel&#xff0c;阿里开源的一套用于服务容错的综合性解决方案。它以流量为切入点&#xff0c;从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。分布式系统的流量防卫兵。 特征: 丰富的应用场景&#xff1a;秒杀&#xff08;即突发流量控制在系统…
阅读更多...
物联网AI MicroPython传感器学习 之 GP2Y10粉尘传感器

物联网AI MicroPython传感器学习 之 GP2Y10粉尘传感器

学物联网&#xff0c;来万物简单IoT物联网&#xff01;&#xff01; 一、产品简介 GP2Y10粉尘传感器用于检测非常细的空气漂浮颗粒物&#xff0c;主要用于空气净化系统中&#xff0c;传感器外观引脚如下图所示。 引脚定义 GND&#xff1a;地VCC&#xff1a;5VLED&#xff1a…
阅读更多...
Dos和DDos攻击

Dos和DDos攻击

Dos Denialof Service拒绝服务,利用程序漏洞或一对一资源耗尽的&#xff0c;攻击有计算机网络宽带攻击和连通性攻击 分类&#xff1a; D网络&#xff1a;耗尽目标网络带宽资源 如&#xff1a;ICMP Flood, UDP Flood D协议&#xff1a;攻击协议漏洞发起的拒绝服务攻击 如…
阅读更多...
Leetcode—17.电话号码的字母组合【中等】

Leetcode—17.电话号码的字母组合【中等】

2023每日刷题&#xff08;九&#xff09; Leetcode—17.电话号码的字母组合 回溯法解题 实现代码 class Solution { public:vector<string> table {"","","abc","def","ghi","jkl","mno",&quo…
阅读更多...
leetCode 283 移动零

leetCode 283 移动零

//right指向待处理序列的首部 //left指向处理后序列的尾部class Solution {public void swap(int[] nums, int left, int right){int tmp nums[left];nums[left] nums[right];nums[right] tmp;}public void moveZeroes(int[] nums) {int n nums.length;int left 0;int rig…
阅读更多...
Oracle（6） Control File

Oracle（6） Control File

一、oracle控制文件介绍 1、ORACLE控制文件概念 Oracle控制文件是Oracle数据库的一个重要元素&#xff0c;用于记录数据库的结构信息和元数据。控制文件包含了数据库的物理结构信息、数据字典信息、表空间和数据文件的信息等。在Oracle数据库启动时&#xff0c;控制文件会被读…
阅读更多...
【c#】2022创建WEB API接口教程demo

【c#】2022创建WEB API接口教程demo

c#创建WEB API接口 创建WEB API接口结果图涉及到的技术设计流程创建WEB API接口 结果图 涉及到的技术 设计流程 1、创建WEB api项目，使用控制器和penapi勾选上，第一次创建项目时没有勾选，因为感觉没啥用。后面跑项目的时候，要把接口用swagger去直接生成的时候，还是需要…
阅读更多...
新的抓包神器，完全免费，支持多平台！

新的抓包神器，完全免费，支持多平台！

目前IOS端的抓包软件&#xff1a; HTTP Catcher&#xff08;网球&#xff09;&#xff0c;免费下载&#xff0c;完整版需要内购。 Storm Sniffer&#xff08;螃蟹&#xff09;&#xff0c;免费下载&#xff0c;完整版需要内购。 Thor&#xff08;锤子&#xff09;&#xff0…
阅读更多...
安全设备

安全设备

一.防火墙 5层应用层 防火墙 4层 udp tcp 协议 华为 厂商 华为 h3 1.区域划分 Dmz 停火区 Untrust 不安全区域 Trust 安全区域 防火墙 默认禁止所有 二.Waf Web 应用防火墙 放到web前面 产品 雷池 绿盟 软件 安…
阅读更多...
proxy解决跨域问题

proxy解决跨域问题

在使用vite工具创建的项目中解决跨域问题&#xff1a; 在vue.config.js中配置如下代码&#xff1a; const { defineConfig } require(‘vue/cli-service’) module.exports defineConfig({ transpileDependencies: true, server:{ proxy:{ ‘/path’:{ target:‘https://i.…
阅读更多...
21 行为型模式-职责链模式

21 行为型模式-职责链模式

1 职责链模式介绍 2 职责链模式原理 3 职责链模式实现 责任链模式的实现非常简单&#xff0c;每一个具体的处理类都会保存在它之后的下一个处理类。当处理完成后&#xff0c;就会调用设置好的下一个处理类&#xff0c;直到最后一个处理类不再设置下一个处理类&#xff0c;这时…
阅读更多...
美团悄悄上线社群团购“团买买”

美团悄悄上线社群团购“团买买”

我是卢松松&#xff0c;点点上面的头像&#xff0c;欢迎关注我哦&#xff01; 之前有社交电商&#xff1a;群买买、快团团、群团团、京喜团&#xff0c;而最近美团也上线了一款社群团购工具“团买买”的小程序。看来今年社群团购赛道非常热门啊&#xff0c;美团的“团买买”对…
阅读更多...
【JAVA学习笔记】44 - 注解，元注解

【JAVA学习笔记】44 - 注解，元注解

项目代码 一、注解的引入 1)注解(Annotation)也被称为元数据(Metadata),用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息。 2)和注释一样&#xff0c;注解不影响程序逻辑&#xff0c;但注解可以被编译或运行&#xff0c;相当于嵌入在代码中的补充信息。 3)在Ja…
阅读更多...
回归预测 | MATLAB实现BO-BiLSTM贝叶斯优化双向长短期神经网络多输入单输出回归预测

回归预测 | MATLAB实现BO-BiLSTM贝叶斯优化双向长短期神经网络多输入单输出回归预测

回归预测 | MATLAB实现BO-BiLSTM贝叶斯优化双向长短期神经网络多输入单输出回归预测 目录 回归预测 | MATLAB实现BO-BiLSTM贝叶斯优化双向长短期神经网络多输入单输出回归预测效果一览基本介绍模型搭建程序设计参考资料 效果一览 基本介绍 MATLAB实现BO-BiLSTM贝叶斯优化双向长…
阅读更多...
让MyEclispe中英文切换详解（附源码）

让MyEclispe中英文切换详解（附源码）

找到根目录 打开图中红框圈起来的myeclipse.ini文件&#xff08;或者选择使用记事本打开&#xff09; 在末尾添加 -Duser.languageen 这是设置成英文版 设置成中文则将 en 更改为 zh_cn就行了 -Duser.languageen-US -Duser.languagezh_cn
阅读更多...
VMware 20.4 桥接网络配置

VMware 20.4 桥接网络配置

1、新建一个虚拟网卡&#xff0c;选择桥接模式 2、配置具体系统的网络适配器&#xff0c;选择自定义&#xff0c;选择刚才新建的网卡 3、开启虚拟机&#xff0c;进入命令行&#xff0c;修改以下文件&#xff0c;文件名可能不一样 vi /etc/netplan/01-network-manager-all.yaml…
阅读更多...
深入浅出排序算法之希尔排序

深入浅出排序算法之希尔排序

目录 1. 原理 2. 代码实现 3. 性能分析 1. 原理 希尔排序法又称缩小增量法。希尔排序法的基本思想是&#xff1a;先选定一个整数&#xff0c;把待排序文件中所有记录分成个组&#xff0c;所有距离为的记录分在同一组内&#xff0c;并对每一组内的记录进行排序。然后&#xf…
阅读更多...
Linux环境基础开发工具的使用

Linux环境基础开发工具的使用

目录 一、Linux软件包管理器yum 1.1 Linux下载软件的方式 1.2 认识yum 1.3 查看软件包 1.4 安装软件 1.5 本地机器与云服务器文件互传 1.6 卸载软件 二、编辑器vim 2.1 vim下各模式的切换 2.2 命令模式下各命令汇总 2.3 底行模式各命令汇总 2.4 vim的简单配置 三…
阅读更多...
二十一、设计模式之解释器模式

二十一、设计模式之解释器模式

目录 二十一、设计模式之解释器模式能帮我们干什么&#xff1f;主要解决什么问题&#xff1f;优缺点优点缺点&#xff1a; 使用的场景角色和职责实现解释器 总结 二十一、设计模式之解释器模式 所属类型定义行为型允许你定义一个语言并解释该语言中的表达式 能帮我们干什么&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023