2020/4/7java面试刷题

最新推荐文章于 2023-03-28 09:41:42 发布

ThestaRY777

最新推荐文章于 2023-03-28 09:41:42 发布

阅读量1.2k

点赞数 4

分类专栏：日常刷题文章标签： java 面试

本文链接：https://blog.csdn.net/weixin_43838446/article/details/105376160

版权

日常刷题专栏收录该内容

4 篇文章 0 订阅

订阅专栏

每日练习

计算机网络

对于用交换机互连的没有划分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();
        }

    }