编程题实训-查找

最新推荐文章于 2024-04-18 13:53:46 发布
最新推荐文章于 2024-04-18 13:53:46 发布
阅读量2.8k 收藏 40
点赞数 29
分类专栏： 数据结构--头歌 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a61233/article/details/135376075
版权

第1关：基于递归的折半查找

任务描述

请编写一个递归的折半查找算法，查找给定有序数组中的某一元素。

编程要求

输入

多组数据，每组数据有三行。第一行为数组长度n，第二行为n个递增排列的数字，第三行为需要查找的数字k。当n=0时输入结束。

输出

每组数据输出一行，如果可以找到数字，则输出“YES”，否则输出“NO”。

#include<iostream>
using namespace std;
int BinSearch_Cur(int a[],int key,int low,int high)
{//基于递归的折半查找
    /************begin***************/
    if(low <= high)
    {
        int mid = low + high >> 1;
        if(a[mid] == key) return mid + 1;
        else if(a[mid] > key) return BinSearch_Cur(a,key,low,mid - 1);
        else return BinSearch_Cur(a,key,mid + 1,high);
    }
	
    return 0;
    /************end***************/
}
int main()
{
    int n;//数组长度n
    while(cin>>n)
    {
        if(n==0) break;
        int a[100],k;
        for(int i=0;i<n;i++)
            cin>>a[i];			//输入n个递增排列的数字
        cin>>k;				//输入需要查找的数字k
        if(BinSearch_Cur(a,k,0,n-1))
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    return 0;
}

第2关：二叉排序树的判定 

任务描述

假设二叉树每个结点的元素均为一个单字符，根据给定的字符序列按照先序遍历的顺序递归创建该树的二叉链表，然后判断该二叉树是否为二叉排序树。

编程要求

输入

多组数据，每组数据有一行。每行为一个二叉树对应的前序序列（其中‘#’表示空树）。当序列为“#”时，输入结束。

输出

每组数据输出1行，若此二叉树为二叉排序树则输出“YES”，否则输出“NO”。

#include<iostream>
#include <string.h>
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//先序建立二叉树
	if(S[i]=='#') T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
BiTree pre=NULL;   //前驱指针
void JudgeBST(BiTree T,int &flag)
{//判断二叉树T是否为二叉排序树，flag初值为1
    /**************begin************/
    if(T!=NULL&&flag)
    {
        JudgeBST(T->lchild,flag);//中序遍历左子树
        if(pre==NULL) pre=T;     //中序遍历的第一个结点不必判断
        else if(pre->data<T->data) pre=T;   //前驱指针指向当前结点
        else flag =0;                //不是二叉排序树
        JudgeBST(T->rchild,flag);   //中序遍历右子树
    }
    /**************end************/
}
int main()
{
	char S[100];
	while(cin>>S)
	{
		if(strcmp(S,"#")==0) break;
		int i=-1;
		int flag=1;
	  	BiTree T;
		CreateBiTree(T,S,++i);
		JudgeBST(T,flag);
		if(flag)
			cout<<"YES"<<endl;
		else
			cout<<"NO"<<endl;
	}
	return 0;
}

 第3关：二叉排序树的限定条件下的数据输出

任务描述

已知二叉排序树采用二叉链表存储结构，根结点的指针为T,链结点的结构为(lchild,data,rchild),其中lchild、rchild分别指向该结点左，右孩子的指针，data域存放结点数据。试编写算法，从小到大输出二叉排序树中所有数值大于等于x的结点的数据。要求先找到第一个满足条件的结点后，再依次输出其他满足条件的结点。

编程要求

输入

多组数据，每组三行。第一行为二叉排序树的结点数n。第二行为空格分隔的n个数字，对应二叉排序树中的n个结点。第三行为一个数字x。n=0时输入结束。

输出

每组数据输出一行。从小到大输出大于等于x的结点数据。每个数据用空格分隔。

#include<iostream>
using namespace std;
typedef struct BSTNode
{//二叉排序树的二叉链表存储表示
	int data;
	struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;
int sum;设一个全局变量sum,为了判断该数据是否为输出的最后一个数
void InsertBST(BSTree &T,int e)
{//当二叉排序树T中不存在关键字等于e的数据元素时，则插入该元素
    /**************begin************/
	if(!T)
    {                            //找到插入位置，递归结束
        BSTree S=new BSTNode;    //生产新结点*S
        S->data=e;               //新结点*S的数据域置为e
        S->lchild=NULL;          //把新结点作为叶子结点
        S->rchild=NULL;
        T=S;                     //把新结点*S链接到已找到的插入位置
    }
    else
    {
        if(e<T->data)
            InsertBST(T->lchild,e);      //将*S插入左子树
        else
            InsertBST(T->rchild,e);      //将*S插入右子树
    }
    /**************end************/
}
BSTree CreateBSTree(int n)
{//构建二叉排序树
    BSTree T=NULL;
    int e;
    for(int i=0;i<n;i++)
    {
        cin>>e;
        InsertBST(T,e);
    }
    return T;
}
void InOrderTraverse(BSTree T,int x)
{//中序遍历二叉树T的递归算法
    if(T==NULL) return;   //空树
    else
    {
        InOrderTraverse(T->lchild,x);//递归遍历左子树
        sum--;         //每次遍历时sum减1
        if(T->data>=x)
        {                               //输出二叉排序树中所有数值大于等于x的结点的数据
            cout<<T->data;              //先输出数据
            if(sum==0) cout<<endl;    //如果是最后一个元素，换行
            else cout<<" ";           //非末位元素，输出空格
        }
        InOrderTraverse(T->rchild,x);//递归遍历右子树
    }
}
int main()
{
	int n,x;        //二叉排序树的结点数n，数字x
	while(cin>>n)
	{
		if(n==0) break;
		BSTree T=NULL;
		T=CreateBSTree(n);
		cin>>x;          //输入数字x
		sum=n;          //结点数n赋给sum
		InOrderTraverse(T,x);
	}
	return 0;
}

第4关：基于非递归的二叉排序树的结点的查找和插入

任务描述

已知二叉树T的结点形式为(llink,data,count,rlink)，在树中查找值为x的结点，若找到，则计数（count）加1；否则，作为一个新结点插入树中，插入后仍为二叉排序树。请写出其非递归算法。

编程要求

输入

多组数据，每组数据3行。第一行为二叉排序树的结点数n，第二行为空格分隔的n个数字，对应二叉排序树中的n个结点，第三行为查找的值x。n=0时输入结束。

输出

每组数据输出两行。第一行为二叉排序树的中序序列（空格分隔），第二行为其对应的计数count。

#include<iostream>
using namespace std;
typedef struct BiTNode
{
	int data;
	int cnt;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
int sum=0;        //全局变量sum表示排序树当前结点的个数,也为了判断数据是否为输出的最后一个数
void SearchBST(BiTree &T,int x)
{//基于非递归的二叉排序树的结点的查找和插入
    /**************begin************/
    BiTree s=new BiTNode;                    //生成一个数据域为x的新结点s
    s->data=x;
    s->cnt=0;
    s->lchild=NULL;
    s->rchild=NULL;
    if(!T)                                    //如果该树为空，则将待插入结点*s作为根结点插入到空树中
    {
        T=s;
        sum++;
        return;
    }
    BiTree q=T,f=NULL;
    while(q)                                //从根结点开始比较，直到结点为空
    {
        if(q->data==x)                        //如果找到该值则计数加1
        {
            q->cnt++;
            return;                            //函数结束
        }
        f=q;                                //如果没有找到，需要用f保存q结点
                                            //因为q指向的最后一个非空结点将会是x的父结点
        if(q->data>x)                        //x小于当前结点值，使指针指向左子树
            q=q->lchild;
        else                                 //x大于当前结点值，使指针指向右子树
            q=q->rchild;
    }
    if(f->data>x)                            //如果找不到，就将新结点插入树中
    {
        sum++;
        f->lchild=s;
    }
    else
    {
        sum++;
        f->rchild=s;
    }
    /**************end************/
}
void InOrderTraverse(BiTree T)
{//中序遍历输出二叉树T结点
    if(T==NULL) return;
    else
    {
        InOrderTraverse(T->lchild);
        sum--;
        cout<<T->data;
        if(sum==0)
            cout<<endl;
        else
            cout<<" ";
        InOrderTraverse(T->rchild);
    }
}
void Print_Count(BiTree T,int x)
{//中序遍历输出二叉树T计数
    if(T==NULL) return;
    else
    {
        Print_Count(T->lchild,x);
        sum--;
        cout<<T->cnt;
        if(sum==0)
            cout<<endl;
        else
            cout<<" ";
        Print_Count(T->rchild,x);
    }
}
int main()
{
	int n;
	while(cin>>n)
	{
		if(n==0) break;
		int e;        //变量e用于接收输入数据
	  	BiTree T=NULL;
		for(int i=0;i<n;i++)  //基于非递归的二叉排序树的结点的查找和插入
		{
			cin>>e;
			SearchBST(T,e);
		}
		int x;           //查找值为x
		cin>>x;
		SearchBST(T,x);
		if(sum==n+1) n++; //没找到时，x作为一个新结点插入树中，此时排序树的结点数加1
		sum=n;
		InOrderTraverse(T);//中序遍历输出二叉树T结点
		sum=n;
		Print_Count(T,x);   //中序遍历输出二叉树T计数
	}
	return 0;
}

第5关：平衡二叉树的高度的计算

任务描述

假设一棵平衡二叉树的每个结点都标明了平衡因子b，设计一个算法，求平衡二叉树的高度。

编程要求

输入

多组数据，每组数据一行，为平衡二叉树的先序序列。输入的数字为该节点的平衡因子。当序列为“#”时，输入结束。

输出

每组数据输出一行，为平衡二叉树的高度。

#include<iostream>
#include <string.h>
using namespace std;
typedef struct BiTNode
{
	char data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
void CreateBiTree(BiTree &T,char S[],int &i)
{//先序建立二叉树
	if(S[i]=='#')
		T=NULL;
	else
	{
		T=new BiTNode;
		T->data=S[i];
		CreateBiTree(T->lchild,S,++i);
		CreateBiTree(T->rchild,S,++i);
	}
}
int Height(BiTree T)
{//求平衡二叉树T的高度
    /**************begin************/
    int level = 0;
    BiTree p = T;
	while(p)
	{
		level++ ; 
		if(p -> data < 0) p = p -> rchild;
		else p = p -> lchild;
	}
	return level;
    /**************end************/
}
int main()
{
	char S[100];//如果平衡因子b=-1，会被字符数组割裂成'-'和'1'，故本题输入样例不包含b=-1
	while(cin>>S)
	{
		if(strcmp(S,"#")==0) break;
		int i=-1;
	  	BiTree T;
		CreateBiTree(T,S,++i);
		cout<<Height(T)<<endl;
	}
	return 0;
}

第6关：基于链地址法的散列表的插入

任务描述

请写出在散列表中插入关键字为k的一个记录的算法，设散列函数为H,H(key)=key%13，解决冲突的方法为链地址法。

编程要求

输入

多组数据，每组三行，第一行为待输入的关键字的个数n，第二行为对应的n个关键字，第三行为需要插入的关键字k。当n=0时输入结束。

输出

每组数据输出用链地址法处理冲突的散列表。

#include<iostream>
using namespace std;
typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode,*LinkList;
LinkList H[13];    //链地址法，13个单链表
void Hash(int e)
{//基于链地址法的散列表的插入
    /**************begin************/
	int index=e%13;       //计算散列地址
    LinkList p=H[index];   //工作指针p指向链表的头结点
    while(p->next)         //移至表尾
        p=p->next;
    LinkList q=new LNode;    //生成新结点*q
    q->data=e;               //将新结点*q的数据域置为e
    q->next=NULL;            //将新结点*q插入在尾结点*p之后
    p->next=q;
    /**************end************/
}
void Input(int n)
{//输入数据
	for(int i=0;i<13;i++)     //建立13个带有头结点的单链表
	{
		H[i]=new LNode;
		H[i]->next=NULL;
	}
	while(n--)          //输入n个关键字,构造散列表
	{
		int e;
		cin>>e;
		Hash(e);
	}
}
void Output()
{//输出数据
	for(int i=0;i<13;i++)
	{
		cout<<i;                 //输出散列地址
		LinkList p=H[i]->next;   //p初始化为链表的首元结点
		while(p)
		{
			cout<<" "<<p->data;
			p=p->next;
		}
		cout<<endl;
	}
}
int main()
{
	int n;
	while(cin>>n)
	{
		if(n==0) break;
		Input(n);     //输入数据
		int k;      //需要插入的关键字k
		cin>>k;
		Hash(k);
		Output();  //输出数据
	}
	return 0;
}

第7关：基于链地址法的散列表的删除 

任务描述

请写出在散列表中删除关键字为k的一个记录的算法，设散列函数为H，H(key)=key%13，解决冲突的方法为链地址法。

编程要求

输入

多组数据，每组三行，第一行为待输入的关键字的个数n，第二行为对应的n个关键字，第三行为需要删除的关键字k。当n=0时输入结束。

输出

每组数据输出用链地址法处理冲突的散列表。

#include<iostream>
using namespace std;
typedef struct LNode
{
	int data;
	struct LNode *next;
}LNode,*LinkList;
LinkList H[13];   //链地址法，13个单链表
void Hash(int e)
{//基于链地址法的散列表的插入
	int index=e%13;       //计算散列地址
	LinkList p=H[index];   //工作指针p指向链表的头结点
	while(p->next)         //移至表尾
		p=p->next;
	LinkList q=new LNode;    //生成新结点*q
	q->data=e;               //将新结点*q的数据域置为e
	q->next=NULL;            //将新结点*q插入在尾结点*p之后
	p->next=q;
}
void Input(int n)
{//输入数据
	for(int i=0;i<13;i++)     //建立13个带有头结点的单链表
	{
		H[i]=new LNode;
		H[i]->next=NULL;
	}
	while(n--)          //输入n个关键字,构造散列表
	{
		int e;
		cin>>e;
		Hash(e);
	}
}
void Delete(int e)
{//基于链地址法的散列表的删除
    /**************begin************/
	int index=e%13;      //计算散列地址
    LinkList p=H[index];   //工作指针p指向链表的头结点
    while(p->next)         //p指向待删除结点的前一个结点，找不到待删除结点时，p最终指向表尾结点
    {
        if(p->next->data==e)
            break;
        p=p->next;
    }
    if(p->next!=NULL)    //p没指向表尾结点时
    {
        LinkList q=p->next;
        p->next=q->next;
        delete q;
    }
    /**************end************/
}
void Output()
{//输出数据
	for(int i=0;i<13;i++)
	{
		cout<<i;                 //输出散列地址
		LinkList p=H[i]->next;   //p初始化为链表的首元结点
		while(p)
		{
			cout<<" "<<p->data;
			p=p->next;
		}
		cout<<endl;
	}
}
int main()
{
	int n;
	while(cin>>n)
	{
		if(n==0) break;
		Input(n);     //输入数据
		int k;
		cin>>k;
		Delete(k);  //需要删除的关键字k
		Output();  //输出数据
	}
	return 0;
}

第8关：基于快排思想的查找

任务描述

借助于快速排序的算法思想，在一组无序的记录中查找给定关键字值等于key的记录。设此组记录存放于数组r[l..n]中。若查找成功，则输出该记录在r数组中的位置及其值，否则显示“not find”信息。

编程要求

输入

多组数据，每组数据三行。第一行为序列的长度n，第二行为序列的n个元素（元素之间用空格分隔，元素都为正整数），第三行为要查找的key值。当n等于0时，输入结束。

输出

每组数据输出一行。如果查找成功，输出key在数组中的位置（1到n）和key的值，两个数字之间用空格隔开。如果查找失败，输出“not find”。

#include<iostream>
using namespace std;
int Search(int r[],int low,int high,int key)
{//基于快排思想的查找
    /**************begin************/
    while(low<high)
    {
        if(r[low]>key&&r[high]<key)      //如果关键字小于数组下界的值且大于数组上界的值，更新指针high和low
        {
            high--;
            low++;
        }
        while(low<=high&&r[high]>key) high--;   //从右侧开始找到第一个不大于关键字的记录，其位置为high
        if(r[high]==key) return high;           //查找成功返回其位置
        while(low<=high&&r[low]<key) low++;     //从左侧开始找到第一个不小于关键字的记录，其位置为low
        if(r[low]==key) return low;             //查找成功返回其位置
    }
    cout<<"not find"<<endl;     //查找失败
    return 0;
    /**************end************/
}
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        int r[n],key;
        for(int i=0;i<n;i++)   //输入数据
            cin>>r[i];
        cin>>key;       //输入要查找的key值
        if(Search(r,0,n-1,key))    //如果查找成功
			cout<<Search(r,0,n-1,key)+1<<" "<<key<<endl;  //输出key在数组中的位置（1到n）和key的值
    }
}

第9关：查找链表倒数第k个结点

任务描述

已知一个带有表头结点的单链表，结点结构为（data，link），假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点（k为正整数）。若查找成功，算法输出该结点的data域的值，并返回1；否则，只返回0。

编程要求

输入

多组数据，每组数据两行。第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔，元素都为正整数）。当n等于0时，输入结束。第三行为要查询链表的倒数索引k。

输出

输出数据一行。若查询到值则输出值，否则不输出。

#include <iostream>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
using namespace std;
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;
void CreateList_R(LinkList &L,int n)
{//后插法创建单链表
    L=new LNode;
    L->next=NULL;
    LinkList r=L;
    for(int i=0;i<n;i++)
    {
        LinkList p=new LNode;
        cin>>p->data;
        p->next=NULL;
        r->next=p;
        r=p;
    }
}
int Search_k(LinkList L,int a[],int k)
{//查找链表倒数第k个结点
//通过一趟遍历把该链表的结点都存入到一个辅助数组中，再通过数组下标可直接获取倒数第k个结点，但这样会需要额外的存储空间，因此空间复杂度为O(n)
    /**************begin************/
    LinkList p=L->next;          //初始化指针p指向首元结点
    int length=0;               //length记录链表长度，也是数组元素的个数
    while(p!=NULL)
    {
        a[length++]=p->data;
        p=p->next;
    }
    if(k>length) return ERROR;
    else cout<<a[length-k]<<endl;
    return OK;
    /**************end************/
}
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==0) break;
        LinkList L;
        CreateList_R(L,n);
        int k,a[MAXSIZE];
        cin>>k;
        Search_k(L,a,k);
    }
    return 0;
}

 

 

JAVA郑
关注
  • 29
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
折半查找的递归算法
11-02
折半查找的递归算法，非常实用，可以实现的C语言程序
c语言数组实训题，数组编程题
01-18
C语言数组实训题、数组编程题 知识点1: 数组的基本概念 在C语言中，数组是一种重要的数据结构，用于存储一组相同类型的数据。数组可以是一维的，也可以是多维的。数组的每个元素都有一个唯一的索引，称为数组下标...
用递归的方法实现折半查找
weixin_30345577的博客
10-24 345
#include<stdio.h>int BinarySearch(int *a,int x,int left,int right);int main(void){ //注：数组必须是有序的 //int a[]={1,2,3,4,5,6,7,8,9,10,12,14,15,18,20}; int a[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,...
递归编程实验
最新发布
ycysbsbsb的博客
04-18 1369
5.全排列递归：总共有n个数字的位置，第u个位置， 用1~n的数字填充且不能重复，用w数组记录数字是否使用过，用path数组记录当前数字，由于填充的位置下标为0~n-1,所以当到达第n个位置时，输出path数组中存储的数字。将求解n位Gray码的问题划分成求解n-1位Gray码的问题，n位Gray码的前半部分最高位置0，其余位不变，n位Gray码的后半部分最高位置1，其余位由n-1位Gray码翻转而来。在这个尾递归函数中，递归调用位于函数的最后一步，并且使用新的参数直接取代了之前的参数。
递归算法 折半查找
waoshiwerr的博客
07-10 5696
（一）递归算法 折半查找 BinarySearch(函数命名了解大驼峰命名 法) 目的 节省时间在一组有序数列中查找一个数。通过查找中间值进行不断比较。 代码如下： int BinarySEarch(int*a,/*数组*/，intx/*想要传入的数组*/，int left /*最左边的数字*/，int right) { int middle； if（left<=right）/*判断数组的左边的数字和右边的数字*/ { middle = （left<=right） { middle =
折半查找（递归做法）
weixin_47511190的博客
11-30 3575
#include<bits/stdc++.h> using namespace std; int BinFind(vector<int>v,int x,int low,int high) { if(high<low) // 尾下标小于头下标，说明没找到，返回-1 return -1; int mid=(low+high)/2; // 取中点 if(v[mid]==x) // 如果找到，返回所在下标 return mid; else if
每日一题Day74
ZLambert的博客
08-24 553
基于递归的折半查找 描述 请编写一个递归的折半查找算法，查找给定有序数组中的某一元素。 输入 多组数据，每组数据有三行。第一行为数组长度n，第二行为n个递增排列的数字，第三行为需要查找的数字k。当n=0时输入结束。 输出 每组数据输出一行，如果可以找到数字，则输出“YES”，否则输出“NO”。 样例输入1  5 1 4 6 7 8 6 6 1 2 5 7 9 100 8 0 ...
递归和分治思想（折半查找）
unityFengYue的博客
04-30 665
1、递归：（归去来兮） 递归效率较低，如果明确知道迭代次数，则能用迭代最好用迭代，递归是函数自己调用自身，每次调用都需要入栈等操作。但是递归操作要比迭代简单和清楚。 递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。 使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
递归法实现折半查找（二分查找）
weixin_46967285的博客
03-13 3262
题目 递归法实现折半查找（二分查找） 分析 设立low代表数组最小端的数组下标，high代表数组最大端的数组下标，mid代表数组中间值的数组下标 查询数字number与mid进行比较，有四种情况： 1、number=数组[mid],则找到number位置为mid 2、number<数组[mid],则将数组一分为二，在小数值一端继续查找，此时low依然是low,而high变为原来的mid-1 3、number>数组[mid],则将数组一分为二，在大数值一端继续查找，此时high依然是high,而l
折半查找(C++实现)
Who_Am_I
09-07 8852
折半查找 定义： 计算机科学中，折半搜索（英语：half-interval search），也称二分搜索（英语：binary search）、对数搜索（英语：logarithmic search），是一种在有序数组中查找某一特定元素的搜索算法。 搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩
递归的折半查找算法
k_ys的博客
02-19 6057
问题一：递归的折半查找算法 注意：折半查找有一个条件，数据必须是有顺序性的，不然折半查找毫无意义； 原问题：有一数组A[10],里面存放了十个整数，顺序递增。任意输入一个n（位于数组里外均可），如果n数与数组，则显示n位于数组中的位置，如果n不属于数组，则显示错误；要求用递归的方法实现折半查找； 扩展：适用于输入所有顺序递增数据实现折半查找。 实验代码如下： #include &amp;lt;stdio....
顺序表实现的图书管理
06-19
定义图书类型结构，定义顺序表；完成功能：初始化构建空表、插入新记录到第i个位置、删除表中第i个记录、按图书名称进行查找、按作者进行查找、按价格区间进行查找。
新版Linux Shell编程实训（全）20170518.docx
06-02
任务10.2 Shell案例：查找最大文件 172 练习（每题50分，共计100分） 174 项目十一 Shell文本处理命令 175 [学习目标] 175 任务11.1 学习和使用grep 176 任务11.2 学习和使用sed 179 任务11.3 学习和使用cut 183 ...
头歌数据结构单链表的基本操作
05-18
第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 顺序表是线性表的顺序存储结构的别称，特点是以“存储位置相邻”表示两个...
linux网络操作系统和实训课后习题答案解析.docx
09-13
Linux 网络操作系统和实训课后习题答案解析 本资源摘要信息涵盖了 Linux 操作系统的基础知识，包括 Linux 的历史、特点、安装、实训等方面。 一、 Linux 的历史和特点 Linux 操作系统是由芬兰学生 Linus Torvalds...
递归实现折半查找算法（C语言）
热门推荐
Mr.yang的博客
05-01 3万+
递归实现折半查找 折半查找顾明思议，就是一半一半的查找，不过前提必须是一个有序的序列，这里我才用了整型数组。 函数必须传入4个参数 int binsearch(int a[], int key, int low, int high) a[] :要进行查找的数组 key:要进行查找的数值 low：最小下标 high：最大下标 核心思想： 当key值小于数组的中间位置的数值时，就在中间向左边的小数组...
编程题实训-实验1-基于线性表的图书信息管理
04-04
题目描述 本题要求实现一个基于线性表的图书信息管理系统，包括添加图书、删除图书、查询图书、修改图书信息等基本功能。 输入描述 输入包括若干行，每行为一条指令，指令格式如下： 1.添加图书：add bookname authorname price 2.删除图书：del bookname 3.查询图书：query bookname 4.修改图书信息：modify bookname authorname price 其中bookname为图书名称，authorname为作者名称，price为图书价格，均为字符串。 输出描述 对于每个查询指令，输出查询到的图书信息，格式为： bookname authorname price 如果查询不到，输出“查无此书”。 对于其他指令，无需输出。 示例 输入： add "C++ Primer" "Lippman" 89.00 add "Data Structure" "Weiss" 59.00 query "C++ Primer" modify "C++ Primer" "Lippman" 99.00 del "Data Structure" query "Data Structure" 输出： C++ Primer Lippman 89.00 查无此书

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值