常见的查找算法--------顺序查找、哈希查找、二分查找（递归算法和循环算法）简单代码及应用范围

常见的查找算法

头文件、宏定义、主函数

#include 
#include 
#include 

#define LEN 10
#define swap(a,b) {typeof(a) t=a; a=b; b=t;}//数值交换宏
#define show_arr(arr,len) {for(int i=0; i//显示宏
int main()
{
	int arr[LEN] = {};
	for(int i=0; i<LEN; i++)
	{
		arr[i] = rand()%100;
	}
	printf("order search:%d\n",order_search(arr,LEN,15));
	sort(arr,LEN);
	show_arr(arr,LEN);
	printf("binary search:%d\n",binary_search_for(arr,LEN,100));
}

顺序查找

顺序查找对数据没有要求，但是数据量大，可能的运算次数多，所以比较适用于数据量少。

int order_search(int* arr,int len,int key)
{
	for(int i=0; i<len; i++)
	{
		if(arr[i] == key)
		{
			return i;
		}
	}
	return -1;
}

哈希查找

哈希查找：
数据 经过哈希函数 计算出数据在哈希表中的位置，然后标记，方便之后的查找，它的时间复试度最快能达到：O(1)。
但是该算法有很大局限性，不适合浮点型、字符串型数据，需要额外的存储空间，空间复杂度高，是一种典型的用空间换取时间的算法。

  哈希函数设计方法：
     **直接定址法：把数据直接当作数组的下标。**
     **数字分析法：分析数据的特点来设计哈希，常用的方法就是找到最大值与最小值,最大值-最小值+1来确定哈希表的长度，数据-最小值访问哈希表。**

bool hash_search(int* arr,int len,int key)
{
	int max = arr[0] , min = arr[len-1];
	for(int i=1; i<len-1; i++)
	{
		if(arr[i] > max) max = arr[i];
		if(arr[i] < min) min = arr[i];
	}

	// 创建哈希表
	int hash[max-min+1] = {};
	// 标记
	for(int i=0; i<len; i++)
	{
		hash[arr[i]-min]++;
	}
	// 查找
	return hash[key-min];
}

二分查找

二分查找的数据必须是有序的，时间复杂度为O(logN)

// 循环二分
void sort(int* arr,int len)
{
	for(int i=0; i<len-1; i++)
	{
		for(int j=i+1; j<len; j++)
		{
			if(arr[i] > arr[j])
			{
				swap(arr[i],arr[j]);
			}
		}
	}
}

int binary_search_for(int* arr,int len,int key)
{
	int l = 0 , r = len-1;
	while(l<=r)
	{
		int p = (l+r)/2;
		if(arr[p] == key) return p;

		if(key < arr[p])
			r = p-1;
		else
			l = p+1;
	}
	return -1;
}
int _binary_search(int* arr,int l,int r,int key)
{
	if(l > r) return -1;

	int p = (l+r)/2;
	if(arr[p] == key)
		return p;
	if(key < arr[p])
		return _binary_search(arr,l,p-1,key);
	else
		return _binary_search(arr,p+1,r,key);
}

// 递归二分
int binary_search(int* arr,int len,int key)
{
	return _binary_search(arr,0,len-1,key);	
}