2020/4/7java面試刷題

每日練習

計算機網絡

對於用交換機互連的沒有劃分VLAN的交換式以太網，哪種描述是錯誤的？()
正確答案: B 你的答案: C (錯誤)
交換機將信息幀只發送給目的端口。
交換機中所有端口屬於一個衝突域。
交換機中所有端口屬於一個廣播域。
交換機各端口可以併發工作。

下列關於曼徹斯特編碼正確的描述是()。
正確答案: B 你的答案: C (錯誤)
曼徹斯特編碼是自含時鐘編碼的模擬數據編碼
這種編碼不會帶來直流分量
每位的中間跳變表示信號的取值爲零
曼徹斯特編碼前後的比特率不變

曼徹斯特編碼，常用於局域網傳輸。曼徹斯特編碼將時鐘和數據包含在數據流中，在傳輸代碼信息的同時，也將時鐘同步信號一起傳輸到對方，每位編碼中有一跳變，不存在直流分量，因此具有自同步能力和良好的抗干擾性能。但每一個碼元都被調成兩個電平，所以數據傳輸速率數據傳輸速率)只有調製速率的1/2。

1是由低變高，0由高變低。

ZigBee 網絡拓撲類型包括（）。

正確答案: A B D 你的答案: A B C D (錯誤)
星型
網狀
環形
樹形

在萬物互聯的背景下，zigbee網絡應用越加廣泛，zigbee技術具有強大的組網能力，可以形成星型、樹型和網狀網，三種zigbee網絡結構各有優勢，可以根據實際項目需要來選擇合適的zigbee網絡結構。

zigbee作爲一種短距離、低功耗、低數據傳輸速率的無線網絡技術，它是介於無線標記技術和藍牙之間的技術方案，在傳感器網絡等領域應用非常廣泛，這得益於它強大的組網能力，可以形成星型、樹型和網狀網三種zigbee網絡，可以根據實際項目需要來選擇合適的zigbee網絡結構，三種zigbee網絡結構各有優勢。

數據庫

對於滿足SQL92標準的SQL語句:

select foo,count(foo)from pokes where foo>10group by foo having count (*)>5 order by foo 

其執行順序應該是?
正確答案: A 你的答案: A (正確)
FROM->WHERE->GROUP BY->HAVING->SELECT->ORDER BY
FROM->GROUP BY->WHERE->HAVING->SELECT->ORDER BY
FROM->WHERE->GROUP BY->HAVING->ORDER BY->SELECT
FROM->WHERE->ORDER BY->GROUP BY->HAVING->SELECT

1、from子句組裝來自不同數據源的數據；
2、where子句基於指定的條件對記錄行進行篩選；
3、group by子句將數據劃分爲多個分組；
4、使用聚集函數進行計算；
5、使用having子句篩選分組；
6、select計算所有的表達式；
7、使用order by對結果集進行排序。

spring的PROPAGATION_REQUIRES_NEW事務，下面哪些說法是正確的？
正確答案: B 你的答案: A (錯誤)
內部事務回滾會導致外部事務回滾
內部事務回滾了，外部事務仍然可以提交
外部事務回滾了，內部事務也跟着回滾
外部事務回滾了，內部事務仍然可以提交

PROPAGATION_REQUIRED如果當前沒有事務，就新建一個事務，如果已經存在一個事務中，加入到這個事務中。這是最常見的選擇。

PROPAGATION_SUPPORTS支持當前事務，如果當前沒有事務，就以非事務方式執行。

PROPAGATION_MANDATORY使用當前的事務，如果當前沒有事務，就拋出異常。

PROPAGATION_REQUIRES_NEW新建事務，如果當前存在事務，把當前事務掛起。

PROPAGATION_NOT_SUPPORTED以非事務方式執行操作，如果當前存在事務，就把當前事務掛起。

PROPAGATION_NEVER以非事務方式執行，如果當前存在事務，則拋出異常。

PROPAGATION_NESTED如果當前存在事務，則在嵌套事務內執行。如果當前沒有事務，則執行與PROPAGATION_REQUIRED類似的操作。

Access支持的查詢類型有（）。
正確答案: A 你的答案: C (錯誤)
選擇查詢、交叉式表查詢、參數查詢、SQL查詢和操作作查詢
基本查詢、選擇查詢、參數查詢、SQL查詢和操作查詢
多表查詢、單表查詢、交叉表查詢、參數查詢操作作查詢
選擇查詢、統計查詢、參數查詢、SQL查詢和操作作查詢

數據結構

判斷一個單向鏈表中是否存在環的最佳方法是（）
正確答案: B 你的答案: C (錯誤)
兩重遍歷
快慢指針
路徑記錄
哈希表輔助

讓快慢指針都從鏈表表頭開始，快指針一次向前移動連個位置，慢指針每次向前移動一個位置。如果快指針到達了NULL，說明不存在環，但如果快指針追上了慢指針，說明存在環。

下面哪個不是用來解決哈希表衝突的開放地址法？
正確答案: C 你的答案: C (正確)
線性探測法
線性補償探測法
拉鍊探測法
隨機探測法

處理hash衝突有：開放定址法（線性探測法、線性補償探測法、隨機探測法），拉鍊法，建立公共溢出區，再散列法

給定一個整數sum,從有N個有序元素的數組中尋找元素a,b,使得a+b的結果最接近sum,最快的平均時間複雜度是：
正確答案: A 你的答案: B (錯誤)
O(n)
O(nlogn)
O(n^2)
O(logn)

設置兩個指針，指向首、尾兩元素。如果和大於sum就將後端指針左移，如果和小於sum，就將前端指針右移！

可唯一確定一棵二叉樹的是（ ）

正確答案: A C 你的答案: A B C (錯誤)
給定一棵二叉樹的後序和中序遍歷序列
給定一棵二叉樹的先序和後序遍歷序列
給定一棵二叉樹的先序和中序遍歷序列
給定先序、中序和後序遍歷序列中的任意一個即可

已知中序遍歷、以及前、後、層其中一種均可確定一顆二叉樹

操作系統

分治法的設計思想是將一個難以直接解決的大問題分割成規模較小的子問題，分別解決子問題，最後將子問題的解組合起來形成原問題的解。這要求原問題和子問題（ ）。
正確答案: C 你的答案: B (錯誤)
問題規模相同，問題性質相同
問題規模相同，問題性質不同
問題規模不同，問題性質相同
問題規模不同，問題性質不同

關鍵詞：分割（大問題分割成規模較小的子問題） 組合（子問題的解組合起來形成原問題的解）

在操作系統中，用戶程序申請使用 I/O 設備時，通常採用（ ）。
正確答案: B 你的答案: A (錯誤)
物理設備名
邏輯設備名
虛擬設備名
獨佔設備名

爲了提高操作系統的可適應性和可擴展性，在現代操作系統中都實現了設備獨立性，即在應用程序中，使用邏輯設備名稱來請求使用某類設備；而系統在實際執行時， 還必須使用物理設備名稱。 所以是邏輯設備名

編譯內核時，可以使用哪些命令對內核進行配置？多選
正確答案: A B C D 你的答案: D (錯誤)
make config
make menuconfig
make oldconfig
make xconfig

常見的頁面調度算法有哪些？
正確答案: A B C D 你的答案: B C (錯誤)
隨機算法rand
先進先出調度算法
最近最少調度算法LRU
最近最不常用調度算法LFU

編程 LeetCode

1.二維數組中的查找

在一個二維數組中（每個一維數組的長度相同），每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。

最容易理解的方法：

public class Solution {
    public boolean Find(int target, int [][] array) {
        for(int row[] : array){
            for(int item : row){
                if(item == target){
                    return true;
                }
                if(item > target){
                    break;
                }
            }
        }
        return false;
    }
}

巧妙一點的方法，從左下角開始，如果該數大於target，往上走，如果該數小於target，往右走：

public class Solution {
    public boolean Find(int target, int [][] array) {
        int i = array.length-1;
        int j = 0;
        for(;i>=0 && j<array[0].length;){
            if(array[i][j]>target){
                i--;
            }else if(array[i][j]<target){
                j++;
            }else{
                return true;
            }
        }
        return false;
    }
}

2.數組操作

輸入一個無序整數數組，調整數組中數字的順序， 所有偶數位於數組的前半部分，使得所有奇數位於數組的後半部分。
要求時間複雜度爲O(n)。

輸入描述:

給定無序數組。
長度不超過1000000。

輸出描述:

所有偶數位於數組的前半部分，所有奇數位於數組的後半部分。
如果有多個答案可以輸出任意一個正確答案。

示例
輸入
2 4 5 7 8 1
輸出
2 4 8 7 5 1

import java.util.Arrays;

public class ArrayDivide {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 4, 5, 7, 8, 1,12};
        method(arr);
        method2(arr);
    }
    
    \\方法一：藉助一個緩存的數組，和緩存數組的頭尾指針實現，空間複雜度O(n+2)
    public static void method(int[] array){
        int head = 0;
        int rear = array.length-1;
        int[] res = new int[array.length];
        for(int item : array){
            if(item % 2 == 0){
                res[head] = item;
                head++;
            }else{
                res[rear] = item;
                rear--;
            }
        }
        System.out.println(Arrays.toString(res));

    }
    
	\\方法二，藉助頭尾指針同時向中間移動，空間複雜度爲O(1+2)
    public static void method2(int[] array){
        int head = 0;
        int rear = array.length-1;
        while(head != rear){
            \\頭、尾指針元素分別爲奇、偶時元素互換元素，並且向中間移動
            if(array[head] % 2 != 0 && array[rear] % 2 == 0){
                int temp = array[head];
                array[head] = array[rear];
                array[rear] = temp;
                head++;
                rear--;
                break;
            }else if(array[head] % 2 == 0){
                head++;
            }else if(array[rear] % 2 != 0){
                rear--;
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

3.羅馬數字轉整數

羅馬數字包含以下七種字符: I， V， X， L，C，D 和 M。

字符 數值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 羅馬數字 2 寫做 II ，即爲兩個並列的 1。12 寫做 XII ，即爲 X + II 。 27 寫做 XXVII, 即爲 XX + V + II 。

通常情況下，羅馬數字中小的數字在大的數字的右邊。但也存在特例，例如 4 不寫做 IIII，而是 IV。數字 1 在數字 5 的左邊，所表示的數等於大數 5 減小數 1 得到的數值 4 。同樣地，數字 9 表示爲 IX。這個特殊的規則只適用於以下六種情況：

I 可以放在 V (5) 和 X (10) 的左邊，來表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左邊，來表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左邊，來表示 400 和 900。
給定一個羅馬數字，將其轉換成整數。輸入確保在 1 到 3999 的範圍內。

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/roman-to-integer

class Solution {
    public int romanToInt(String s) {
        int value = 0;
        Map<String,Integer> map = new HashMap<>();
        map.put("I",1);
        map.put("V",5);
        map.put("X",10);
        map.put("L",50);
        map.put("C",100);
        map.put("D",500);
        map.put("M",1000);
        String[] arr = s.split("");
        int len = arr.length;
        for(int i=0; i<len; i++){
            if(i<len-1 && map.get(arr[i])<map.get(arr[i+1])){
                value -= map.get(arr[i]);
            }else{
                value += map.get(arr[i]);
            }
        }
        return value;
    }
}

用charAt的話，map去get的時候會空指針異常

4.旋轉矩陣

給你一幅由 N × N 矩陣表示的圖像，其中每個像素的大小爲 4 字節。請你設計一種算法，將圖像旋轉 90 度。

不佔用額外內存空間能否做到？

示例 1:

給定 matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

原地旋轉輸入矩陣，使其變爲:
[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]

來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/rotate-matrix-lcci

核心思想：先進行轉置，再對每一行以中心爲參照，首尾互換：

class Solution {
    public void rotate(int[][] matrix) {
        int temp;
        for(int i=0; i<matrix.length; i++){
            for(int j=i; j<matrix[i].length; j++){
                temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
        for(int i=0; i<matrix.length; i++){
            int len = matrix[i].length;
            for(int j=0; j<len/2; j++){
                temp = matrix[i][j];
                matrix[i][j] = matrix[i][len-1-j];
                matrix[i][len-1-j] = temp;
            }
        }
    }
}

5.稀疏矩陣

實現如圖所示：

import java.io.*;

public class SparseArray {
    public static void main(String[] args) throws IOException {
        int[][] originArr = new int[11][11];
        originArr[1][2] = 1;
        originArr[2][3] = 2;
        System.out.println("原始數組：");
        forEach(originArr);

        int[][] sparseArr = toSparseArr(originArr);
        System.out.println("稀疏數組：");
        forEach(sparseArr);
        System.out.println("迴轉原始數組：");
        forEach(toOriginArr(sparseArr));
    }
    
    public static int[][] toSparseArr(int[][] arr){
        int sum = 0;
        for (int[] row : arr) {
            for (int i : row) {
                if(i != 0){
                    sum++;
                }
            }
        }
        int[][] res = new int[sum+1][3];
        res[0][0] = arr.length;
        res[0][1] = arr[0].length;
        res[0][2] = sum;
        int resRow = 1;

        for (int row=0; row<arr.length; row++){
            for (int col=0; col<arr[row].length; col++){
                if (arr[row][col] != 0){
                    res[resRow][0] = row;
                    res[resRow][1] = col;
                    res[resRow][2] = arr[row][col];
                    resRow++;
                }
            }
        }
        return res;
    }

    public static int[][] toOriginArr(int[][] sparseArr){
        int[][] originarr = new int[sparseArr[0][0]][sparseArr[0][1]];
        int sparseRow = 1;
        for (int i=0; i<sparseArr[0][2]; i++){
            originarr[sparseArr[sparseRow][0]][sparseArr[sparseRow][1]] = sparseArr[sparseRow][2];
            sparseRow++;
        }
        return originarr;
    }

    private static void forEach(int[][] arr){
        for (int[] row : arr) {
            for (int i : row) {
                System.out.printf("%d\t",i);
            }
            System.out.println();
        }

    }