精华内容
下载资源
问答
  • C语言数组元素的查找
    千次阅读
    2019-04-14 17:41:57

    顺序查找

    顺序査找也叫线性查找,是一种简单的査找算法,其实现方法是从序列的起始元素开始,逐个将序列中的元素与所要查找的元素进行比较,如果序列中有元素与所要查找的元素相等,那么査找成功,如果査找到序列的最后一个元素都不存在一个元素与所要査找的元素值相等,那么表明査找失败。

    /**
    * 线性查找数组元素
    * @param int a[] 要查找元素的数组
    * @param int n 数组元素的个数
    * @param int des 要查找的数
    * @return int 1: 查找成功;0: 查找失败
    **/
    int ordersearch(int a[], int n, int des){
        int i;
        for(i=0; i<n; i++)
            if(des==a[i])return 1;
        return 0;
    }

    二分查找

    二分査找也称折半査找,其优点是查找速度快,缺点是要求所要査找的数据必须是有序序列。该算法的基本思想是将所要査找的序列的中间位置的数据与所要査找的元素进行比较,如果相等,则表示査找成功,否则将以该位置为基准将所要査找的序列分为左右两部分。接下来根据所要査找序列的升降序规律及中间元素与所查找元素的大小关系,来选择所要査找元素可能存在的那部分序列,对其采用同样的方法进行査找,直至能够确定所要查找的元素是否存在,具体的使用方法可通过下面的代码具体了解。

    /**
    * 二分查找数组元素
    * @param int a[] 要查找元素的数组
    * @param int n 数组元素的个数
    * @param int key 要查找的数
    * @return int 1: 查找成功;0: 查找失败
    **/
    
    int binarySearch(int a[], int n, int key){
        int low = 0;
        int high = n - 1;
        while(low<= high){
            int mid = (low + high)/2;
            int midVal = a[mid];
            if(midVal<key) low = mid + 1;
            else if(midVal>key) high = mid - 1;
            else return 1;
        }
        return 0;
    }

     

    更多相关内容
  • C语言 数组部分知识、实现数组查找和排序

    数组的定义和初始化

       数组在定义是要注意:
      1.数组同变量一样,需要先定义后才能使用
      2.定义数组时,[ ]内不能用变量表示元素个数(在引用时可以,如for内初始化数组),也不能用实数表示元素个数

      一维数组初始化要注意,{ }只能在数组定义的同时使用。数组不初始化,里面的数据将会是随机数
      正确示范:

    	/*正确示范1*/
    	int a[5];
    	a[0]=0;
    	a[1]=1;
    	a[2]=2;
    	a[3]=3;
    	a[4]=4;
    
    	/*正确示范2*/
    	int a[5]={0, 1, 2, 3, 4};	/*也可以写成下面这样*/
    	int a[]={0, 1, 2, 3, 4};	/*只有在给数组全部元素赋初值时可以省略[ ]内的数组元素个数*/
    
    	/*正确示范3*/
    	int a[5]={};	/*数组a全部元素被初始化为0*/
    	int a[5]={0};	/*数组a全部元素被初始化为0*/
    

      错误示范:

    	/*错误示范1*/
    	int a[5]=[0, 1, 2, 3, 4];	/*赋初值应用{ }括起来*/
    	int a[5]={0, 1, 2, 3, 4};	/*应写成这样*/
    
    	/*错误示范2*/
    	int a[5];
    	a={0, 1, 2, 3, 4};	/*{ }只能在定义的同时使用*/
    
    	/*错误示范3*/
    	int a[5]=1;		/*赋初值应用{ }括起来*/
    	int a[5]={1};	/*应该写成这样,这样写只有a[0]值为1,a[1]-a[4]全为0*/
    

      
      

    查找

    1.顺序查找

      查找数组a有没有值为25的元素

    #include <stdio.h>
    main()
    {
    	int a[10]={1, 0, 24, 30, 5, 9, 30, 25, 55, 49};
    	int i, j;
    	for(i=0; i<10; i++)
    		if(a[i]==25)	/*注意不要写成=,否则就是赋值了*/
    			break;
    	if(i>9)
    		printf("没找到25");
    	else
    		printf("25的下标为%d", i);	
    
    	return 0;
    }
    

      
      

    2.二分查找

      二分查找又称对分查找、折半查找。要使用二分查找有一个前提:数组中的数据必须由大到小或者小到大的有序顺序排列。

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
        /*值为25的元素下标为10,即第11个*/
        int array[]={0, 1, 3, 6, 9, 14, 18, 22, 23, 24, 25, 28, 30, 33, 38, 44, 50};
        int low=0,high=sizeof(array)/sizeof(array[0]);	/*high初始值为数组长度*/
        int mid=0;
        int target=25;
    
        while(low<=high)
        {
    		mid=(low+high)/2;
    		if(array[mid]<target)
    			low=mid+1;		/*为什么不是low=mid,因为上一行已经排除mid,进一步缩小范围,更容易找到目标*/
    		else if(array[mid]>target)
    			high=mid-1;
    		else
    			break;		/*在找到array[mid]==target或者low>high时退出循环*/
    	}
    	if(low>high)
    		printf("没找到25");
    	else
    		printf("找到了,下标是%d", mid);
    		
        return 0;
    }
    
    

      
      

    排序方法

    1.(简单)选择排序法

      找到元素最小值/最大值,把它放在数组头,接着找剩下元素里的最值,把它放在上次找到的最值后面,直到最后一个元素。
      方法一:始终保持a[i]是一个更小值,直到它为剩下元素里值最小

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    /*选择排序实例1*/
    /*选择排序,要求:小的在前大的在后*/
    int main()
    {
    	int a[100]={};
    	int i, j, t;
    	int n=sizeof(a)/sizeof(a[0]);	/*数组长度*/
    
    	/*设置随机数种子*/
    	srand(time(NULL));
    	/*数组a的元素为随机的三位数*/
    	for(i=0; i<n; i++)
    		a[i]=rand()%1000;
    
    	/*选择排序*/
    	for(i=0; i<n-1; i++)
    	{
    		for(j=i+1; j<n; j++)
    			if(a[j]<a[i])
    				t=a[i], a[i]=a[j], a[j]=t;
    	}
    
    	/*打印数组*/
    	for(i=0; i<n; i++)
    		printf("%d ", a[i]);
    
    	return 0;
    }
    

      
      方法二:找到最小值的下标,然后和a[i]交换,使最小值位于前头

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    /*选择排序实例2*/
    /*选择排序,要求:小的在前大的在后*/
    int main()
    {
    	int a[100]={};
    	int i, j, k, t;
    	int n=sizeof(a)/sizeof(a[0]);	/*数组长度*/
    
    	/*设置随机数种子*/
    	srand(time(NULL));
    	/*数组a的元素为随机的三位数*/
    	for(i=0; i<n; i++)
    		a[i]=rand()%1000;
    	
    	/*选择排序*/
    	for(i=0; i<n-1; i++)	/*i比j小1,所以i范围是0~n-1*/
    	{
    		k=i;	/*最小值下标*/
    		for(j=i+1; j<n; j++)
    			if(a[j]<a[k])	/*因为k是j的变化值,只有在第0次循环时才是a[i]和a[j]比*/
    				k=j;		/*后面碰到a[j]比a[i]小的值,a[i]就会被换掉,再后面就是a[j]和a[j]之间比了*/
    		t=a[i], a[i]=a[k], a[k]=t;
    	}
    
    	/*打印数组*/
    	for(i=0; i<n; i++)
    		printf("%d ", a[i]);
    
    	return 0;
    }
    
    

      
      

    2.冒泡排序法

      冒泡排序,顾名思义,元素会像水里的泡泡一样,从底部一直上升到顶部,即前后元素相比较,大值元素被安排到数组尾部,小值元素在交换的时候自然而然的会排在头部。

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    /*冒泡排序,要求:小的在前大的在后*/
    int main()
    {
    	int a[100]={};
    	int i, j, t;
    	int n=sizeof(a)/sizeof(a[0]);	/*数组长度*/
    
    	/*设置随机数种子*/
    	srand(time(NULL));
    	/*数组a的元素为随机的三位数*/
    	for(i=0; i<n; i++)
    		a[i]=rand()%1000;	
    	
    	/*冒泡排序*/
    	for(i=0; i<n-1; i++)		/*冒泡次数为n-1次*/
    		for(j=0; j<n-1-i; j++)	/*a[j]要和a[j+1]比较,所以范围是0~n-1,由于每冒泡一次,下一个元素的比较次数就会-1*/
    			if(a[j+1]<a[j])
    				t=a[j], a[j]=a[j+1], a[j+1]=t;
    	
    
    	/*打印数组*/
    	for(i=0; i<n; i++)
    		printf("%d ", a[i]);
    		
    	return 0;
    }
    
    

      
      

    3.(直接)插入排序法

      跟打扑克牌时差不多,把选中元素插入到有序序列合适的位置中。

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h>
    
    /*插入排序,要求:小的在前大的在后*/
    int main()
    {
    	int a[100]={};
    	int i, j, k, data;
    	int n=sizeof(a)/sizeof(a[0]);	/*数组长度*/
    
    	/*设置随机数种子*/
    	srand(time(NULL));
    	/*数组a的元素为随机的三位数*/
    	for(i=0; i<n; i++)
    		a[i]=rand()%1000;	
    	
    	/*插入排序*/
    	for(i=1; i<n; i++)		/*只有一个元素的序列就是排列好的了,所以从第二个开始*/
    	{
    		data=a[i];
    		for(j=0; j<i; j++)	/*遍历序列,找到合适的下标k*/
    			if(a[j]>data)	/*因为序列有序,所以元素都是从小到大排放大*/
    				break;
    		k=j;
    		for(j=i; j>k; j--)	/*后续元素后退一个,方便插入元素*/
    			a[j]=a[j-1];
    		a[k]=data;
    	}
    	
    
    	/*打印数组*/
    	for(i=0; i<n; i++)
    		printf("%d ", a[i]);
    		
    	return 0;
    }
    
    

      
      

    二维数组的查找方法(《剑指offer》题目)

      关于二维数组的二分查找、暴力搜索查找、线性查找(剑指offer题目,右上角解法),可以查看这篇文章:C语言 二维数组的查找方法(←点击查看原文)

      
      

    指针和一维数组

      指针就是地址(一种只能存放地址的数据类型),关于指针可以看看我写的另一篇文章~指针详解、指针和一维数组、实例(←点击查看原文)

    展开全文
  • 二分查找C语言

    2021-05-22 17:20:05
    二分查找(binary_search)二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表...

    二分查找(binary_search)

    二分查找又称折半查找,优点是比较次数少,查找速度快,平均性能好;其缺点是要求待查表为有序表,且插入删除困难。因此,折半查找方法适用于不经常变动而查找频繁的有序列表。首先,假设表中元素是按升序排列,将表中间位置记录的关键字与查找关键字比较,如果两者相等,则查找成功;否则利用中间位置记录将表分成前、后两个子表,如果中间位置记录的关键字大于查找关键字,则进一步查找前一子表,否则进一步查找后一子表。重复以上过程,直到找到满足条件的记录,使查找成功,或直到子表不存在为止,此时查找不成功。

    arrays为查找数组

    result为查找结果

    length为数组长度

    时间复杂度

    最好结果:1

    最坏结果:lg(N)

    int binary_search(int arrays[],int result,int length){

    int begin=0,end=length-1;

    int mid=0;

    while(begin<=end){

    mid=(begin+end)/2;

    if(arrays[mid]==result)break;

    else if(arrays[mid]

    else if(arrays[mid]>result)end=mid-1;

    }

    return mid;

    }

    测试函数

    int main() {

    int array[] ={1,2,3,4,5,6,7};

    int result = binary_search(array,5,7);

    printf("result is %d\n", result);

    }

    执行结果

    9a62f29ca33a

    image.png

    二分查找比较简单,注意待查找数组必须为顺序升序数组,降序数组只需要修改一下两行即可

    else if(arrays[mid]

    else if(arrays[mid]>result)end=mid-1;

    更多关于java的文章请戳这里:(您的留言意见是对我最大的支持)

    展开全文
  • //在一个数组中,查找具体的某个数字 int main(){ int arr[] = {1,2,3,4,5,6,7,8,9,10}; int k = 7; int sz = sizeof(arr)/sizeof(arr[0]); //计算元素个数 int left = 0; int right = sz - 1; //右下标 ...

    首先确定范围

    //在一个数组中,查找具体的某个数字 
    int main(){
    	int arr[] = {1,2,3,4,5,6,7,8,9,10};
    	int k = 7;
    	
    	int sz = sizeof(arr)/sizeof(arr[0]); //计算元素个数 
    	int left = 0; 
    	int right = sz - 1; //右下标	 
    	 
    	 while(left <= right) //当左下标和右下标相等时,确定了这个数
    	 {
    	 	int mid = (left + right) / 2;	//中间下标
    	 	
    	 	 if(arr[mid] < k){
    	 		left = mid + 1;
    	 	}
    	 	else if(arr[mid] > k){
    	 		right = mid - 1;
    	 	}
    	 		
    	 	else{
    	 		printf("找到了,下标是:%d",mid);
    	 		break;
    	 	}	 	
    	 } 
    	 if(left > right){
    	 	printf("找不到"); 
    	 }
    	
    	return 0;
    } 
    
    展开全文
  • 数据查找,遍历查找和二分查找
  • C语言二数组中的查找的实例 题目描述:在一个数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个数组和一个整数,判断数组中是否含有该...
  • pta二分查找法详解; 不足之处请见谅;
  • 文章标题二维数组的定义与初始化存储形式二维数组二分查找一维数组 二维数组的定义与初始化    二维数组与一维数组的定义和使用有许多共性。   1. 二维数组在使用前必须先定义和初始化,如果不定义直接使用将...
  • C语言二分查找数组下标

    千次阅读 2022-04-23 19:42:28
    有n个数存放在一个数组a[]中,输入一个数k,要求用折半查找求出k是数组中第几个元素的值,求该元素的下标;若k不属于数组中任何一个元素,则输出“None”。 方法一:不利用函数利用数组循环等求下标 #include<...
  • C语言----二分查找数(在数组中)

    千次阅读 2019-02-18 21:16:14
    写代码可以在整型有序数组查找想要的数字,找到了返回下标,找不到返回-1.(折半查找) 源码: #define _CRT_SECURE_NO_WARNINGS #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&...
  • 数组查找算法的C语言 实现-----线性查找和二分查找 线性查找 Linear Search 用户输入学生学号的成绩 二分查找 Binary Search 要求数据表是已经排好序的 程序存在小的瑕疵 jvascript 顺序查找和二分查找法 第一种:...
  • C语言数组的总结

    2021-05-22 15:31:22
    数组(Array)是一系列相同类型的数据的集合,可以是一维的、维的、多维的;最常用的是一维数组数组,多维数组较少用到。对数组的总结1) 数组的定义格式为:type arrayName[length]type 为数据类型,arrayName...
  • C语言实现有序数组二分查找

    千次阅读 多人点赞 2022-04-16 13:29:54
    C语言实现二分查找
  • 使得将数组中所有大于 value 的值变成 value 后,数组的和 最接近 target (最接近表示两者之差的绝对值最小)。 如果有多种使得和最接近 target 的方案,请你返回这些整数中的最小值。 请注意,答案不一定是 arr 中...
  • //要查找的数字 int i = 0; int sz = sizeof(arr)/sizeof(arr[0]);//数组元素个数 for(i=0; i<sz; i++)//遍历数组 { if(arr[i] == k) printf("要查找的数字的下标是%d\n", i); } return 0; } 2
  • C语言——实现一个整型有序数组二分查找的两种方法
  • C语言二分查找

    2022-01-16 19:54:44
    二分查找法:从一个有序数组中找到一个数(不管是升序还是降序)。 思路:先从中间找,之后依次截半查找。 比如从1 2 3 4 5中找到4,先找中间数3,发现4小那么取3与5最中间的数4,找到了。 如果是1 2 3 4找3,先...
  • C语言入门》简单有序数组二分查找代码实现

    多人点赞 热门讨论 2021-11-14 11:25:01
    想必学过编程的朋友或多或少都听说过二分查找,本文将给C语言入门的朋友具体介绍一下二分查找的原理和代码实现。 1.简单原理 在一个有序数组中(如图),若想查找一个具体数值,多数人可能会想到历遍数组的方法,...
  • C语言实现二分查找

    2022-01-17 11:33:28
    相较于线性查找,二分查找在面对大量数据时的效率更高,但它的缺点是只能对有序数组进行查找。 源代码如下: #include<stdio.h> void binarysearch(int *a,int sum,int n) { int low=0; int high=sum-1; ...
  • 什么是二分查找?首先,二分查找也叫折半查找,它是对于一组有序(升序或降序)数列来说的,我们举例子说明这个思想。 例如:猜数字游戏 随机给出1-100内的一个数字,请猜出这个数字 那我们不能随机没有规律的去...
  • C语言实现二分查找

    千次阅读 2021-04-07 18:18:22
    C语言实现二分查找 二分查找基本思想:首先选取表中间位置记录,将其代表的数与需查找的数进行比较,若相等则查找成功,若大于,则表示需查找的数在数组左边,反之,在数组右边。然后重复比较,直至查找成功。 注...
  • //把右标移到中间,缩小范围 } else if(nums[mid] 二分查找适用于有序数组,无重复数字。 35 int searchInsert(int* nums, int numsSize, int target){ int right=numsSize-1,left=0; int mid=0; while(left) { mid...
  • 而后面我们会知道,二分查找法则高效的多,最差要找log以2为低n的对数次,即如果有2^32个数,最差查32次就可得到结果。 所谓二分法,就是先用数组中间的数去和查找的数作比较,我们可以知道中间的数是大于还是小于...
  • c语言实现二分查找

    千次阅读 多人点赞 2022-01-16 17:55:05
    2.如何用c语言来实现二分查找法 三.总结 一.前言 假如今天我们需要在一个有序的数组中来寻找一个数的下标,就用"1,2,3,4,5,6,7,8,9"这九个数组成的数组来说,假如我们想寻找'2',那很简单我们只用从小到...
  • C语言数组知识点梳理

    2020-03-14 21:49:18
    数组声明之后变为常量,不能放在等号左边;初值表{…}只能用于初始化。 数组元素只能逐个进行引用,不能一次性引用。 数组越界的危害: (1)会覆盖其他变量的值(越界短时) (2)会出现段错误(越界过长) a+i==&a...
  • 二分查找——有序数组

    千次阅读 2022-04-10 12:19:21
    二分查找算法的详解
  • 请实现有重复数字的升序数组二分查找 给定一个 元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的第一个出现的target,如果目标值存在返回下标,否则返回 -1 示例1 输入: [1,2,4,...
  • C语言 二分法查找数组元素

    千次阅读 2020-11-08 20:15:43
    在用二分法进行查找时,查找对象的数组必须是有序的,即各数组元素的次序是按其值的大小顺序存储的。其基本思想是先确定待查数据的范围(可用 [low,high] 区间表示),然后逐步缩小范围直到找到或找不到该记录为止。...
  • C语言进行二分查找

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,879
精华内容 16,751
关键字:

c语言数组二分查找