分治算法：
思想就是有分，有合。
比如并归排序和快速排序.
并归排序，首先是把一个数组从中间分开，然后2边在分开，一直分到只有一个数为止，然后从一个数开始慢慢的按顺序合并。
void merge(int arr[],int left,int mid,int right)
{
int i, j, k;
i = mid - left + 1;
j = right - mid;
int *arr1 = NULL;
int *arr2 = NULL;
arr1 = (int*)malloc(sizeof(int)*i);
arr2 = (int*)malloc(sizeof(int)*j);
arr1[m] = arr[left + m];
for (int n = 0; n < j; n++)
arr2[n] = arr[mid + 1 + n];
int n = 0;
k = left;
while (m <i&&n < j)
{
if (arr1[m] <= arr2[n])
arr[k++] = arr1[m++];
else
arr[k++] = arr2[n++];
}
for (; m < i; m++)
arr[k++] = arr1[m];
for (; n < j; n++)
arr[k++] = arr2[n];
arr1 = NULL;
free(arr2);
arr2 = NULL;
}
void decompose(int* arr, int left, int right) //首先是分解开。
{
if (left < right) //判断结束条件
{
int mid = (right + left) / 2; //注意是+号，别写成减号。。。。。
decompose(arr, left, mid); //按左右分成2部分
decompose(arr, mid+1, right);
merge(arr, left, mid, right); //最后合并
}
}
快速排序：选取一个数，一般选择的是中间，然后比中间小的数放在左边，比中间大的数放在右边，然后依次递归，排出序来。
void quicksort(int arr[],int left,int right)
{
int mid = arr[(right + left) / 2];
int i=left, j=right;
int temp;
while (i <j)
{
while (arr[i] <mid)
{
i++;
}
while (arr[j] >mid) //不能相等，最后走到选出的那个数 肯定要找到一个数交换
{
j--;
}
if (i <=j) //必须得小于等于，这样的话就肯定有换位置的机会，如果
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}
quicksort(arr, left, j);
if (i<right) //i变量是一直向right方向走的
quicksort(arr, i, right);
}
回溯算法：
思想有进有回。挑选组合，比如1~4 选择2个数组合的集合。
#include<iostream>
using namespace std;
#include<vector>
void find__(int n, int k, int start,vector<int>&result ) // k表示的是挑选出几个数。
{
vector<int>::iterator itor;
if (k < 0) //k小于零表示挑选结束return ;
else if (k == 0)
{
for (vector<int>::iterator it = result.begin(); it != result.end(); it++)
{
cout << *it << '\t';
}
cout << endl;
return;
}
else
{
for (int i = start; i <= n; i++)
{
result.push_back(i); //首先进去一个数
find__(n, k - 1, i + 1, result); //选择不同的数，所以i+1
result.pop_back(); //选择完了就把这个数给返回出来。 从开始到结束都每执行一次find__函数，就有
} //一次放入取出的操作。
}
}
void main()
{
vector<int>result;
find__(4, 2, 1, result);
}
动态规划：像斐波拉契数列 f(n)=f(n-1)+f(n-2) 这样的递归或者是循环，一般的从上到下的思想来解决，这样的话一般就会
造成很多的重复解，使用动态规划，我们可以从下往上计算，并且保存计划好的值，这样可以节省时间。