第二章面试需要的基础知识

Posted 2020-12-04 sungc

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了第二章面试需要的基础知识相关的知识，希望对你有一定的参考价值。

2.1 面试官谈基础知识

基础很重要
算法、复杂的
编程能力
数据结构

2.2 编程语言

程序员写代码总是基于某一种编程语言，因此技术面试的时候直接或者间接都会涉及至少一种编程语言。在面试的过程中，面试官要么直接问语言的语法，要么让应聘者用-~种编程语言写代码解决一个问题，通过写出的代码来判断应聘者对他使用的语言的掌握程度。现在流行的编程语言很多，不同公司开发用的语言也不尽相同。做底层开发比如经常写驱动的人更习惯用C, Linux下有很多程序员用C++开发应用程序，基于Windows的C#项目已经越来越多，跨平台开发的程序员则可能更喜欢Java,随着苹果iPad、iPhone 的热销已经有很多程序员投向了Objective C的阵营，同时还有很多人喜欢用脚本语言如Perl、Python 开发短小精致的小应用软件。因此，不同公司面试的时候对编程语言的要求也有所不同。每一种编程语言都可以写出一本大部头的书籍，本书限于篇幅不可能面面俱到。本书中所有代码都用C/C++/C#实现，下面简要介绍一些C++/C#常见的面试题。

面试题1:赋值运算符函数

题目：如下为类型CMyString的声明，请为该类型添加赋值运算符函数。
思路

将返回值类型声明为该类型的引用
把传入的参数类型声明为常量引用
释放实例自身已有的内存
判断传入的参数和当前的实例是不是同一个实例

不适用java

面试题2:实现Singleton模式

题目:设计一个类，我们只能生成该类的一个实例。

https://www.cnblogs.com/cielosun/p/6582333.html
1. 懒汉模式
public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){
}
public static SingletonDemo getInstance(){
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}
}
如上，通过提供一个静态的对象instance，利用private权限的构造方法和getInstance()方法来给予访问者一个单例。缺点是，没有考虑到线程安全，可能存在多个访问者同时访问，并同时构造了多个对象的问题。之所以叫做懒汉模式，主要是因为此种方法可以非常明显的lazy loading。针对懒汉模式线程不安全的问题，我们自然想到了，在getInstance()方法前加锁，于是就有了第二种实现。

2. 线程安全的懒汉模式

public class SingletonDemo {
private static SingletonDemo instance;
private SingletonDemo(){
}
public static synchronized SingletonDemo getInstance(){
if(instance==null){
instance=new SingletonDemo();
}
return instance;
}
}
然而并发其实是一种特殊情况，大多时候这个锁占用的额外资源都浪费了，这种打补丁方式写出来的结构效率很低。

3. 饿汉模式

public class SingletonDemo {
private static SingletonDemo instance=new SingletonDemo();
private SingletonDemo(){
}
public static SingletonDemo getInstance(){
return instance;
}
}
直接在运行这个类的时候进行一次loading，之后直接访问。显然，这种方法没有起到lazy loading的效果，考虑到前面提到的和静态类的对比，这种方法只比静态类多了一个内存常驻而已。

4. 静态类内部加载

public class SingletonDemo {
private static class SingletonHolder{
private static SingletonDemo instance=new SingletonDemo();
}
private SingletonDemo(){
System.out.println("Singleton has loaded");
}
public static SingletonDemo getInstance(){
return SingletonHolder.instance;
}
}
使用内部类的好处是，静态内部类不会在单例加载时就加载，而是在调用getInstance()方法时才进行加载，达到了类似懒汉模式的效果，而这种方法又是线程安全的。

2.3 数据结构

数据结构一直是技术面试的重点，大多数面试题都是围绕着数组、字符串、链表、树、栈及队列这几种常见的数据结构展开的，因此每一个应聘者都要熟练掌握这几种数据结构。

数组和字符串是两种最基本的数据结构，它们用连续内存分别存储数字和字符。链表和树是面试中出现频率最高的数据结构。由于操作链表和树需要操作大量的指针，应聘者在解决相关问题的时候-要留意代码的鲁棒性，否则容易出现程序崩溃的问题。是一个与递归紧密相关的数据结构，同样队列也与广度优先遍历算法紧密相关。深刻理解这两种数据结构能帮助我们解决很多算法问题。

2.3.1 数组

面试题3：二维数组中的查找

题目：在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路:从右上角或左下角开始找，逐行删除，或者用二分法查找
代码实现右上角开始实现

publicclassTestc {
publicstaticvoidmain(String[] args) {
int[][] arr= { { 1, 2, 8, 9 }, { 2, 4, 9, 12 }, { 4, 7, 10, 13 }, { 6, 8, 11, 15 } };
System.out.println(find(arr, 7));
}
publicstaticbooleanfind(int[][] array, inttarget) {
if(array== null) {
returnfalse;
}
introw= 0;
intcolumn= array[0].length- 1;
while(row< array.length&& column>= 0) {
if(array[row][column] == target) {
returntrue;
}
if(array[row][column] > target) {
column--;
} else{
row++;
}
}
returnfalse;
}
}

2.3.2 字符串

面试题4:替换空格

题目:请实现一个函数，把字符串中的每个空格替换成"%20"。例如输入“We are happy.",则输出“We%20are%20happy.”。
思路:从后往前复制，数组长度会增加，或使用StringBuilder、StringBuffer类，先遍历空格个数直接扩容
代码实现

publicclassTestc {
publicstaticvoidmain(String[] args) {
System.out.println(replaceSpace(newStringBuffer("We Are Happy.")));
}
publicstaticString replaceSpace(StringBuffer str) {
if(str== null)
returnnull;
StringBuilder sb= newStringBuilder();
for(inti= 0; i< str.length(); i++) {
if(String.valueOf(str.charAt(i)).equals(" ")) {
sb.append("%20");
} else{
sb.append(str.charAt(i));
}
}
returnString.valueOf(sb);
}
}

方法二

"We Are Happy.".replace(" ", "%20")

举一反三:
合并两个数组(包括字符串)时，如果从前往后复制每个数字(或字符)需要重复移动数字(或字符)多次，那么我们可以考虑从后往前复制，这样就能减少移动的次数，从而提高效率。

2.3.3 链表

我们说链表是一种动态数据结构，是因为在创建链表时，无须知道链

表的长度。当插入一一个结点时，我们只需要为新结点分配内存，然后调整指针的指向来确保新结点被链接到链表当中。内存分配不是在创建链表时.次性完成，而是每添加一个结点分配一次内存。由于没有闲置的内存，链表的空间效率比数组高。

面试题5:从尾到头打印链表

题目:输入一个链表的头结点，从尾到头反过来打印出每个结点的值。
面试小提示:在面试中如果我们打算修改输入的数据，最好先问面试官是不是允许做修改。
思路:借助栈实现，或使用递归的方法。
代码实现

publicArrayList<Integer> printListFromTailToHead(ListNodelistNode) {
ArrayList<Integer> list= newArrayList<>();
if(listNode== null)
returnlist;
Stack<ListNode> stack= newStack<>();
while(listNode!= null) {
stack.push(listNode);
listNode= listNode.next;
}
while(!stack.isEmpty()) {
list.add(stack.pop().val);
}
returnlist;
}

简单演示栈

publicclassTestc {
publicstaticvoidmain(String[] args) {
ArrayList<Integer> arr= newArrayList<Integer>();
arr.add(1);
arr.add(2);
arr.add(3);
arr.add(4);
arr.add(5);
printListFromTailToHead(arr);
}
publicstaticvoidprintListFromTailToHead(ArrayList<Integer> list) {
Stack<Integer> stack= newStack<Integer>();
for(Integer integer: list) {
stack.push(integer);
}
while(!stack.isEmpty()) {
System.out.println(stack.pop());
}
}
}

简单演示递归

publicclassTestc {
publicstaticvoidmain(String[] args) {
int[] arr= {1,2,3,4,5};
printListFromTailToHead(arr,0);
}
publicstaticvoidprintListFromTailToHead(int[] arr,intnum) {
if(arr.length> num){
printListFromTailToHead(arr,num+1);
System.out.println(arr[num]);
}
}
}

测试用例:

功能测试(输入的链表有多个结点，输入的链表只有一个结点)。
特殊输入测试(输入的链表头结点指针为NULL)。

本题考点:

考查对单项链表的理解和编程能力。
考查对循环、递归和栈3个相互关联的概念的理解。

2.3.4 树

树是一种在实际编程中经常遇到的数据结构。它的逻辑很简单:除了根结点之外每个结点只有一个父结点，根结点没有父结点;除了叶结点之外所有结点都有一个或多个子结点，叶结点没有子结点。父结点和子结点之间用指针链接。由于树的操作会涉及大量的指针，因此与树有关的面试题都不太容易。当面试官想考查应聘者在有复杂指针操作的情况下写代码的能力，他往往会想到用与树有关的面试题。

面试的时候提到的树，大部分都是二叉树。所谓二叉树是树的一种特殊结构，在二叉树中每个结点最多只能有两个子结点。在二叉树中最重要的操作莫过于遍历，即按照某一-顺序访问树中的所有结点。通常树有如下几种遍历方式:

前序遍历:先访问根结点，再访问左子结点，最后访问右子结点。图2.5中的二叉树的前序遍历的顺序是10、6、4、8、14、12、16。
中序遍历:先访问左子结点，再访问根结点，最后访问右子结点。图2.5中的二叉树的中序遍历的顺序是4、6、8、10、12、14、16。
后序遍历:先访问左子结点，再访问右子结点，最后访问根结点。图2.5中的二叉树的后序遍历的顺序是4、8、6、12、16、14、10。

面试题6:重建二叉树

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

思路:先找出根节点，然后利用递归方法构造二叉树
代码实现

classTreeNode {
intval;
TreeNode left;
TreeNode right;
TreeNode(intx) {
val= x;
}
}
publicclassTestc {
publicTreeNode reConstructBinaryTree(int[] pre, int[] in) {
if(pre== null|| in== null) {
returnnull;
}
if(pre.length== 0 || in.length== 0) {
returnnull;
}
if(pre.length!= in.length) {
returnnull;
}
TreeNode root= newTreeNode(pre[0]);
for(inti= 0; i< pre.length; i++) {
if(pre[0] == in[i]) {
root.left= reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i+ 1), Arrays.copyOfRange(in, 0, i));
root.right= reConstructBinaryTree(Arrays.copyOfRange(pre, i+ 1, pre.length),
Arrays.copyOfRange(in, i+ 1, in.length));
}
}
returnroot;
}
}

本题考点:

考查应聘者对二叉树的前序遍历、中序遍历的理解程度。只有对二叉树的不同遍历算法有了深刻的理解，应聘者才有可能在遍历序列中划分出左、右子树对应的子序列。考查应聘者分析复杂问题的能力。我们把构建二叉树的大问题分解成构建左、右子树的两个小问题。我们发现小问题和大问题在本质上是一致的，因此可以用递归的方式解决。

2.3.5 栈和队列

栈是一个非常常见的数据结构，它在计算机领域中被广泛应用，

比如操作系统会给每个线程创建-一个栈用来存储函数调用时各个函数的参数、返回地址及临时变量等。栈的特点是后进先出，即最后被压入(push)栈的元素会第一个被弹出(pop)。在面试题22“栈的压入、弹出序列”中，我们再详细分析进栈和出栈序列的特点。

通常栈是一“个不考虑排序的数据结构，我们需要O(n)时间才能找到栈中最大或者最小的元素。如果想要在O(1)时间内得到栈的最大或者最小值，我们需要对栈做特殊的设计，详见面试题21“包含min函数的栈”。

队列是另外一种很重要的数据结构。和栈不同的是，队列的特点是先进先出，即第一个进入队列的元素将会第一个出来。在2.3.4节介绍的树的宽度优先遍历算法中，我们在遍历某一层树的结点时，把结点的子结点放到一个队列里，以备下一层结点的遍历。详细的代码参见面试题23“从上到下遍历二叉树”。

栈和队列虽然是特点针锋相对的两个数据结构，但有意思的是它们却相互联系。请看面试题7“用两个栈实现队列”，同时读者也可以考患如何用两个队列实现栈。

面试题7:用两个栈实现队列

题目：用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。
思路：一个栈压入元素，而另一个栈作为缓冲，将栈1的元素出栈后压入栈2中。也可以将栈1中的最后一个元素直接出栈，而不用压入栈2中再出栈。
代码

publicclassTestc {
Stack<Integer> stack1= newStack<Integer>();
Stack<Integer> stack2= newStack<Integer>();
publicstaticvoidmain(String[] args) throwsException {
Testc t= newTestc();
t.push(1);
t.push(2);
System.out.println(t.pop());
t.push(3);
System.out.println(t.pop());
System.out.println(t.pop());
System.out.println(t.pop());
}
publicvoidpush(intnode) {
stack1.push(node);
}
publicintpop() throwsException {
if(stack1.isEmpty() && stack2.isEmpty()) {
thrownewRuntimeException("栈为空!");
}
if(stack2.isEmpty()) {
while(!stack1.isEmpty()) {
stack2.push(stack1.pop());
}
}
returnstack2.pop();
}
}

测试用例:

往空的队列里添加、删除元素。
往非空的队列里添加、
删除元素。
连续删除元素直至队列为空。

本题考点:

考查对栈和队列的理解。
考查写与模板相关的代码的能力。
考查分析复杂问题的能力。本题解法的代码虽然只有只有20几行
代码，但形成正确的思路却不容易。应聘者能否通过具体的例子分
析问题，通过画图的手段把抽象的问题形象化，从而解决这个相对
比较复杂的问题，是能否顺利通过面试的关键。

2.4 算法和数据操作

和数据结构一样，考查算法的面试题也备受面试官的青睐，其中排序和查找是面试时考查算法的重点。在准备面试的时候，我们应该重点掌握二分查找、归并排序和快速排序，做到能随时正确、完整地写出它们的代码。

有很多算法都可以用递归和循环两种不同的方式实现。通常基于递归的实现方法代码会比较简洁，但性能不如基于循环的实现方法。在面

试的时候，我们可以根据题目的特点，甚至可以和面试官讨论选择合适.的方法编程。

位运算可以看成是一- 类特殊的算法，它是把数字表示成二进制之后对0和1的操作。由于位运算的对象为二进制数字，所以不是很直观，但掌握它也不难，因为总共只有与、或、异或、左移和右移5种位运算。

2.4.1 查找和排序

查找和排序都是在程序设计中经常用到的算法。查找相对而言较为简

单，不外乎顺序查找、二分查找、哈希表查找和二叉排序树查找。在试

的时候，不管是用循环还是用递归，面试官都期待应聘者能够信手拈来写出完整正确的二分查找代码，否则可能连继续面试的兴趣都没有。

面试小提示:如果面试题是要求在排序的数组( 或者部分排序的数组)中查找一个数字或者统计某个数字出现的次数，我们都可以尝试用二分查找算法。

面试题8:旋转数组的最小数字

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE:给出的所有元素都大于0，若数组大小为0，请返回0
思路：
代码实现

publicclassTestc {
publicstaticvoidmain(String[] args) {
System.out.println(minNumberInRotateArray(newint[] { 1, 0, 1, 1, 1 }));
}
publicstaticintminNumberInRotateArray(int[] array) {
if(array== null|| array.length== 0)
return0;
intleft= 0;
intright= array.length- 1;
intmid= 0;
while(array[left] >= array[right]) {
if(right- left<= 1) {
mid= right;
break;
}
mid= (left+ right) / 2;
if(array[left] == array[mid] && array[mid] == array[right]) {
if(array[left+ 1] != array[right- 1]) {
intreslut= array[left];
for(inti= left+ 1; i<= right; i++) {
if(reslut>array[i]) {
reslut= array[i];
}
}
returnreslut;
}
} else{
if(array[left] <= array[mid]) {
left= mid;
} else{
right= mid;
}
}
}
returnarray[mid];
}
}

本题考点:

考查对二分查找的理解。本题变换了二分查找的条件，输入的数组不是排序的，而是排序数组的一个旋转。这要求我们对二分查找的过程有深刻的理解。
考查沟通学习能力。本题面试官提出了一个新的概念:数组的旋转。我们要在很短时间内学习理解这个新概念。在面试过程中如果面试官提出新的概念，我们可以主动和面试官沟通，多问几个问题把概念弄清楚。
考查思维的全面性。排序数组本身是数组旋转的一一个特例。另外，我们要考虑到数组中有相同数字的特例。如果不能很好地处理这些特例，就很难写出让面试官满意的完美代码。

2.4.2 递归和循环

如果我们需要重复地多次计算相同的问题，通常可以选择用递归或者循环两种不同的方法。递归是在一一个函数的内部调用这个函数自身。而循环则是通过设置计算的初始值及终止条件，在一个范围内重复运算。

面试小提示:通常基于递归实现的代码比基于循环实现的代码要简洁很多，更加容易实现。如果面试官没有特殊要求，应聘者可以优先采用递归的方法编程。

递归虽然有简洁的优点，但它同时也有显著的缺点。递归由于是函数调用自身，而函数调用是有时间和空间的消耗的:每一次函数调用，都需要在内存栈中分配空间以保存参数、返回地址及临时变量，而且往栈里压入数据和弹出数据都需要时间。这就不难理解.上述的例子中递归实现的效率不如循环。
另外，递归中有可能很多计算都是重复的，从而对性能带来很大的负面影响。递归的本质是把一一个问题分解成两个或者多个小问题。如果多个小问题存在相互重叠的部分，那么就存在重复的计算。在面试题9“斐波那契数列”及面试题43“n个骰子的点数”中我们将详细地分析递归和循环的性能区别。
除了效率之外，递归还有可能引起更严重的问题:调用栈溢出。前面分析中提到需要为每一次函数调用在内存栈中分配空间，而每个进程的栈的容量是有限的。当递归调用的层级太多时，就会超出栈的容量，从而导致调用栈溢出。在上述例子中，如果输入的参数比较小，如10，它们都能返回结果55。但如果输入的参数很大，如5000，那么递归代码在运行的时候就会出错，但运行循环的代码能得到正确的结果12502500。

面试题9:斐波那契数列

题目一:写一个函数，输入n,求斐波那契( Fibonacci )数列的第n项斐波那契数列的定义如下:

思路:递归实现效率低，循环实现。
循环代码实现

publicclassTestc {
publicstaticvoidmain(String[] args) {
System.out.println(fibonacci(9));
}
publicstaticlongfibonacci(intn) {
longresult= 0;
longpreOne= 1;
longpreTwo= 0;
if(n== 0) {
returnpreTwo;
}
if(n== 1) {
returnpreOne;
}
for(inti= 2; i<= n; i++) {
result= preOne+ preTwo;
preTwo= preOne;
preOne= result;
}
returnresult;
}
}

递归代码实现

publicclassTestc {
publicstaticvoidmain(String[] args) {
System.out.println(fibonacci(9));
}
publicstaticlongfibonacci(intn) {
if(n< 0) {
return0;
}
if(n== 1) {
return1;
}
returnfibonacci(n- 1) + fibonacci(n- 2);
}
}

题目二：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法

把问题一 0 1 改成 1 2
假设，一级台阶，有f(1)种方法，二级有f(2)种，以此类推，n级有f(n)种方法。
可以看出，f(1)=1;f(2)=2。
那么，假设n级台阶，那么第一步就有两种情况，跳一步，跟跳两步。
情况一：跳一步，那么接下去的就是f(n-1)；
情况二：跳两步，那么接下去的就是f(n-2)。

测试用例:

功能测试(如输入3、5、10 等)。
边界值测试(如输入0、1、2)。
性能测试(输入较大的数字，如40、50、100 等)。

本题考点:

考查对递归、循环的理解及编码能力。
考查对时间复杂度的分析能力。
如果面试官采用的是青蛙跳台阶的问题，那同时还在考查应聘者的数学建模能力。

2.4.3 位运算

五种运算：与、或、异或、左移、右移

面试题10：二进制中的1的个数

题目:请实现一个函数，输入一个整数，输出该数二进制表示中1的个数。例如把9表示成二进制是1001，有2位是1。因此如果输入9，该函数输出2。
思路：

1.可能引起死循环的解法判断尾数右移。面试官接下来可能要问的第二个问题就是:上面的函数如果输入一个负数，比如0x80000000，运行的时候会发生什么情况?把负数0x80000000右移一位的时候并不是简单地把最高位的1移到第二位变成0x4000000而是0xC000000。这是因为移位前是个负数,仍然要保证移位后是个负数，因此移位后的最高位会设为1。如果一直做右移运算，最终这个数字就会变成0xFFFFFFFF而陷入死循环。
2.为了避免死循环，我们可以不右移输入的数字i。首先把i和1做与运算，判断i的最低位是不是为1。接着把1左移一-位得到2，再和i做与运算，就能判断i的次低位是不是.....这样反复左移，每次都能判断i的其中一位是不是1。
代码实现

publicclassTestc {
publicstaticvoidmain(String[] args) {
System.out.println(NumberOf(5));
}
publicstaticintNumberOf(intn) {
intcount= 0;
intflag= 1;
while(flag!= 0){
if((n& flag) != 0){
count++;
}
flag= flag<< 1;
}
returncount;
}
}

思路二：把一个整数减去1,再和原整数做与运算，会把该整数最右边一个1变成0。那么一一个整数的二进制表示中有多少个1,就可以进行多少次这样的操作。
代码实现

publicclassTestc {
publicstaticvoidmain(String[] args) {
System.out.println(NumberOf(7));
}
publicstaticintNumberOf(intn) {
intcount= 0;
while(n> 0){
if(n!= 0)
n= n&(n-1);
count++;
}
returncount;
}
}

测试用例:

正数(包括边界值1、0x7FFFFFFF)。
负数(包括边界值0x80000000、0xFFFFFFFF)。

本题考点:

考查对二进制及位运算的理解。
考查分析、调试代码的能力。如果应聘者在面试过程中采用的是第
一种思路，当面试官提示他输入负数将会出现问题时，面试官会期待他能在心中运行代码，自己找出运行出现死循环的原因。这要求应聘者有一定的调试功底。

相关题目:

用一条语句判断一“个整数是不是2的整数次方。一个整数如果是2的整数次方，那么它的二进制表示中有且只有一位是1,而其他所有位都是0。根据前面的分析，把这个整数减去1之后再和它自己做与运算，这个整数中唯一的1就会变成0。
输入两个整数m和n,计算需要改变m的二进制表示中的多少位才能得到n。比如10的二进制表示为1010， 13 的二进制表示为1101，需要改变1010中的3位才能得到1101。我们可以分为两步解决这个问题:第一步求这两个数的异或，第二步统计异或结果中1的位数。