10道騰訊C++/Java筆試真題你能做對幾道？3道就贏了80%的競爭者（含答案）

整理了幾道騰訊真題，來試試自己水平有多厲害吧，每題還有答案和詳細解答哦，

1、下列哪些可以用于Linux行程間通訊?

A：UNIX套接字 B：信號量 C：無名管道 D：檔案鎖 E：共享記憶體

Linux行程通信六大方式：
1、管道及(pipe)有名管道
2、信號（signal）                
3、報文佇列
4、共享記憶體
5、信號量(semaphore)
6、套接字（socket）
答案：ABCDE，

2、Java語言中，如果"xyz"沒有被創建過，String s =new String(“xyz”);創建了幾個String Object？

A：1 B：2 C：3 D：4

對于這句代碼，可以分為兩個程序：1、首先JVM 在字串常量池內里查找是否包含字串"xyz"；如果存在的話，則進入第二步；否則，創建新的 String 物件，并放到字串常量池里面，2、因為new String（“xyz”），所有會在堆里面創建 String 物件，參考的常量池的“xyz”，答案：B，

3、NumberList是一個順序容器，以下代碼執行后，NumberList里的元素依次為：

	List<int> NubmerList = new List<int>(){2,4,1,3,5}; 
	for(int i = 0 ; i<NumberList.Count; i++){
   		 int v = NumberList[i];
		   if(v%2 ==0)  {
		    NumberList.Remove(v); //洗掉的是元素，而非下標
		   }  
    }

A：2,4,1,3,5 B：2,1,3,5 C：4,1,3,5 D：1,3,5

因為NumberList是順序容器，第一次回圈之后洗掉元素2，容器中2后面的所有元素需要向前移動一個位置，即{4,1,3,5}，而第二次回圈判斷的是i=1位置的元素，并沒有對4進行操作，所以4并沒有被洗掉，所以答案選C，

4、關于多執行緒和多行程編程，下面描述正確的是（）:

A：多行程里，子行程可獲得父行程的所有堆和堆疊的資料；而執行緒會與同行程的其他執行緒共享資料，擁有自己的堆疊空間，
B：執行緒因為有自己的獨立堆疊空間且共享資料，所以執行的開銷相對較大，同時不利于資源管理和保護，
C：執行緒的通信速度更快，切換更快，因為他們在同一地址空間內，
D：執行緒使用公共變數/記憶體時需要使用同步機制，因為他們在同一地址空間內，
E：因為在多執行緒里，每個子行程有自己的地址空間，因此相互之間通信時，執行緒不如行程靈活和方便，

子行程是父行程的復制品，可以獲得父行程的資料空間、堆和堆疊，相對行程而言，執行緒擁有自己的堆疊空間和獨立的執行序列，但它可以與同行程的其他執行緒共享資料，答案：ACD，

5、在Windows編程中下面的說法正確的是:

A：兩個視窗,他們的視窗句柄可以是相同的
B：兩個視窗,他們的處理函式可以是相同的
C：兩個視窗,他們的視窗句柄和視窗處理函式都不可以相同

視窗句柄就相當于一個身份證，如果兩個視窗的句柄相同的話，就會出現訊息不知道傳給哪個視窗的問題，答案：B，

6、輸入一個鏈表，將鏈表反轉后，輸出新鏈表，
例如：輸入{1,2,3}
回傳值{3,2,1}

public class Solution {
    public ListNode ReverseList(ListNode head) {
         if(head==null)
         {
             return null;
         }
        ListNode second=head.next;
        head.next=null;
        ListNode three=null;
        while(second!=null)
        {
            three=second.next;
            second.next=head;
            head=second;
            second=three;
        }
        return head;
    }
}

7、一只青蛙一次可以跳上1級臺階，也可以跳上2級，求該青蛙跳上一個n級的臺階總共有多少種跳法（先后次序不同算不同的結果），

public class Solution {
    public int JumpFloor(int target) {
        int[] dp=new int[target+1];
        dp[0]=1;
        dp[1]=1;
      
        for(int i=2; i<dp.length; i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[target];
    }
}

8、給定一個陣列，找出其中最小的K個數，例如陣列元素是4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4，如果K>陣列的長度，那么回傳一個空的陣列，
示例：輸入[4,5,1,6,2,7,3,8],4
回傳值[1,2,3,4]

import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        if(k>input.length)
            return list;
        for(int n = 0;n < k;n++){//冒泡排序，只找到k個小的就行，
            for(int i = 0;i < input.length-n-1;i++){
                if(input[i] < input[i+1]){//把最小的先找到，即把小的放在后面，
                    int temp = input[i];
                    input[i] = input[i+1];
                    input[i+1] = temp;
                }
            }
            list.add(input[input.length-n-1]);//把后面的即小的放在陣列里，
        }
        return list;
    }
}

9、給定兩個字串str1和str2，輸出兩個字串的最長公共子串題目，保證str1和str2的最長公共子串存在且唯一，
示例：輸入“1AB2345CD”，“12345EF”
回傳值：“2345”

import java.util.*;
 
 
public class Solution {
    /**
     * longest common substring
     * @param str1 string字串 the string
     * @param str2 string字串 the string
     * @return string字串
     */
    public String LCS (String str1, String str2) {
        String result = "";
        int start = 0;
        int end = 1;
        while(end<=str2.length()){
            String subStr = str2.substring(start,end);
            if(str1.contains(subStr)){
                result = subStr;
            }else{
                start++;
            }
            end++;
        }
        return result;
    }
}

10、輸入一個字串,按字典序列印出該字串中字符的所有排列，例如輸入字串abc,則按字典序列印出由字符a,b,c所能排列出來的所有字串abc,acb,bac,bca,cab和cba，
示例：輸入“ab”
回傳值：[“ab”,ba]

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;   
//思路：第一步：將輸入的字串中第一個字符與后面每一個字符依次進行比較，若二者不同，則交換位置，第一個位置的字符完成，（第一步的結果是得到若干個“第一個字符不同”的字串），
//第二步：保持第一個字符不動，從第二個位置開始依次跟后面的字符進行比較，不同則交換，第二個位置的字符也確定了，（第二步的結果是得到若干'前兩個字符不同'的字串），
//依次類推.....直到對最后一個位置的字符確定時，按字典排序輸出所有字串即可，
//每一步的操作相同，所以可用遞回解決， 
public class Main{
    public static ArrayList arraylist = new ArrayList();
    private static HashSet hashset = new HashSet();
    private static void swap(char[] str,int i,int j ) {
        char temp = str[i];
        str[i] = str[j];
        str[j] = temp;
    }
   
    public static void permutation(char[] str,int start,int length) {
           
        //遞回出口，最后只有一個字符，不需要交換
        if(start == length-1) {
            hashset.add("\""+String.valueOf(str)+"\"");
        }else {
            for(int j=start;j<length;j++) {
                if(str[start] == str[j] && start!=j) {
                    continue;
                }
                swap(str,j,start);
                //確定一個在start位置的字符，再遞回去判斷后面start+1位置，該放哪個字符
                permutation(str, start+1, length);
                //換回來，以便往后判斷是否需要跟start位置交換
                swap(str,j,start);
            }
        }
    }
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String input;
        scan.useDelimiter("\r\n");
        scan.useDelimiter("\n");
        while(scan.hasNext()) {
            input = scan.next();
            permutation(input.toCharArray(),0,input.length());
            if ("[]".equals(hashset.toString())){//空字串
                System.out.println("[]");
            }else {
                Iterator iterator = hashset.iterator();
                while(iterator.hasNext()) {
                    arraylist.add(iterator.next());
                }
                Collections.sort(arraylist);
                //arraylist的toString()方法會帶有空格，要替換掉
                System.out.println(arraylist.toString().replace(", ",","));
            }
            hashset.clear();
            arraylist.clear();
        }
    }
}

上面的筆試題你做對了幾道？如果你覺得看得不過癮，關注我，后續會給同學們分享更多大廠筆試真題，

xDroid——讓安卓應用運行在Linux平臺上