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

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

查找算法：
顺序查找：
对待查找的数据没有要求，时间复杂度: 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;
		}
	}
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

快速：找到一个标杆，一面从左找比标杆大的数据，找到后把放在标杆的右边，另一个从右边找比标杆小的数据，找到后把放在标杆的左边，最终标杆左边的数据都比它小，右边的数据都比它大，这样就整体有序，然后按同样的方法排序标杆左边的数据和标杆右边的数据。
它的综合性能最高，因此叫快速排序，笔试时考的最多的排序。
时间复杂度：O(nlogn)
不稳定

void _quick_sort(TYPE* arr,int left,int right)
{
	if(left >= right) return;
	int l=left,r=right;
	TYPE pv = arr[l];
	while(l<r)
	{
		while(l<r && arr[r] >= pv) r--;
		arr[l] = arr[r];
		while(l<r && arr[l] <= pv) l++;
		arr[r] = arr[l];
	}

	arr[l] = pv;
	_quick_sort(arr,left,l-1);
	_quick_sort(arr,l+1,right);
}

void quick_sort(TYPE* arr,size_t len)
{
	_quick_sort(arr,0,len-1);
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

归并：先一组把数据拆分成单独的个体，然后按从小到大的顺序进行合并，由于需要使用额外的内存空间因此避免的数据交换的耗时，也是一种典型的用空间换取时间的算法，可递归实现也可以循环实现。
时间复杂度：O(nlogn)
稳定

// 合并
void merge(TYPE* arr,TYPE* tmp,int l ,int p , int r)
{
	if(arr[p] < arr[p+1]) return;

	int k = l , i = l , j = p+1;
	while(i<=p && j<=r)
	{
		if(arr[i] < arr[j])
			tmp[k++] = arr[i++];
		else
			tmp[k++] = arr[j++];
	}
	while(i<=p) tmp[k++] = arr[i++];
	while(j<=r) tmp[k++] = arr[j++];
	//while(l<=r) arr[l] = tmp[l++]; 
	memcpy(arr+l,tmp+l,sizeof(TYPE)*(r-l+1));
}

// 拆分
void _merge_sort(TYPE* arr,TYPE* tmp,int l,int r)
{
	if(l >= r) return;
	int p = (l+r)/2;
	_merge_sort(arr,tmp,l,p);
	_merge_sort(arr,tmp,p+1,r);
	merge(arr,tmp,l,p,r);
}

// 归并
void merge_sort(TYPE* arr,size_t len)
{
	TYPE* tmp = malloc(sizeof(TYPE)*len);
	_merge_sort(arr,tmp,0,len-1);
	free(tmp);
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

void merge_for_sort(TYPE* arr,size_t len)
{
	TYPE* tmp = malloc(sizeof(TYPE)*len);
	TYPE* src = arr , *des = tmp;

	for(int s=1; s<len; s*=2)
	{
		for(int l=0; l<len; l+=s*2)
		{
			int r = (l+s*2<len)?l+s*2:len;
			int p = (l+s<len)?l+s:len; 
			int k = l , i = l , j = p;
			while(i<p && j<r)
			{
				if(src[i] < src[j])
					des[k++] = src[i++];
				else
					des[k++] = src[j++];
			}
			while(i<p) des[k++] = src[i++];
			while(j<r) des[k++] = src[j++];
		}
		swap(des,src);
	}
	if(src != arr) memcpy(arr,src,sizeof(TYPE)*len);
	free(tmp);

	show_arr(arr,len);
	printf(":%s\n",__func__);
}

堆：把数据当作完全二叉树，然后树中调整为大根树，然后把根节点交换到最后，然后数量–，然后再调整为大根树，直到数量为1时结束，可递归实现也可以循环实现。
时间复杂度：O(nlogn)
不稳定

void create_heap(TYPE* arr,int root,size_t len)
{
	if(root >= len) return;
	int left = root*2+1 , right = root*2+2;
	create_heap(arr,left,len);
	create_heap(arr,right,len);
	if(right < len && arr[left] < arr[right])
		swap(arr[left],arr[right]);
	if(left < len && arr[root] < arr[left])
		swap(arr[root],arr[left]);
}

void heap_sort(TYPE* arr,size_t len)
{
	create_heap(arr,0,len);	
	for(int i=len-1; i>0; i--)
	{
		swap(arr[0],arr[i]);
		create_heap(arr,0,i);
	}

	show_arr(arr,len);
	printf(":%s\n",__func__);
}

void heap_for_sort(TYPE* arr,size_t len)
{
	for(int i=len-1; i>0; i--)
	{
		int p = (i+1)/2-1;
		if(arr[i] > arr[p]) swap(arr[i],arr[p]);
	}
	show_arr(arr,len);
	printf("\n");

	for(int i=len-1; i>0; i--)
	{
		swap(arr[0],arr[i]);
		for(int j=0; j<i; j++)
		{
			if(j*2+2<i && arr[j*2+1]<arr[j*2+2])
			{
				swap(arr[j*2+1],arr[j*2+2])
			}
			if(j*2+1<i && arr[j]<arr[j*2+1])
			{
				swap(arr[j],arr[j*2+1])
			}
		}
	}
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

计数：找出数据中的最大值和最小值，创建哈希表，把数据-最小值当作数组中的下标访问哈希表并标记数量，然后遍历哈希表，当表中的值大于时，把下标+最小值依次放入数组中，是一种典型的用空间换取时间的算法。
该排序算法理论上速度非常快，但有很大局限性，适合排序整型数据，而且数据的差值不宜过大，否则会非常浪费内存，数据越平均、重复数越多，性价比越高。
时间复杂度：O(n+k);
稳定

void count_sort(TYPE* arr,size_t len)
{
	TYPE min = arr[0] , max = arr[len-1];
	for(int i=0; i<len; i++)
	{
		if(arr[i] < min) min = arr[i];
		if(arr[i] > max) max = arr[i];
	}
	TYPE* tmp = calloc(sizeof(TYPE),max-min+1);
	for(int i=0; i<len; i++)
	{
		tmp[arr[i]-min]++;
	}
	for(int i=0,j=0; i<=max-min; i++)
	{
		while(tmp[i]--)
		{
			arr[j++] = i+min;
		}
	}
	free(tmp);
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

桶：把数据根据值，存储到不同桶中，然后再调用其它排序函数，对桶中的数据进行排序，然后再拷贝到数组中，以到降低排序规模来提高排序的时间，是一种典型的用空间换取时间的算法。
时间复杂度：O(n+k);
稳定

void _bucket_sort(TYPE* arr,size_t len,int cnt,TYPE range)
{
	TYPE* bucket[cnt],*bucketed[cnt];
	for(int i=0; i<cnt; i++)
	{
		bucket[i] = malloc(sizeof(TYPE)*len);
		bucketed[i] = bucket[i];
	}

	for(int i=0; i<len; i++)
	{
		for(int j=0; j<cnt; j++)
		{
			if(range*j<=arr[i] && arr[i]<range*(j+1))
			{
				*(bucketed[j]) = arr[i];
				bucketed[j]++;
			}
		}
	}
	for(int i=0; i<cnt; i++)
	{
		int size = bucketed[i]-bucket[i];
		if(size > 1) count_sort(bucket[i],size);
		memcpy(arr,bucket[i],sizeof(TYPE)*size);
		arr += size;
		free(bucket[i]);
	}
}

void bucket_sort(TYPE* arr,size_t len)
{
	_bucket_sort(arr,len,4,25);	
	show_arr(arr,len);
	printf(":%s\n",__func__);
}

基数：是桶排序的具体实现，首先创建10个队列(队列)，然后逆序计算出数据的个十百… 然后压入到对应的队列中，然后再从队列中弹出存储的数组中，当下标为0队列中有len个数据时，排序结束。
时间复杂度：O(n+k);
稳定

void radix_sort(TYPE* arr,size_t len)
{
	ListQueue* queue[10] = {};
	for(int i=0; i<10; i++)
	{
		queue[i] = create_list_queue();
	}

	for(int i=1; i<=10&&size_list_queue(queue[0])<len; i++)
	{
		int mod = pow(10,i);
		int div = mod / 10;

		for(int j=0; j<len; j++)
		{
			int index = arr[j]%mod/div;
			push_list_queue(queue[index],arr[j]);
		}
		int k = 0;
		for(int j=0; j<10; j++)
		{
			while(!empty_list_queue(queue[j]))
			{
				arr[k++] = head_list_queue(queue[j]);
				pop_list_queue(queue[j]);
			}
		}
	}
	for(int i=0; i<10; i++)
	{
		destory_list_queue(queue[i]);
	}

	show_arr(arr,len);
	printf(":%s\n",__func__);
}

如何判断排序算法是否稳定：
待排序的数组中，如果有值相同的数据，排序过程中如果不会改它们的前后顺序，则认为该排序算法稳定。