时间复杂度

1. 衡量算法执行时间随输入规模增长而增长的速度的一个概念。它用大写字母O表示，后跟一个函数描述算法执行时间。这里的“n”通常代表输入数据的大小或数量。
2. 例如，对于顺序查找（线性查找）算法，你需要遍历数组中的每个元素来查找目标值。如果数组有n个元素，那么在最坏的情况下（即目标值不存在于数组中），你也需要遍历整个数组，因此执行时间为n次，那么顺序查找算法的时间复杂度就是O(n)。
3. 对于其他的时间复杂度表示，如O(log n)，它表示算法的执行时间与输入数据的大小成对数关系。这意呀着，随着输入数据大小的增加，算法的执行时间不会像O(n)那样线性增长，而是增长得更慢。二分查找就是一个典型的O(log n)时间复杂度的算法。

1. 顺序查找（Linear Search）

描述：顺序查找是最简单的查找方法，它逐个检查数组中的每个元素，直到找到所需的元素或搜索完整个数组。

时间复杂度：平均和最坏情况都是O(n)，最好情况是O(1)（如果第一个元素就是目标元素）。

#include <stdio.h>  
// 顺序查找函数  
int linearSearch(int arr[], int n, int x) {  
    for (int i = 0; i < n; i++) {  
        if (arr[i] == x) {  
            return i; // 找到元素，返回其索引  
        }  
    }  
    return -1; // 未找到元素，返回-1  
}  
  
int main() {  
    int arr[] = {2, 3, 4, 10, 40};  
    int n = sizeof(arr)/sizeof(int); //sizeof（arr）是数组所占用的字节大小，sizeof(int)是int类型所占的字节大小。二者相除得出个数，即数组的长度。
    int x = 10;  
    int result = linearSearch(arr, n, x);  
    if (result == -1) {  
        printf("no);  
    } else {  
        printf("Yes -> %d", result);  
    }  
    return 0;  
}

2. 二分查找（Binary Search）

描述：二分查找是一种在有序数组中查找特定元素的快速算法。它通过将数组分成两半，判断目标元素可能存在的那一半，然后继续在那一半中查找，直到找到元素或搜索范围为空。

时间复杂度：平均和最坏情况都是O(log n)。

#include<stdio.h>
int main(){
	int arr [] = {25,44,53,62,79,81,91};
	int i;
	int len = sizeof(arr)/sizeof(int);
	int n = 79;
	//方法1： while嵌套 
//	int max = len-1,min = 0,mid = (max+min)/2;
//	printf("max = %d,min = %d,mid = %d,len = %d",max,min,mid,len);
//	while(min <= max){
//		if(arr[mid]>n){
//			max = mid-1;
//		}else{
//			min = mid+1;
//		}
//		mid = (max+min)/2;	
//	}
//	printf("\n");
//	printf("mid = %d",mid);
	int flag = BinarySearch(arr,len,n);
	printf("flag = %d\n",flag);
	if(!flag){
		printf("no");
	} else{
		printf("yes -> %d",arr[flag]);
	}
	return 0;
}
//方法2：BinarySearch函数 
int BinarySearch(int arr[],int len,int n){
	int max=len-1,min=0,mid;
	while(min<=max){
		mid = (max+min)/2;
		if(arr[mid] == n)
			return mid;
		else if(arr[mid]>n){
			max = mid-1;
		}else{
			min = mid+1;
		}
	}
	return -1;
}

3. 插值查找（Interpolation Search）

插值查找是一种在有序数组中查找某一特定元素的搜索算法。在选择中间点时，它使用了插值公式，这个公式基于要查找的值和数组两端的值之间的比例关系来估计中间点的位置。这种方法在数组元素分布较为均匀时尤其有效。

时间复杂度：

1. 最好情况：如果元素恰好位于通过插值公式计算出的中间点，则时间复杂度为O(1)。
2. 平均情况：如果分布较为均匀，则接近O(log n)；但如果分布极不均匀，则可能退化到O(n)。
3. 最坏情况：当数组中的元素分布极不均匀时，插值查找可能退化为线性查找，时间复杂度为O(n)。

#include<stdio.h>
//插值查找：
int InterpolationSearch(int arr[],int len,int n){
	int max = len - 1; // 数组的最大索引  
    int min = 0;       // 数组的最小索引  
    int mid;           // 用于存储计算出的中间索引  
	while(min<=max){
		// 根据插值查找公式计算中间索引  
        // mid = min + [(n - arr[min]) / (arr[max] - arr[min])] * (max - min)  
		mid = min+(n-arr[min])/(arr[max]-arr[min])*(max-min);
		if(arr[mid] == n)
			return mid;
			//如果中间mid大于查找元素，则左半部分继续查找 
		else if(arr[mid]>n){
			max = mid-1;
			//否则，在右半部分查找 
		}else{
			min = mid+1;
		}
	}
	return -1;
}
int main(){
	int arr [] = {25,44,53,62,79,81,91};
	int i;
	int len = sizeof(arr)/sizeof(int);
	int n = 79;
	int flag = BinarySearch(arr,len,n);
	printf("flag = %d\n",flag);
	if(flag==-1){
		printf("no");
	} else{
		printf("yes -> %d",arr[flag]);
	}
	return 0;
}

4.分块查找

5.哈希查找