面试总结之 递归

递归的基本形式是：

第一种是先递归，再处理（比如MergeSort）

 T Recursive(arg_list* args){
 if(args==BASIC_CASE)
    return T(BASIC_CASE);
 for(int i=0;i<n;i++)
    t[i] = Recursive(args+i);
 //combine results
}

OR

一种是先处理，再递归（比如qsort）

T Recursive(arg_list* args){
 if(args==BASIC_CASE)
    return T(BASIC_CASE);
 //process the data
 for(int i=0;i<n;i++)
    t[i] = Recursive(args+i);
}

1. 递归终止条件，也就是那个问题是你不需要递归解决的，比如if(root==NULL)

2. 先递归还是先处理，参照上面的两个框架

3. 处理的逻辑怎么写，这部分特别搞笑~貌似见过不少人忘记写这一块的了，直接递归下去就觉得程序可以帮你解决这个问题，就像MergeSort，分段去MergeSort之后，回来却不把结果Merge。

 

 

 

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,
If n = 4 and k = 2, a solution is:

[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

这个就是第一种，先递归，在处理  combine.

public ArrayList<ArrayList<Integer>> combine(int n, int k) {
    // Start typing your Java solution below
    // DO NOT write main() function
    if(n<k) return null;
    ArrayList<ArrayList<Integer>> all = new  ArrayList<ArrayList<Integer>>();       
    if(k==1){
        for(int i=1;i<=n;i++){
            ArrayList<Integer> al = new ArrayList<Integer>();
            al.add(i);
            all.add(al);
        }
        return all;
    }
    for(int i=n;i>=k;i--){                
        for(ArrayList<Integer> al : combine(i-1,k-1)){
            al.add(i);
            all.add(al);
        } 
    }
    return all;       
}

 

例题: 括号匹配，给定字符串，输出括号是否匹配，例子如下
"()" yes
")(" no
"(abcd(e)" no
"(a)(b)" yes

class test{
    
    public static boolean isVaild(String str, int pos, int nOpen){
        if(pos == str.length()) 
            return nOpen==0;
        if(str.charAt(pos)=='(')
            nOpen++;
        else if(str.charAt(pos)==')')
            nOpen--;
        if(nOpen < 0)
            return false;
        return isVaild(str,pos+1,nOpen);
    }
    
    public static void main(String []argus){
        
        String str = "(a)(b))";
        System.out.print( isVaild(str,0,0) );
        return;
    }
    
}

实际上就是为了要一个 最后的return.