算法

**

算法:

**
数据结构中的算法，指的是数据结构所具备的功能。
解决特定问题的方法，他是前辈们的一些优秀的经验总结。

**

分治：

**
把一个大而复杂的问题，分解为很多个小而简单的问题，利用计算机的强大计算能力来解决问题。
实现分治的方法有：循环、递归

递归：
是函数自己调用自己的行为，这种行为可以形成循环调用，进而实现分治算法。
什么情况下使用递归：
问题太复杂无法拆解成循环语句。
问题非线性，而函数递归，由于借助栈内存，函数的每一次调用，（函数的每一次调用，就会把它的数据重新压入栈空间，它的数据都会保留下来），可以解决非线性的问题（二叉树的相关问题，汉诺塔问题等）
在单线程模式下永远只能同时执行一个函数，当函数自己调用自己时（子级），会先执行子级的的代码，然后子级执行完成后再返回到上一级继续执行。
如何安全实现递归：
使用递归很有可能造成“死循环”，非常浪费空间耗费资源。
1、先写出口，考虑如何让无限的调用停止下来。
if(条件) return;
2、解决一个小问题
3、把剩下的问题交给我的下一级（参数发生变化）
练习：使用递归实现斐波那契数列前n项
练习：使用递归实现汉诺塔问题n层的盘子的移动过程。
递归的优点：
代码简单容易理解
缺点：容易形成死循环，耗费内存，运行速度慢，执行效率低（参数入栈、出栈、局部变量的定义、销毁）。

查找：

顺序查找：从头到位逐一比较，对于要查找的数据没有要求，但方法简单，在小规模的数据查找中比较常用，效率低。

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

二分查找：前提就是数据必须是有序的，然后从数据的中间位置开始查起。

int _binary_find(int* arr,size_t l,size_t r,int key)
{
	if(l > r) return -1;

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

int binary_find(int* arr,size_t len,int key)
{
	//return _binary_find(arr,0,len-1,key);
	int l = 0 , r = len -1 ;

	while(l <= r)
	{
		int pi = (l+r) / 2;
		if(key > arr[pi])
			l = pi + 1;
		else if(key < arr[pi])
			r = pi - 1;
		else 
			return pi;
	}
	
	return -1;
}

块查找，权重查找：适用于特殊条件下，需要对数据进行排序、分析、总结、归纳。

排序：

排序算法的稳定性：当序列中由相等的数据时，算法会不会改变这两个数据的前后位置。

**冒泡排序:**是一种稳定排序，在排序过程中可以监测到数据是否已经有序（对数据的有序性敏感），可以立即停止，如果待排序的数据基本有序，则冒泡的效率是非常高的

#define swap(a,b) {typeof(a) t=a; a=b; b=t;}
void bubble_sort(int* arr,size_t len)
{
	for(int i=len-1; i>0; i--)
	{
		bool flag = true;
		for(int j=0; j<i; j++)
		{
			if(arr[j] > arr[j+1])
			{
				swap(arr[j],arr[j+1]);
				flag = false;
			}
		}
		if(flag) break;
	}
}

插入排序：当一列数已经有序再有新加入的数据时，适当使用插入排序。

void insert_sort(int* arr,size_t len)
{
	for(int i=1; i<len; i++)
	{
		int t = arr[i] , k = i;
		for(int j=i-1; j>=0 && arr[j] > t; j--)
		{
			arr[j+1] = arr[j];
			k = j;
		}
		arr[k] = t;
	}
}

选择排序：是冒泡排序的一种变种，但是它没有冒泡对数据有序性的敏感，但它在排序过程中比冒泡要少了很对数据交换，因此要比冒泡要快（数据比较混乱的情况下）

void select_sort(int* arr,size_t len)
{
	for(int i=len-1; i>0; i--)
	{
		int max = i;
		for(int j=0; j<i; j++)
		{
			if(arr[j] > arr[max])
				max = j;
		}
		if(max != i)
			swap(arr[max],arr[i]);
	}
}

快速排序：
基于交换的一种排序。

void _quick_sort(int* arr,size_t left,size_t right)
{
	if(left >= right) return;

	// 计算标杆的下标
	int pi = (left+right)/2;
	// 备份标杆的值
	int pv = arr[pi];
	// 备份左右下标
	int l = left , r = right;
	/*for(int i=left; i<=right; i++)
	{
		if(i==pi)
		{
			printf("[%d] ",arr[i]);
		}
		else
			printf("%d ",arr[i]);
	}
	printf("\n");	*/
	// 左右下标相遇时结束
	while(l < r)
	{
		// 在标杆的左边寻找比它大的数据
		while(l<pi && arr[l] <= pv) l++;
		if(l<pi) // 如果没有超出范围，说明找到比标杆大的值
		{
			// 与标杆交换位置，并记录新的标杆下标
			arr[pi] = arr[l];
			pi = l;
		}
		// 在标杆的右边寻找比它小的数据
		while(pi<r && arr[r] >= pv) r--;
		if(pi<r) // 如果没有走出范围，说明找到比标杆小的值
		{
			arr[pi] = arr[r];
			pi = r;
		}
	}
	// 还原标杆的值
	arr[pi] = pv;
	//show_arr(arr,10);
	if(pi-left > 1) _quick_sort(arr,left,pi-1);
	if(right-pi > 1) _quick_sort(arr,pi+1,right);
}

void quick_sort(int* arr,size_t len)
{
	_quick_sort(arr,0,len-1);
}

堆排序：首先把待排序的数组当作完全二叉树，然后保证根节点最大，然后把根节点与最后一个元素交换，然后再调整二叉树（逐渐减少数组），让根依然保持最大，重复上次操作。

void creat_heap(int* arr,size_t root,size_t len)
{
	if(root >= len) return;
	int left = root*2+1,right = root*2+2;

	creat_heap(arr,left,len);
	creat_heap(arr,right,len);

	int max = root;
	if(left < len)
	{
		if(arr[left] > arr[max])
			max = left;
	}

	if(right < len)
	{
		if(arr[right] > arr[max])
			max = right;
	}
	
	if(max != root)
		swap(arr[max],arr[root]);
}

void heap_sort(int* arr,size_t len)
{
	for(int i=0; i<len; i++)
	{
		creat_heap(arr,0,len-i);
		swap(arr[0],arr[len-i-1]);
	}
}

**归并排序：**不交换数据，但是需要借助额外的空间用作临时存储空间。

void merge(int* arr,size_t left,size_t pi,size_t right)
{
	int i=left,j=pi+1,k=0;
	// 内部合并
	int temp[right-left+1];

	while(i<=pi && j<=right)
	{
		if(arr[i] < arr[j])
			temp[k++] = arr[i++];
		else
			temp[k++] = arr[j++];
	}

	while(i<=pi) temp[k++] = arr[i++];
	while(j<=right) temp[k++] = arr[j++];
	
	for(int i=0; i<=(right-left); i++)
	{
		arr[i+left] = temp[i];
	}
}
void _merge_sort(int* arr,size_t left,size_t right)
{
	if(left >= right) return;
	int pi = (left+right)/2;
	printf("%d %d\n",pi,arr[pi]);
	_merge_sort(arr,left,pi);
	_merge_sort(arr,pi+1,right);
	merge(arr,left,pi,right);
}

void merge_sort(int* arr,size_t len)
{
	_merge_sort(arr,0,len-1);
}

算法的时间复杂度：

注意：时间复杂度并不是指程序算法所需要的时间，而是算法执行的次数。
冒泡：O(N)，O（N^2）
插入：O(N)，O（N^2）
选择：O(N^2)
堆排序:O(n log2n)
快速排序：O(n log2n)
归并：O（nlog2n）