递归算法

1.典型的斐波那契数列f(x) = f(x-1)+f(x-2)。

题目：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

思路：此题是青蛙跳台阶问题的进阶版，应用到递归思想。考虑前n-1、n-2……种情况下，多付1、2……元，所以，对应的数学表达为  f(x) = f(x-1)+f(x-2)+f(x-3)……=2f(n-1)

int fountion(int n)
{
    if (n = 1)
        return 1;
    else
        return 2 * fountion(n - 1);
}

2.快速排列

int partion(int seq[],int low,int high)
{
    int pivot = seq[low];
    while (low<high)
    {
        while (low < high && pivot < pivot)
            high--;
        seq[low] = seq[high];
        while (low < high && pivot > pivot)
            low++;
        seq[high] = seq[low];
    }
    seq[low] = pivot;
    return low;
}
void quickSort(int seq[], int low, int high)
{
     if(low<high)
     {
        int pivot = partion(seq, low, high);
        quickSort(seq, low, pivot);
        quickSort(seq, pivot, high);

     }
}

3.前、中、后序遍历

vector<int> inorderTraversal(TreeNode* root)
{
    vector<int> test;
    inorder(root, test);
    return test;
}
void inorder(TreeNode* root, vector<int>& test) //传引用不传值
{
    if (root == NULL)    //终止条件
        return;
    else
    {
        inorder(root->left, test);
        test.push_back(root->val);
        inorder(root->right, test);
    }
}

4.DFS+回溯算法

如：求全排列

//DFS可以看成树来理解就简单多了，从根节点到所有叶子结点的路劲为n种情况 
vector<vector<int>> permute(vector<int>& nums) 
    {
        vector<vector<int>> res;
        int len = nums.size();
        int dep = 0;
        if (len == 0)
            return res;
        else
            DFS(res,nums,0,len);
            return res;
    }

    void DFS(vector<vector<int>> &res, vector<int> &sam,int dep,int len)
    {
        if (len == dep)       //表示已经到了最后一层，为一种情况
        {
            res.push_back(sam);
            return;
        }
        for (int i = dep; i < len; i++)
        {
            swap(sam[i], sam[dep]);     //i位置之前的数为已选情况
            DFS(res, sam, dep+1, len);
            swap(sam[dep], sam[i]);      //回溯算法的思想，需要改回到之前的样子
        }

    }