豌豆荚面试题

/*
第一题：
给一棵排序二叉树，请按照类先序序遍历的顺序打印这棵树：
例如：


    5
  /   \
3     7
 \     /  \
  4  6    8


打印结果：
5 3 4 3 5 7 6 7 8 7 5 
*/


public void main(String[] args){
    Tree node = ...
    PreOrder(node);
}


public static void PreOrder(Tree node){
    if(node == null){
        return;
    }
    System.out.print(node.get(data)+" ");
    PreOrder(node.getLiftChild());
    if(node.getLiftChild()!=null){
        System.out.print(node.get(data)+" ");
    }
    PreOrder(node.getRightChild());
    if(node.getRightChild()!=null){
        System.out.print(node.get(data)+" ");
    }
   
    
}

/*
第二题：
给两个递增的整数数组 A 和 B，长度分别为 n 和 m。找出这两个数组中第 K 小的数。
例如：A = [1，2， 4， 8， 10]， B = [2, 3, 4, 5], K = 4。第 K 小的数是 3。
*/

public int sort(int[] a,int[] b,int K){
    if(a.length + b.length < K) return -1;
    int i = 0;
    int j = 0;
    for(;K>1;K--){
        if(a[i]>b[j] && j <b.length) j++;
        else if(a[i]<=b[j] && i<a.length) i++;
        else break;
    }
    if(K==1){
        return a[i]>b[j]?b[j]:a[i];
    }else{
        if(i == a.length) {
            return a[i+K]
        }else{
            return b[j+K];
        }
    }
}

网上的算法，二分。比较好，复杂度求解

//Notice ： K > 0  
int FindKthElm(int A[], int aBeg, int aEnd, int B[], int bBeg, int bEnd, int k)  
{  
    if (aBeg > aEnd)  
    {  
        return B[bBeg + k - 1];  
    }  
    if (bBeg > bEnd)  
    {  
        return A[aBeg + k - 1];  
    }  
      
    //取中间位置  
    int aMid = aBeg + (aEnd - aBeg)/2;    
    int bMid = bBeg + (bEnd - bBeg)/2;  
      
    //从A和B的开始位置到两个数组中间位置的元素个数  
    int halfLen = aMid - aBeg + bMid - bBeg + 2;  
      
    if (A[aMid] < B[bMid])  
    {  
        if (halfLen > k)  
        {  
            // 此时在合并的数组中A[aBeg...aMid]和元素一定在B[bMid]的左侧，  
            // 即此时第k大的元素一定比B[bMid]这个元素小（严格来说不大于）  
            // 故以后没有必要搜索 B[bMid...bEnd]这些元素  
            return FindKthElm(A, aBeg, aEnd, B, bBeg, bMid - 1, k);  
        }  
        else  
        {  
            // 此时在合并的数组中A[aBeg...aMid]元素一定在B[bMid]的左侧，  
            // 所以前K个元素中一定包含A[aBeg...aMid]（可以使用反证法来证明这点）。  
            // 但是无法判断A[amid+1...aEnd]与B[bBeg...bEnd]之间的关系，帮需要对他们进行判断  
            // 此时K就剩下除去A[aBeg...aMid]这些元素，个数为k - (aMid - aBeg + 1)  
            return FindKthElm(A, aMid + 1, aEnd, B, bBeg, bEnd, k - (aMid - aBeg + 1));  
        }  
    }  
    else  
    {  
        //注释与上面相似  
        if (halfLen > k)  
        {  
            return FindKthElm(A, aBeg, aMid - 1, B, bBeg, bEnd, k);  
        }  
        else  
        {  
            return FindKthElm(A, aBeg, aEnd, B, bMid + 1, bEnd, k - (bMid - bBeg + 1));  
        }  
    }  
}