腾讯Android客户端开发 2020暑期实习一面

面试时间：1小时25分钟左右

面试官一上来就给我四道算法题，算法题没记下题目，只能自己编下题目，应该能明白大概意思。而且他每道题写完就会问一下这道题时间复杂度是多少。算法题先放后面吧，先说一下其他的题目。

算法题一做完就开始说自己写过的项目，自己挑一个出来讲，然后再讲讲自己遇到的问题，这部分略过。。。

我这里面所有的回答都是我当时面试时的回答，不保证完全正确，但也七七八八吧。。。

个人项目

其中我讲到我的项目有步数统计，并且会传到服务端，然后他就顺着这个问题来问我。

1. 如果有两台手机同时进行运动，那么步数怎么统计？答：只记录最高并且结束时间最晚的。
2. 如果先拿一台手机运动，然后放下，再拿另一台手机运动，怎么统计？答：先给设备记录活动态或者静止态，如果是活动态时记录最开始运动的时间和最后运动时间，并且把它上传，若静止了代表不动了，那就不处理。服务端将通过活动开始时间和活动结束时间来进行步数的整合

Java

1. 垃圾回收机制是怎样的？答：两种方法，四种引用。。。
2. 总结一下垃圾回收的规则。答：用不到的会被引用，地址丢失等的也会被回收
3. 回收的时机是什么时候？答：内存不足的时候，方法等执行结束的时候。
4. 有没有没被引用，但也不能回收的情况？答：数组开多了的空间暂时不会用到也不能回收（面试官说我说的没错，然后补充了一点，A引用B，B引用A，但是这个整体没有被外界引用）
5. 遇到第4点面试官说的相互引用的这种情况要怎么处理？（这个没答出来，搜了下答案是通过‘gc roots‘去判断是否可达）
6. 线程跟进程的区别？略

算法题：

1.有n个数，怎么找到最大的有重复的数？如1 2 2 3 3 4，最大的有重复的就是3。(这道题直接回答不用写代码)答：用计数排序，并维护一个set，通过set来遍历计数排序，如1 2 2 3 3 100，那么set里就是1 2 3 100，那么计数排序就在100,3,2,1中查询。时间复杂度是O(n^2)。

2.小明发明了自增数组，数组中任意的数都能+1，现在要保证数组中每一个数都是唯一的，请问需要几步。时间复杂度尽量小

输入：1 2 2 3 5

输出：2

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int main() {
    int a[10000]={1,2,2,3,5};
    int num[1000];
    int ans=0;
    memset(num,0,sizeof(num));
    for(int i =0;i<5;i++){
        num[a[i]]++;
    }
    for(int i=0;i<5;i++){
        if(num[i]>1){
            int d=i+1;
            while(1){
                if(num[d]==0){
                    num[d]++;
                    num[i]--;
                    ans+=d-i;
                    break;
                }
                d++;
                
            }
        }
    }
    cout<<ans<<endl;
    //int a;
    //cin >> a;
}

3.现在有一串由‘N’和‘Q’组成的字符串，小明不喜欢‘NQ’，他想把字符串中的‘NQ’去掉，去掉一次后新的字符串也去掉‘NQ’，请问最后还剩下多少个字符。

输入：Q N Q Q N N

输出：4

#include <iostream>
#include<stack>
using namespace std;
int main() {
    //int a;
    //cin >> a;
    char a[100]={'Q','N','Q','Q','N','N'};
    stack<int>s;
    for(int i=0;i<6;i++){
        if(i==0){
            s.push(a[i]);
        }
        else{
            if(a[i]=='Q' && s.top()=='N'){
                s.pop();
            }else{
                s.push(a[i]);
            }
        }
    }
    int ans=0;
    while(!s.empty()){
        s.pop();
        ans++;
    }
    cout << ans << endl;
}

4.小明去到游乐场打气球，如果把所有颜色的气球都打掉了，就能获得奖励。气球将会有m个颜色（1.2.3...m），小明将会从左到右连续打出n枪，求最少需要打出几枪才能命中所有颜色的气球。

输入：假设有5种颜色的气球，分别为1,2,3,4,5，现在有一个气球场的气球为{2,5,3,1,3,2,4,1,0,5,4,3}

输出：6

解析：6是因为连续的5 3 1 3 2 4，能满足5个颜色都打完

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int a[10000]={2,5,3,1,3,2,4,1,0,5,4,3};
int num[5];
int isSix(int l,int r){
    memset(num,0,sizeof(num));
    for(int i=l;i<=r;i++){
        num[a[i]]++;
    }
    int mark=1;
    for(int i=0;i<5;i++){
        if(num[i]==0){
            mark=0;
            break;
        }
    }
    if(mark==1){
        return 1;
    }else{
        return 0;
    }
}
int main() {
    //int a;
    //cin >> a;
    int minn=0x3f3f3f3f;
    
    for(int i=0;i<12;i++){
        for(int j=i+1;j<12;j++){
            if(isSix(i,j)==1){
                if(minn>(i-j)){
                    minn=j-i;
                }
            }
        }
    }
    cout << minn << endl;
}

 

5.在不允许新增内存的情况下，把arrayA数组和arrayB数组合并进arrayA中，使返回的数组是递增的。保证arrayA的内存空间足够放下arrayB

void mergeArray(int arrayA[], int lengthA, int arrayB[], int lengthB) {}

输入：arrayA={1,2,3,4} arrarB={2,3,5,8}

输出：{1,2,2,3,3,4,5,8}

#include <iostream>
using namespace std;
void mergeArray(int arrayA[], int lengthA, int arrayB[], int lengthB) {
    int d=0;
    int i=0;
    int nowAlen=lengthA;
    for(;i<lengthA;i++){
        while(arrayB[d]<=arrayA[i]){
            for(int j=nowAlen++;j>=i;j--){
                arrayA[j+1]=arrayA[j];
            }
            arrayA[i]=arrayB[d];
            d++;
        }
    }
    
    for(int i=d;i<lengthB;i++){
        arrayA[nowAlen++]=arrayB[i];
    }
    
    for(int j=0;j<lengthA+lengthB;j++){
        cout<<arrayA[j]<<" ";
    }
    cout<<endl;
}
int main() {
    int arrayA[10]={1,2,3,4};
    int lena=4;
    int arrayB[10]={2,3,5,8};
    int lenb=4;
    mergeArray(arrayA,lena,arrayB,lenb);
}