1、给一个数组a[n],去掉数组小于k的值，并保持原来的相互顺序？ a[] = {3,7，4，1,2,5}, k = 3 ,结果返回{3,7,4,5}；

vector<int> resovle(int a[],int n,int k){
        vector<int> ans;
    for(int i=0;i<n;i++){
        if(a[i]>=k){
            ans.push_back(a[i]);
        }
    }
    return ans;
}

void resovle(int a[],int n,int k){
        int num=0;
    for(int i=0;i<n;i++){
            if(a[i]>=k){
            a[num++]=a[i];
        }
    }
}

2、非递归深度遍历一颗二叉树的深度？
写了一个递归的，非递归的没搞出来

int dfs(TreeNode* root){
    if(root){
      int ldep=dfs(root->left);
    int rdep=dfs(root->right);
    return max(ldep,rdep)+1;
  }
  return 0;
}
参考了一片非递归深度遍历，核心就是栈，先入右孩子，再入左孩子，刚刚好可以深度遍历

   /**
     * 深度优先遍历，相当于先根遍历
     * 采用非递归实现
     * 需要辅助数据结构：栈
     */
    public void depthOrderTraversal(){
        if(root==null){
            System.out.println("empty tree");
            return;
        }       
        ArrayDeque<TreeNode> stack=new ArrayDeque<TreeNode>();
        stack.push(root);       
        while(stack.isEmpty()==false){
            TreeNode node=stack.pop();
            System.out.print(node.value+"    ");
            if(node.right!=null){
                stack.push(node.right);#####先入右子树
            }
            if(node.left!=null){
                stack.push(node.left);#####后入左子树
            }           
        }
        System.out.print("\n");

原文链接：https://blog.csdn.net/lznsay/article/details/78717117

3、给予n个桶，每个桶中有不同质量的球m个, 在每个桶里拿一个球出来，这n个球的总质量为t,请问有多少种方法？

const max_n=1000;
vector<int>T[max_n];
int ans;
void dfs(int index,int sum,int n){
  if(index==n-1&&sum==t)ans++;
  for(int i=0;i<T[index].size();i++){
    if(sum+T[index][i]<t){
      dfs(index+1,sum+T[index][i],n);
    }
  }
}

int main(){
  ans=0;
  dfs(0,0,n);
  return 0;
}

4.问一下项目，仔细说了一下监控方面的事情。
5.了解了一下他们做的事情，车联网相关的事情，然后阿里这边体系一般3-4轮面试。