顺序查找，二分查找，块查找，哈希查找

1.顺序查找

​ 对待查找的数据没有要求，从头到尾逐一比较，在小规模的查找中较为常见，查找效率较低
​ 时间复杂度：O(N)

2.二分查找(折半查找)

​ 待查找的数据必须有序，从数据中间；位置开始比较查找，如果中间值比key小，则从左边继续进行二分查找，反之从右边进行。
​ 时间复杂度：O(logN)

3.块查找(权重查找)

​ 是一种数据处理的思想，不是一种特定的算法，当数据量非常多时，可以先把数据进行分块处理，然后再根据分块的条件进行查找，例如英文字典;（块间用二分查找，块内用顺序查找）

#include <stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<string.h>
#define LEN 10
//顺序查找
int order_search(int *arr,int len,int key)
{
	for(int i=0;i<len;i++)
	{
		if(arr[i]==key)
		{
			return i;	
		}
		
		
	}

	return -1;
}


void sort(int *arr,int len)
{
	for(int i=0;i<len-1;i++)
	{
		for(int j=0;j<len-1-i;j++)
		{
			if(arr[j]>arr[j+1])
			{
				int temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
		
	}

}
//二分查找循环
int  bin(int arr[],int n,int target)
{
	
	int left=0, right=n-1;
	while(left<=right)
	{
		int mid=left+(right-left)/2;	
		if(arr[mid]==target)
		{
			return mid;	
			
		}else if(arr[mid]<target)
		{
			left=mid+1;	
		}else 
		 right=mid-1;
	}
	 return -1;	
}

//依赖
int  _bin_recuesion(int *arr,int l,int r,int key)
{
    	if(l>r) return -1;          
	  int	mid=(l+r)/2;
		if(arr[mid]==key) return mid;
		
		if(key<arr[mid])  return  _bin_recuesion(arr,l,mid-1,key);
		else      		  return _bin_recuesion(arr,mid+1,r,key);
	
}
//递归二分查找
int bin_recuesion(int *arr,int len,int key)
{
	return  _bin_recuesion(arr,0,len-1,key);	
	
}



int main(int argc,const char* argv[])
{
	int arr[LEN]={};
	for(int i=0;i<LEN;i++)
	{
		arr[i]=rand()%100	;
//		printf("%d ",arr[i]);
	}
	//printf("%d ",order_search(arr,LEN,21));
	
	sort(arr,10);
	for(int i=0;i<LEN;i++)
	{
		printf("%d ",arr[i]);
	}
	printf("\n%d\n",bin(arr,10,21));
	printf("%d\n ",bin_recuesion(arr,10,21));
	return 0;
}

4.哈希查找

1.线性探测

2.直接定址法

元素作为下标

bool hash_search(int *arr,int len,int key)
{
	//直接定址法
	//创建哈希表
	/*法1：
	int hash[100000]={};
	for(int i=0;i<len;i++)
	{
		hash[arr[i]]++;	
	}
	return hash[key];
	*/
	//法2：
	int max=arr[0],min=arr[0];
	for(int i=0;i<len;i++)
	{
		if(arr[i]>max) max=arr[i];
		if(arr[i]<min) min=arr[i];
		
	}
	int hash[max-min+1];
	memset(hash,0,sizeof(hash));
	for(int i=0;i<len;i++)
	{
		hash[arr[i]-min]++;	
	}
	//查找
	return key-min;
}