查找算法和排序算法（顺序查找，二分查找，块查找，哈希查找，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，堆排序，计数排序，桶排序，基数排序）

算法的时间复杂度并不能代表算法的实际执行时间，有些时候看似复杂度高的速度反面快。

查找算法：
顺序查找：
对待查找的数据没有要求，时间复杂度: O(n)
二分查找:
对待查找的数据必须有序，时间复杂度: O(logn)
块查找：
是一种数据处理的思想，不是特定的算法，当数据量过多时，可以先把数据进行分块处理，然后再进行查找，例如英语词典。
哈希查找：
数据 经过哈希函数 计算出数据在哈希表中的位置，然后标记，方便之后的查找，它的时间复试度最快能达到：O(1)。
但是该算法有很大局限性，不适合浮点型、字符串型数据，需要额外的存储空间，空间复杂度高，是一种典型的用空间换取时间的算法。

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

排序算法：
冒泡：数据左右进行比较，把最大的数据交换到最后，特点是该算法对数据的有序性敏感，在排序过程中可以立即发现已经完成。
时间复杂度：O(n),O(n^2)
稳定

// 冒泡排序
void bubble_sort(TYPE* arr,size_t len)
{
   
	bool flag = true;
	for(int i=len-1; i>0 && flag; i--)
	{
   
		flag = false;
		for(int j=0; j<i; j++)
		{
   
			if(arr[j] > arr[j+1])
			{
   
				swap(arr[j],arr[j+1]);
				flag = true;
			}
		}
	}
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

选择：假定最开始的位置是最小值并记录下标min，然后与后面的数据进行比较，如果有比以min为下标的数据小的则min的更新，最后如果min的如果发生改变，则交换min与最开始位置的数据，虽然时间复杂度挺高的，但数据交换的次数比较小，因此实际运行速度并不慢(数据交换比数据比较耗时)。
时间复杂度：O(n^2)
不稳定

// 选择排序
void select_sort(TYPE* arr,size_t len)
{
   
	for(int i=0; i<len-1; i++)
	{
   
		int min = i;
		for(int j=i+1; j<len; j++)
		{
   
			if(arr[j] < arr[min]) min = j;
		}
		if(i != min) swap(arr[i],arr[min]);
	}
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

插入：把数据看作两部分，一分部是有序，把剩余的数据逐个插入进行，适合对已经排序后的数据，新增数据并排序。
时间复杂度：O(n^2)
稳定

// 插入排序
void insert_sort(TYPE* arr,size_t len)
{
   
	for(int i=1,j=0; i<len; i++)
	{
   
		int val = arr[i];
		for(j=i; j>0 && arr[j-1] > val; j--)
		{
   
			arr[j] = arr[j-1];
		}
		if(j != i) arr[j] = val;
	}
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

希尔：是插入排序的增加版，由于插入排序时，数据移动的速度比较发慢，所以增加了增量的概念，以此来提高排序速度。
时间复杂度：O(nlogn)
不稳定

// 希尔排序
void shell_sort(TYPE* arr,size_t len)
{
   
	for(int k=len/2; k>0; k/=2)
	{
   
		for(int i=k,j=0; i<len; i++)
		{
   
			int val = arr[i];
			for(j=i; j-k>=0 && arr[j-k] > val; j-=k)
			{
   
				arr[j] = arr[j-k];
			}
			if(j != i) arr[j] = val;
		}