C++ 二分查找

合集下载

C++二分查找(折半查找)算法实例详解

C++二分查找(折半查找)算法实例详解

C++⼆分查找(折半查找)算法实例详解本⽂实例讲述了C++⼆分查找(折半查找)算法。

分享给⼤家供⼤家参考,具体如下:⼆分查找⼜称折半查找,优点是⽐较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插⼊删除困难。

因此,折半查找⽅法适⽤于不经常变动⽽查找频繁的有序列表。

⼆分查找思想⾸先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字⽐较,如果两者相等,则查找成功;否则利⽤中间位置记录将表分成前、后两个⼦表,如果中间位置记录的关键字⼤于查找关键字,则进⼀步查找前⼀⼦表,否则进⼀步查找后⼀⼦表。

重复以上过程,直到找到满⾜条件的记录,使查找成功,或直到⼦表不存在为⽌,此时查找不成功。

基本算法C语⾔实现代码:int binary_search(int arr[], int len, int elem){int low = 0;int high = len - 1;while (low <= high){int mid = (low + high) / 2;if (elem == arr[mid]){ //相等,返回midreturn mid;}else if (elem > arr[mid]){low = mid + 1; //元素⽐区间中间元素⼤,取区间中间元素的下⼀个元素作为新区间起始位置}else{high = mid - 1; //元素⽐区间中间元素⼩,取区间中间元素的上⼀个元素作为新区间结束位置}}return -1;}添加检测是否是已排好序数组的程序实例#include <iostream>using namespace std;int binary_search(int arr[], int len, int elem){int low = 0;int high = len - 1;while (low <= high){int mid = (low + high) / 2;if (elem == arr[mid]){return mid;}else if (elem > arr[mid]){low = mid + 1;}else{high = mid - 1;}}return -1;}//检测是否排好序int is_sorted(int arr[], int len){int sorted = 1;for (int i = 0; i < len - 1; i++){sorted = sorted && arr[i] <= arr[i + 1];}return sorted;}int main(){int arr[] = { 1, 3, 5, 7, 9, 11, 12, 15, 18, 23, 25, 26 }; int len = sizeof(arr) / sizeof(int);int pos;int sorted = is_sorted(arr, len);if (sorted){pos = binary_search(arr, len, 26);cout << "pos = " << pos << endl;}system("pause");}运⾏结果:pos = 11请按任意键继续. . .希望本⽂所述对⼤家C++程序设计有所帮助。

二分查找 c++函数

二分查找 c++函数

二分查找c++函数二分查找(Binary Search)是一种在有序数组中查找某一特定元素的搜索算法。

搜索过程从数组的中间元素开始,如果中间元素正好是要查找的元素,则搜索过程结束;如果某一特定元素大于或者小于中间元素,则在数组大于或小于中间元素的那一半中查找,而且跟开始一样从中间元素开始比较。

如果在某一步骤数组为空,则代表找不到。

这种搜索算法每一次比较都使搜索范围缩小一半。

以下是一个二分查找的C++ 函数示例:```cpp#include <iostream>#include <vector>using namespace std;int binarySearch(vector<int>& nums, int target) {int left = 0;int right = nums.size() - 1;while (left <= right) {int mid = left + (right - left) / 2;if (nums[mid] == target) {return mid;} else if (nums[mid] < target) {left = mid + 1;} else {right = mid - 1;}}return -1; // 如果没有找到目标值,返回-1}int main() {vector<int> nums = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};int target = 13;int result = binarySearch(nums, target);if (result != -1) {cout << "找到目标值" << target << ",索引为:" << result << endl;} else {cout << "未找到目标值" << target << "。

利用C语言编写二分查找程序

利用C语言编写二分查找程序
}
sprintf(num,"%d",y);
settextstyle(0,0,4);
drawmat(cha64K, 64,180, 10,GREEN);
drawmat(zhao64K,64,270, 10, GREEN);/*设置字符串FIND的X、Y坐标*/
outtextxy(370,30,num);
1
二分查找法,它是一种效率较高的查找方法,它充分利用了元素间的次序关系,它的基本思想是,将n个元素分成个数大致相同的两半,取a[n/2]与欲查找的x作比较,如果x=a[n/2]则找到x,算法终止。如果x<a[n/2],则我们只要在数组a的左半部继续搜索x。如果x>a[n/2],则我们只要在数组a的右半部继续搜索x。
{
Clr(300);
Clr(80); /*这里的三个Clr是为了把屏幕上的箭头和文字删了*/
Clr(230);
drawmat(cha64K, 64,180, 10, YELLOW);
drawmat(zhao64K, 64,270, 10, YELLOW);
settextstyle(0,0,4);
outtextxy(370,30,str1);
2.5
在指定位置显示一字符串
2.6
冒泡排序,是指计算机的一种排序方法,它的时间复杂度为O(n^2),虽然不及堆排序、快速排序的O(nlogn,底数为2),但是有两个优点:1.“编程复杂度”很低,很容易写出代码;2.具有稳定性,这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列,而堆排序、快速排序均不具有稳定性。不过,一路、二路归并排序、不平衡二叉树排序的速度均比冒泡排序快,且具有稳定性,但速度不及堆排序、快速排序。冒泡排序是经过n-1趟子排序完成的,第i趟子排序从第1个数至第n-i个数,若第i个数比后一个数大(则升序,小则降序)则交换两数。

二分查找 最长递增子序列 c语言

二分查找 最长递增子序列 c语言

二分查找最长递增子序列 c语言在学习计算机算法和数据结构时,我们常常会接触到一些经典的算法和问题,比如二分查找和最长递增子序列。

这些问题不仅在计算机科学领域有着重要的地位,而且在日常生活中也有着广泛的应用。

本文将从简单到深入地介绍二分查找和最长递增子序列,以便读者能更加全面地理解这两个经典的主题。

1. 二分查找二分查找是一种非常高效的搜索算法,它要求在有序的数据集合中查找特定的元素。

其基本思想是每次都将搜索区间对半分,然后确定目标值可能存在的那一半区间,如此重复,直到找到目标值或者确定目标值不存在。

二分查找的时间复杂度为O(log n),因此在大规模数据集中具有较高的效率。

在实际应用中,二分查找可以用于查找有序数组中的某个值,也可以用于在某个范围内寻找满足某个条件的元素。

它的应用领域涵盖了各个方面,比如在搜索算法、数据库索引以及游戏开发中都有着广泛的应用。

2. 最长递增子序列最长递增子序列是另一个经典的问题,它要求在一个给定的序列中找到一个最长的子序列,使得子序列中的元素依次递增。

求解最长递增子序列的问题可以帮助我们更好地理解动态规划算法,它也具有着广泛的应用。

在实际应用中,最长递增子序列可以帮助我们解决一些实际问题,比如在股票交易中寻找最佳买入卖出时机、在DNA序列分析中找出最长的相似序列等等。

在C语言中,我们可以通过一些经典的算法和数据结构来实现二分查找和最长递增子序列的求解。

比如在实现二分查找时,我们可以通过递归或者迭代的方式来实现,而在求解最长递增子序列时,我们可以利用动态规划的思想来解决,通过构建状态转移方程来求解最优解。

二分查找和最长递增子序列是计算机算法和数据结构中的经典问题,它们在实际应用中具有着广泛的价值。

通过对这两个问题的深入理解,我们不仅能够更好地掌握算法和数据结构,而且还能够应用于实际场景中,解决一些实际的问题。

希望读者通过本文的介绍,能够更加深入地了解二分查找和最长递增子序列,并能够在实际应用中灵活运用这些知识。

二分查找 c语言

二分查找 c语言

二分查找c语言摘要:1.二分查找算法简介2.二分查找算法在C语言中的实现3.示例代码及解析4.影响查找速度的因素5.总结与拓展正文:一、二分查找算法简介二分查找(Binary Search)是一种在有序数组中查找特定元素的搜索算法。

相较于顺序查找,二分查找能够在一定程度上提高搜索效率。

它通过将待查找元素与有序数组的中间元素进行比较,根据比较结果进行下一步查找,从而缩小查找范围。

这个过程持续到找到目标元素或查找范围为空。

二、二分查找算法在C语言中的实现以下是二分查找算法在C语言中的基本实现:```cvoid binary_search(int arr[], int len, int target) {int left = 0;int right = len - 1;while (left <= right) {int mid = left + (right - left) / 2;if (arr[mid] == target) {printf("找到目标元素,索引为:%d ", mid);return;} else if (arr[mid] < target) {left = mid + 1;} else {right = mid - 1;}}printf("未找到目标元素");}```三、示例代码及解析以下是一个使用上述二分查找算法的示例:```c#include <stdio.h>int main() {int arr[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};int len = sizeof(arr) / sizeof(arr[0]);int target = 11;binary_search(arr, len, target);return 0;}```编译并运行上述代码,输出结果为:```找到目标元素,索引为:5```四、影响查找速度的因素1.有序性:有序数组中的元素分布对二分查找的效率有很大影响。

二分法查找(C语言)

二分法查找(C语言)

⼆分法查找(C语⾔)⼆分法是⼀种⾼效的查找⽅法,其适⽤于已经排好序的数组基本思路从数组最中间的数开始查找判断,若不是需要查找的数字,则⽐较⼤⼩,之后则在从中间分开的两边中的⼀边从最中间开始查找判断,以此类推算法描述这⾥以升序数组为例,降序数组类似1. 记录数组最中间数的下标,将其中的数与要查找的数进⾏⽐较2. 若相等,停⽌查找,若⼤于要查找的数,则将数组下标上限换为较⼤半区的最⼩下标;若⼩于要查找的数,则将数组下标的下限换为较⼩半区的最⼤下标3. 重复第⼀步,直到数组下标不能调换,若查找到则停⽌查找,若未找到,则返回不存在的结果代码实现这⾥以升序数组为例,降序数组类似# include<stdio.h>int f(int, int [], int);int main(){int n;int arr[10]={1,2,3,4,5,6,7,8,9,10};scanf("%d", &n);//输⼊要查找的数int m=f(n, arr, 10-1);if(f(n, arr, 10-1)!=-1)printf("该数所在下标为:%d\n", m);elseprintf("该数不存在\n");}int f(int n, int a[], int h){int i, l, mid;l = 0;while(l<=h)//注意有等号,因为可能最后⼀次查找就只剩⼀个数,则这时上下限下标相等{mid=(l+h)/2;//计算中间下标if(a[mid]==n)//判断是否为⽬标数return mid;else if(a[mid]<n)l=mid+1;//如果中间数⼩于⽬标数,则将数组下限改为较⼤半区的下限elseh=mid-1;//如果中间数⼤于⽬标数,则将数组上限改为较⼩半区的上限}return -1;//返回-1表⽰⽬标数不存在}。

C语言基本算法

C语言基本算法C语言是一门用于编写计算机程序的高级编程语言,其特点是语法简洁、表达力强,广泛应用于科学计算、系统开发等领域。

在C语言中,算法是解决问题的关键,因此掌握基本算法对于学习和使用C语言非常重要。

本文将介绍C语言中一些简单级别的基本算法。

1.顺序查找算法顺序查找算法是一种简单的算法,用于在一个无序数组中查找目标元素。

它的基本思想是逐个比较数组中的元素,如果找到目标元素则返回其索引,否则返回-12.二分查找算法二分查找算法是一种高效的算法,用于在一个有序数组中查找目标元素。

它的基本思想是将数组分成两半,判断目标元素在哪一半中,然后再在该半中进行查找,如此循环直到找到目标元素或确定不存在。

3.冒泡排序算法冒泡排序算法是一种简单的排序算法,用于将一个无序数组按照升序或降序排列。

它的基本思想是从数组的第一个元素开始,两两比较相邻元素的大小并交换位置,按照此规则不断遍历数组直到排序完成。

4.选择排序算法选择排序算法是一种简单的排序算法,用于将一个无序数组按照升序或降序排列。

它的基本思想是从数组中选择最小(或最大)的元素并放置到第一个位置,然后在剩余的元素中选择最小(或最大)的元素并放置到第二个位置,如此循环直到排序完成。

5.插入排序算法插入排序算法是一种简单的排序算法,用于将一个无序数组按照升序或降序排列。

它的基本思想是将数组分为已排序部分和未排序部分,每次从未排序部分选取一个元素插入到已排序部分的适当位置,如此循环直到排序完成。

6.计数排序算法计数排序算法是一种简单的排序算法,适用于待排序的元素是有限个数的情况。

它的基本思想是统计数组中每个元素出现的次数,然后根据统计结果重新排列数组。

7.求和算法求和算法是一种简单的计算算法,用于计算一个数组中所有元素的和。

它的基本思想是遍历数组,累加每个元素的值得到最终结果。

8.求平均值算法求平均值算法是一种简单的计算算法,用于计算一个数组中所有元素的平均值。

c 语言 查找算法

c 语言查找算法一、线性查找线性查找也称为顺序查找,是最简单的一种查找算法。

它的原理是从数据集的第一个元素开始,逐个比较每个元素,直到找到目标值或者遍历完整个数据集。

由于它的查找过程是按顺序进行的,所以时间复杂度为O(n),其中n为数据集的大小。

二、二分查找二分查找是一种高效的查找算法,但要求数据集必须是有序的。

它的原理是先确定数据集的中间元素,然后将目标值与中间元素进行比较。

如果目标值等于中间元素,则查找成功;如果目标值小于中间元素,则在左半部分继续查找;如果目标值大于中间元素,则在右半部分继续查找。

通过每次将数据集缩小一半的方式,可以快速地找到目标值。

二分查找的时间复杂度为O(log n),其中n为数据集的大小。

三、哈希查找哈希查找是一种基于哈希表的查找算法,它通过将数据元素与其对应的哈希值进行关联,从而实现快速查找。

哈希表是一种以键值对形式存储数据的数据结构,通过哈希函数将键映射到对应的索引位置。

在查找时,只需要通过哈希函数计算目标值的哈希值,并在哈希表中查找对应的索引位置即可。

哈希查找的平均时间复杂度为O(1),但在最坏情况下可能达到O(n),其中n为数据集的大小。

四、二叉查找树二叉查找树(Binary Search Tree,BST)是一种二叉树的数据结构,它具有以下特点:对于任意节点,其左子树中的所有节点的值都小于该节点的值,右子树中的所有节点的值都大于该节点的值。

通过这种有序性,可以快速地进行查找操作。

在查找时,从根节点开始,根据目标值与当前节点的大小关系,递归地在左子树或右子树中查找。

二叉查找树的平均时间复杂度为O(log n),但在最坏情况下可能达到O(n),其中n为二叉查找树中节点的个数。

c语言提供了多种查找算法,可以根据不同的需求选择合适的算法。

线性查找适用于数据量较小且无序的情况;二分查找适用于数据量较大且有序的情况;哈希查找适用于需要快速定位的情况;二叉查找树适用于需要频繁插入和删除节点的情况。

c++ 二分查找函数

c++ 二分查找函数二分查找(Binary Search)是一种查找方法,可以在给定的有序数组中查找指定的数据,它具有高效的查找速度。

具体实现方式主要有两种:递归和非递归,只要了解一种便可以轻松实现另一种,本文主要介绍二分查找的递归实现,非递归的实现时类似的。

(1)定义文件定义查找的数组,将其声明为全局变量:int arr[10] = {1,2,3,4,5,6,7,8,9,10}; //全局变量(2)定义查找函数函数参数包括:查找数组arr,查找元素target,数组起始位置start和终止位置end。

int binary_search(int arr[], int target, int start, int end){//定义三个指针,指向数组的起始位置,中间位置,及终止位置int mid;if(start > end) //若start > end则说明查找失败return -1;mid = (start + end)/2; //计算中间位置if(arr[mid] > target) //若查找元素小于中间元素,则在数组起始位置到中间位置之前查找return binary_search(arr, target, start, mid - 1);else if(arr[mid] < target) //若查找元素大于中间元素,则在中间位置到数组终止位置之间查找return binary_search(arr, target, mid + 1, end);else //否则,说明查找元素等于中间元素,已查找到return mid;}(3)调用查找函数int ret = binary_search(arr, 4, 0, 9);if (ret == -1)cout << “Element Not Found” << endl;elsecout << “Element Found at index: ” << ret << endl;//输出 Element Found at index: 3(4)总结二分查找是一种高效的查找方法,可以帮助我们在有序数组中查找指定元素,它具有较高的查找速度。

二分查找法C语言立体7-6

二分查找法C语言立体7-6
二分查找法的算法步骤描述如下:设n个元素的数组a已升序排列,用left和right两个变量来表示查找的区间,即在a[left] 〜 a[right]区间去查找x。

初始状态为left = 0,right = n-1。

首先用要查找的x与查找区间的中间位置元素a[mid](mid = (left + right) / 2)比较,如果相等则找到;如果x < a[mid],由于数组是升序排列的,则只要在a[left] 〜 a[mid-1]区间继续查找;如果x > a[mid],则只要在a[mid+1] 〜 a[right]区间继续查找。

也就是根据与中间元素比较的情况产生了新的区间值left、right值,当出现left > right时,说明不存在值为x的元素。

输入格式:输入在第1行中给出一个正整数n(1≤n≤10)和一个整数x,第2行输入n个整数,其间以空格分隔。

题目保证数据不超过长整型整数的范围。

输出格式:在每一行中输出查找过程中对应步骤的中间结果,按照“[left,right][mid]”的格式输出。

提示:相邻数字、符号之间没有空格。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
void creat_hash();
void PrintOut();
};
//-------------------------------------------------------------
List::List(int n1,int p1)
{
int num=0;
length=n1; p=p1;
{
if(ht[i].key!=-1)
cout<<"\n i="<<i<<"学号:"<<ht[i].key<<"姓名:"<<ht[i].name
<<"英语成绩:"<<ht[i].english<<"高数成绩:"<<ht[i].math;
}
}
//-------------------------------------------------------------
const int MAXSIZE=100; //数组的容量
struct ElemType //学生的记录信息
{ KeyType key ; //学号
char name[10]; //姓名
int english; //成绩
int math; //成绩
} ;
class List
{ public:
ElemType *ht; //表数组
else
cout<<"\n i="<<i<<"学号:"<<ha.ht[i].key<<"姓名:"<<ha.ht[i].name
<<"英语成绩:"<<ha.ht[i].english<<"高数成绩:"<<ha.ht[i].math;
} break;
case 3:{ ha.PrintOut(); } break;
int main()
{ int p0,n0;
cout<<"\n请输入n值(n值应是记录总数的.3-1.5倍)"; cin>>n0;
cout<<"\n请输入P值(应是不大于n的大质数):"; cin>>p0;
List ha(n0,p0); ElemType a;
int k; //char ch;
do { cout<<"\n\n\n";
cin>>K;
while(K!=-1&&num<length)
{
cout<<"\n请输入学生的姓名,英语成绩和高数成绩:";
cin>>na>>en>>ma;
ht[i].key=K;
strcpy(ht[i].name,na); //用串拷贝赋值
ht[i].english=en;
ht[i].math=ma;
while(pos<top)
{
int mid=(pos+top)/2;
if(ht[mid].key<s)
pos=mid+1;
else
top=mid;
}
if(top<pos)
return 0;
else
return pos;
}பைடு நூலகம்
void List::PrintOut()
{ int i;
for (i=0;i<length; i++)
switch(k)
{ case 1:{ ha.creat_hash();} break;
case 2:{ cout<<"\n请输入待查找的学生学号:"; cin>>a.key;
int i=ha.search(a.key);
if(i==-1)
cout<<"\n此学生"<<a.key<<"不存在!" ;
//插入学生记录K
cout<<"\n插入成功!" ; num++;
cout<<"\n请逐一输入各个学号(关键字值)(-1结束):"; cin>>K;
i++;
}
}
//查询某关键字的记录
int List::search( KeyType k )
{ KeyType s=k;int pos=0;int top=length;
int length; //表大小(长度)
KeyType p; //除留余数法的大质数
public:
List( int n1,int p1);
~List(){delete []ht; length=0;};
//int find( KeyType k );
int search( KeyType k );
实验六 二分查找
一.实验目的
1.学生在实习中体会各种查找算法的基本思想、适用场合,理解开发高效算法的可能性和寻找、构造高效算法的方法。
2.掌握运用查找解决一些实际应用问题。
二.程序
#include <iostream>
using namespace std;
typedef int KeyType; //关键字的类型
cout<<"\n 1.建立哈希表";
cout<<"\n 2.在哈希表中查找某位学生";
cout<<"\n 3.输出哈希表";
cout<<"\n 4.结束";
cout<<"\n=======================================";
cout<<"\n输入您的选择(1,2,3,4):"; cin>>k;
}
}while(k>=1&&k<=3);
getchar(); return 0;
}
三.实验结果
四.总结
1.二分查找必须采用顺序存储结构;
2.二分查找必须按关键字大小有序排列;
3.二分查找其优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难,因此,折半查找方法适用于不经常变动而查找频繁的有序列表。
ht=new ElemType[length];
for(int i=0;i<length;i++)ht[i].key=-1;
}
void List::creat_hash()
{ int i=0,K,en,ma;char na[10];int num=0;
cout<<"\n请逐一输入各个学号(关键字值)(-1结束):";
相关文档
最新文档