【YAHOOWY】IT面试题集锦-CSDN博客

面试之前-准备技术面试

如何准备技术面试

You’ve purchased this book, so you’ve already gone a long way towards good preparation Nice work!

你已经在看本书了，你在面试的道路上已经跨出了一大步了。加油！

That said, there are better and worse ways to prepare Many candidates just read through problems and solutions Don’t do that! Memorizing or trying to learn specific questions won’t help you! Rather, do this:

准备技术面试的方法有好有坏。有些读者看完问题之后直接翻答案。千万别这么做。死记硬背或者敲代码是没有什么用的。更好的方法是这样做：

1 Try to solve the problem on your own I mean, really try to solve it Many questions are designed to be tough - that’s ok! When you’re solving a problem, make sure to think about the space and time efficiency Ask yourself if you could improve the time efficiency by reducing the space efficiency, or vice versa

1 尝试用自己的方法来解决这个问题。全凭自己的方法。有些问题确实很难，不过没关系。在解决了问题之后一定要考虑下时间和空间复杂度。推敲一下是否能够通过空间换时间或者时间换空间的方法来优化算法。

2 Write the code for the algorithm on paper You’ve been coding all your life on a computer, and you’ve gotten used to the many nice things about it But, in your interview, you won’t have the luxury of syntax highlighting, code completion, or compiling Mimic this situation by coding on paper

2 在纸上写下实现算法的代码。此前你一直在计算机写代码，特别依赖语法高亮、代码自动填补和编译器这些东西。但是在面试的时候是没有这些东西的，为了模仿这样的情况请一定在纸上写代码。

3 Type your paper code as-is into a computer You’ll probably have made a bunch of mistakes Start a list of all the mistakes you made, so that you can keep these in mind in the real interview

3 把你的代码原封不动的敲到计算机上。你肯定发现自己犯了不少的错。把这些错误都列在一张表里面吧，在面试的时候你就会警惕这些错误了。

4 Do a mock interview CareerCup offers a mock interview service, or you can grab a friend to ask you questions Though your friend may not be an expert interviewer, he or she may still be able to walk you through a coding or algorithm question

4 做个模拟面试。CareerCup提供一些模拟面试的服务，或者你可以找个朋友让他给你提一些面试的问题。虽然你的朋友不是专业面试官，但也能帮你完成代码或者算法的面试。

What You Need To Know

必备知识

Most interviewers won’t ask about specific algorithms for binary tree balancing or other complex algorithms Frankly, they probably don’t remember these algorithms either

面试官一般不会直接问你一个算法(平衡二叉树或者其他复杂的算法)是如何实现的，说实话这些算法面试官自己可能都忘记了。

You’re usually only expected to know the basics Here’s a list of the absolute must-have knowledge: Data Structures Algorithms Concepts Linked Lists Breadth First Search Bit Manipulation Binary Trees Depth First Search Singleton Design Pattern Tries Binary Search Factory Design Pattern Stacks Merge Sort Memory (Stack vs Heap) Queues Quick Sort Recursion Vectors / ArrayLists Tree Insert / Find / etc Big-O Time Hash Tables

一般面试官只需要你记住一些基本的算法，下面是一个必须知道的知识的列表：

This is not, of course, an all-inclusive list Questions may be asked on areas outside of these topics This is merely a “must know” list

当然这个表格并不包含一切知识点的。面试问题可能超出这个范围。这只是一个必须知道的列表。

For each of the topics, make sure you understand how to implement / use them, and (where applicable) the space and time complexity

对于表格中每一项你都得理解并且知道如何实现和使用它们，以及它们的时间空间复杂度。

Practicing implementing the data structures and algorithms You might be asked to imple- ment them in your interview, or you might be asked to implement a modification of them Either way, the more comfortable you are with implementations the better

好好练习这些数据结构和算法的实现。在面试的时候你可能会被问到如何实现他们，或者对算法进行改进。不论什么情况，你准备的越充分越好咯。

Do you need to know details of C++, Java, etc

语言的琐碎知识点

While I personally never liked asking these sorts of questions (e g , “what is a vtable?”), many interviewers regretfully do ask them For big companies like Microsoft, Google, Amazon, etc, I wouldn’t stress too much about these questions Look up the most common questions and make sure you have answers to them, but I would focus on data structures and algorithms preparation

就我个人来说，我绝不会问这类琐碎的问题（比如：什么是虚函数表？），很多面试官也很不喜欢这类问题。如果去面微软、谷歌或者亚马逊这类大公司，我是不会花太多的力气在这类问题上的。随便翻翻一般的参考书知道答案就可以了，更多的时间还是花在数据结构和算法的准备。

At smaller companies, or non-software companies, these questions can be more important Look up your company on CareerCup com to decide for yourself If your company isn’t listed, look up a similar company as a reference

但是在面试小公司或者非软件行业的公司的话，准备这类问题还是比较重要的。你可以到Careercup.com （需翻墙）看看你讲面试的公司是不是这类公司。如果没在列表里面的话，可以找一家差不多的公司作为参考。

面试题集-位操作

如何准备：

很多应聘者都很害怕“位操作”的题目，害怕确实是没有必要的。如果真的在位操作方面不太擅长的话，建议你还是通过在一些练习好好准备。笔算下面的题目：

如果这些题目做的时候还有困惑的话，那就把我们平时做10进制加减的规则联系到2进制上。

注意：windows自带的计算器能完成很多2进制下的计算，加减法，求与求门等。点击计算机的“查看” -> “科学型”，再按F7就能进入二进制模式计算了。

注意事项：

*在写代码的时候涉及到位操作一定要小心。边写的时候就要边想下，最好还能测试下。最后全部写完以后再测试一次。
*在做移位操作的时候，特别注意移位超过边界的时候如何处理。一定要想清楚然后。

左位移：

x< < 表示将x向左位移y位。移动时超出的部分直接丢弃。

右位移：

x>>y 表示将x向右位移y位。移动时超出的部分直接丢弃。

5.1 给你两个32位整数N,M，还有表示位置的i和j。实现方法使得N的i至j位等于M。例如：输入 N = 10000000000, M = 10101, i = 2, j = 6 输出 N = 10001010100
5.1解答：
解法很简单，首先将N的i到j位清零，然后再将M左移i位，最后将两数做或。

5.2 以字符串形式传入一个十进制数(例如3.72)，输出它的二进制表示形式。如果不能准确表示则输出"ERROR"
5.2解答：首先我们思考一下小数是如何用二进制表示的。以n = 0.101 = 1 * (1/2^1) + 0 * (1/2^2) + 1 * (1/2^3)为例。
打印输出整数部分是非常简单和直接的。小数部分我则采用将n*2，取整数部分，这就相当于“移位”的思想。

如果r>1，那么说明小数点后第一位为1。一直这样做，我们就能得到小数的二进制表示方法。

(译者注:本题作者理解为若32位小数仍无法表示则认为该数无法用二进制准确表示。更为准确的是判断标准为：在转换的任意阶段，若小数部分的最后一个数字非5，在该数无法被二进制数准确表示。)

5.3 给定一个整数，输出与这整数在二进制表示下有相同个数“1",大于n的最小值和小于n的最大值。
5.3解答：
暴力算法：
最简单的方法就是从n向上/向下例举，判断是否有对应个数的”1“。但是这样的方法一点技术含量也没有。
根据数字性质：
首先观察
* 若降一个”1“变为”0“，再另一个”0“必须变为1；
* 若将第i位的0变为了1，第j为的1变为了0，那么数字大小的变化为2^i - 2^j；
* 若要变大数字必须让i大于j。
求大于n的最小值：
* 将n转化为二进制，从右往左依次遍历各位，在经过1后，遇到的第一个0，将其置1。这样就是个数字增大了2^i。例:xxxxx011100 变成 xxxxx111100
* 将i位右边的1置0，这样数字总的变化2^i-2^(i-1)。例：xxxxx111100 变成 xxxxx101100
* 为了让大于n的最小值，将i-1之后的1都移到最右端。
求小于n的最大值，方法类似：
* 将n转化为二进制，从右往左一次遍历各位，在经过0后遇到的第一个。例如xxxxx100011 变为 xxxxx000011
* 将i位右边的0置为1。例如xxxxx000011 变为 xxxxx010011。
* 为求最大值，将i-1位后的1尽量往左移到。
有了算法，开始着手写代码的时候记得将一些常用的方法放到一个公共的类中，写出整洁的代码。

5.4 解释下面表达式的含义 ((n & (n-1)) == 0)
5.4解答
我们来反向思考这个问题。
A&B=0是什么意思呢？它表示A和B两个数的二进制数每一位都不相同。那么n & (n-1)=0，说明n和n-1也没有相同的位。
那n-1又表示什么意义呢？从下面的例子你能看发现什么呢？

当你做减法的时候，主要看最低位，如果最低位为1，那么最低位直接变0；如果最低位为零，那么向高位借1，再减。从低位开始向高位将0变为1，直到借位的那一位。那么n和n-1的关系将会如下例所示：

如果n&(n-1)为0的话，说明例子中的abcde均为0，也就是说n中只有一位为1。也就是说n为2的整数次幂。

5.5 实现函数计算将整数从A变成B需要变动几位。例如输入:31,14 输出 2
5.5解答：
本题的解题关键在于发现A和B之间有多少位是不同的。那如何判断A和B那些位不同呢?对XOR!
将获得A和B不同的部分，统计出有多少个1就能判断需要变动几位了。

5.6 实现方法将一个整数中的偶数位和奇数位交换。(例如：将0位和1位交换，2位和3位交换)
5.6解答:
用10101010(0xAA)这样的掩码提取出偶数位的信息，类似的用0x55提取奇数位的信息。然后错位求或即可。

5.7 一个数组A[1，n]能容纳n个数字，现将0到n这n+1个数字，随机的放入到数组中。最后会有一个数字没有进入数组。现在让你找出这个数字。但是有如下的限制，不能直接访问数组的整个元素，只能访问“A[i]的第j位”。写出代码找出该元素。能否将时间复杂度控制在O(n)。
5.7解答：
(译者注：作者这里假设n为奇数。)
首先我们将0到n的所有数字的二进制表达列出来。那么我们可以发现最低位的，大概是这样的情况：count(0)>=count(1)。
如果我们从中移除了一个数字，会怎么样呢？

如果移除的数最低位为0，那么count(1)>=count(0)；如果移除的是1，那么count(0)>count(1)。如果n次访问每个数的最低位，那么用以上的准则我们就能判断出没有进入数组的那个数字的最后一位是什么。如果最低位是0的话，那就可以排除最低位为1的元素；如最低位为1，那就可以排除末尾为0的。
那下一步怎么办呢？看次低位的情况？那么我以n=5，未入数组的数字为3。经过上一轮的排除后，剩下的数字如图所示：

那么现在次低位的情况为0 0 1 0 1 0 ，根据之前的逻辑我们知道，次低位应该是1。那么我们继续排除。只保留末尾为11的元素。剩下的就是：

再继续看倒数第三位。同样方法知道第三位应该是0。那么我们确定出了丢失的元素。
根据以上的方法，确定实现代码如下：

那算法的时间复杂是多少呢？第一次扫描了N次的最低位，第二次为N/2......以此类推，根据下式子：

所以我的算法的复杂度为O(n)。

面试题集-数组和字符串

哈希表

尽管哈希表不能解决所有的问题，但是面试中的大部分问题能用它解决。在面试之前一定要好好准备下哈希表的使用和实现。

数组链表

数组链表(大小可动态变化的数组)在使用中能够根据需要扩大数组的容量，并且能够提供O(1)的随机访问效率。数组链表典型的一种实现方法就是：当达到数组上限，就将数组容量扩大一倍。虽然在扩大容量时候的时间复杂度为O(n)，但是这样情况都较少发生，所以总的时间开销可近似为O(1)。

字符串

问：下面这段代码的时间复杂度？

答：O(n^2)，这里的n为字符串sentence中的字符的个数。理由如下：每次你在向字符串sentence串中才追加一个数组的时候，就需要重新复制一次sentence中的字符，每次复制都需要从头到尾遍历一次sentence。这样的话把所有的单词追加到sentence中的时间复杂度为O(n^2)。

1.1 设计算法判断一个字符串中字符都是否唯一的。如果不能使用额外的数据结构呢？
解答1.1：先假设字符串中的字符均为ASCII码(如果不是的可以增大存储空间，而算法的逻辑是相同的)。“假设”在你的面试中非常的重要。

算法的时间空间复杂度均为O(n)，n为字符串的长度。

采用bit序列来代替数组可以为我们进一步节省空间。这里我们需要假设字符串中的字符为'a'-'z'。这样只要用一个int型的变量就能记录字符是否出现了。

本题还有其他的解法：
1. 检查每一个字符在字符串中的出现次数，这样的方法时间复杂度为O(n^2),但是空间复杂度为0。
2. 如果字符串中的内容可以破坏的话。我们可以将字符串中的字符排序(时间复杂度为O(nlogn))，然后遍历字符串中的某个字符相邻的字符时候相同。但是要注意有些排序算法是需要额外的存储空间的。

1.2 实现C语言风格的字符串反转的算法
(C语言字符串：例如“abcd”字符串为5个字符，最后一个字符为/0用来表示字符串结束。)
解答1.2：
这个是面试的常见问题。如果你说你懂的话，就马上开始写代码吧。

1.3 设计一个算法移除字符串中的重复字符，算法不使用额外缓冲。并对你的算法设计测试用例。注意：一两个变量使用当是OK的，但是复制整个数组就不行了。
解答1.3：
无字符串缓冲算法
1. 对每个字符判断是否为重复字符。
2. 重复字符直接跳过，非重复字符记录。
时间复杂度为O(n^2)

测试用例：
1. 无重复字符：abcd；
2. 全重复字符：aaaa；
3. 无效字符串：null；
4. 连续重复字符串：aaaabbbb；
5. 非连续重复字符串：abcabc；

字符串缓冲算法：

1. 无重复字符：abcd；
2. 全重复字符：aaaa；
3. 无效字符串：null；
4. 空字符串：empty
5. 连续重复字符串：aaaabbbb；
6. 非连续重复字符串：abcabc；

1.4 写一个函数判断两个字符串是否使用相同的字符构成。
解答1.4：
本题有两种解法
法1 排序法

法2 计数法

1.5 编写代码将字符串在中的空格替换为‘ ’
解答1.5：
算法流程：
1 遍历字符串，记录下有多少个空格；
2 从字符串尾部重新解析：
(1) 如果当前字符为空格，在写入字符串' '
(2) 非空格则直接记录。

1.6 给出一张图片，表示为NXN的居然，每个像素点为4字节。写一个函数实现将这张图片旋转90°。
解答1.6：
图片的旋转可以将像素划分成一圈一圈，然后从最外层一圈一圈上来旋转。旋转某一圈的某个元素的时候，相当于对应的上下左右依次交换。

1.7 实现算法：在一个MxN的矩阵中，如果某一元素为0，则将其所在的行和列都置为零。
解答1.7：
乍一看题目，先遍历矩阵，出现0元素，就将所在的行列置零。但是这样的方法执行下来的话整个矩阵都变成了0了。
一个变通的方法，在另外一个MxN的矩阵中记录是否出现零的情况，然后根据记录对原来的矩阵中对相应的行列进行置零。可是这样方法的空间复杂度为O(MxN)。有没有改进的空间呢？
经过观察，其实我们只需要记录哪一列和哪一行需要置零即可。那么我们新的记录方法即为:使用两个数组rows[]和col[]来记录需要置零的行列。更具这样的方法算法代码如下：

1.8 假设你已经有一个函数用来 isSubstring(s1,s2) 用来判断字符串s1是否是字符串s2的子串。那么现在给你一个字符串s1和s2，让你判断s1是否是s2循环位移得到的。你的算法中只能调用一次isSubstring (比如“waterbottle”循环位移就可以得到"erbottlewat")。
解答1.8：
算法描述:
1 如果length(s1)！= length(s2) 返回 false
2 将是s1和本身连接，得到新字符串s1'，调用isSubstring(s2,s1')判断s2是否为s1'的字符串。

面试题集-链表

如何准备

链表是面试中非常常见的问题。问题难度有难有易。无论题目如何，我们都建议你先练熟简单题目。掌握了简单链表题，面对那些难题的时就会轻松一点。所以下面列出了一些链表题中必备的代码。

创建一个链表：

注意：在面试的时候写链表，一定要先问清楚是写单链表还是双链表！

在单链表中删除一个节点

2.1从一个未排序的链表中删除重复元素
进阶：如果不能使用额外的空间怎么办？
2.1解答：
如果可以使用哈希表的话，那么检查每一个元素是否重复，然后移除。

如果不能额外使用空间的话，我们就需要两个指针来遍历数组：current用来正常的遍历；runner则用来检查元素是否重复。runner只为一个元素检查一次是否重复，因为每一次runner会删除和元素的所有重复元素。

2.2 实现算法查找单链表中的倒数第n个元素。
注意：这个问题强烈的暗示递归算法，但是这里才采用一种更巧妙的方法。像这样类似的问题就，一定要多思考看看。能不能用非递归的方法代替递归的方法。
2.2解答：
这里我们假设链表的长度至少为n。
算法描述：
(1) 创建两个指针p1和p2，均指向链表头。
(2) 让p2增加n-1次，使得p2指向从链表头第n个元素(使得p1和p2之间距离为n)
(3) 若p2->next为空，则返回p1；不为空则同时增加p1，p2。（如果p2->next为空，则表示p1所指的元素为倒数第n个，因为p1，p2的距离为n。）
(4) 重复(3)

2.3 实现一个算法，只给你链表中间的一个元素(没有链表头)，将其从链表中删除。
例如：
输入：节点 c (原链表为 a->b->c->d->e)
输出：没有任何返回值。但链表变成 a->b->d->e
2.3解答：
本题的解答只是把输入的下一个元素拷贝到输入的这个元素中以完成删除输入的元素。(译者注：原文的代码没有释放下一元素的空间。)
注意：这样的方法并不能删除链表的最后一个元素。这一点需要和你的面试官说清楚。算法有缺陷没有关系，大胆的告诉你的面试官，他们喜欢看到你提出这些。至于怎么解决可以和你的面试官讨论。

2.4 两个用链表表示的数字，最低位在表头。写一个函数对两个这样的链表求和，采用相同的形式返回结果。
例如： (3 -> 1 -> 5) + (5 -> 9 -> 2) 返回 8 -> 0 -> 8
2.4解答：
本题可以采用递归的方式逐位的做加法。算法流程:

2

2.5 给一个带有环的链表，设计算法查找这个环的起点。
环的定义：链表中的某一元素的下一个元素为之前的一个元素。
例如：输入 A -> B -> C -> D -> E -> C 输出 C
2.5 解答：
如果在链表中有两个指针，从表头开始p1以每次一个节点的速度前进，p2每次2个。那么这两个指针一定在链表的环中相遇。想想两辆车以不同的速度在一个环形跑道上运动，那么他们肯定会在跑道上再次相遇。
这个问题最难的部分就在于如何超出这个环开始的节点。假想下如果是在一个圆形的跑道上p2以两倍的速度于p1同时从起点出发，他们将会哪里相遇。还是在起点！
现在我们再假设如果p2超前起跑线k米起跑，他们第一次在哪里相遇呢？在起跑线后面k米处。(为什么？假设p2过了起跑线之后跑了x和p1相遇，那么p2跑了l-k+x，其中l为跑道的长度，至相遇时p1也跑了x。根据相遇时消耗的时间相等得方程 (l-k-x)/2=x/1，解得 x = l-k，也就是在起跑线后k处相遇。)

那重新回到问题本身，当p1指针刚进入环的时候，p2在环中恰好领先p1指正k个节点，k为链表头节点到环开始处的距离。根据之前的结论，当p1、p2相遇的时候，他们都相遇环开始节点k个距离。
那么我们得到如下结论：
(1)表头距离环开始处k节点
(2)p1，p2距离环开始处也是k个节点。
如果当p1、p2相遇之后，将p1至于表头然后两个指针都采用1的速度移动的话。那么相遇处即为环开始处。

面试题集-堆栈和队列

如何准备：

当面试官需要你实现一个简单的堆栈或者列队的时候，你能顺利的写完，那你就比一般的应聘者先人一步了。熟能生巧，下面的这些基本的堆栈和队列的框架代码一定要掌握。

堆栈

队列

3.1 怎样用一个数组实现三个堆栈
3.1解答：
解法一：
将数组划分成3等份，每一份独立的用来实现堆栈。
*第一个堆栈：从 0 至 n/3
*第二个堆栈：从 n/3 至 2n/3
*第三个堆栈：从2n/3 至 n
这种解法是基于对每个堆栈的使用没有额外的使用说明，所以我们直接为每个堆栈划分固定的大小。

解法二：
解法二中的，主要数组中还有空余的空间，堆栈就还能增长。
每次为堆栈分配一个空间的时候，在这个新空间中记录上一个空间地址。这样堆栈中的每个元素都有一个指针指向之前的元素。
这样的实现方法有一个问题就是如果一个堆栈弹出一个空间(释放空间)，这个空间并不会作为空闲空间现在数组后面。这样话我们就不能使用新产生的空闲空间。
为了解决这个问题，我们用一个列表来记录空闲的空间。当有新空闲空间出现，我们就把它加入到这个表中。如果需要新分配一个空间，就从这个表中删除一个元素。
这样的实现方法使得3个堆栈能够动态的使用数组的空间，但是这是以增大空间复杂度换来的。

3.2 适合实现一个堆栈，除了有函数push、pop函数之外还有min函数，min函数范围堆栈中的最小元素。要求push,pop和min三个函数的时间复杂度均为O(1)。
3.2解答：
在每个堆栈中的节点中记录目前堆栈中的最小值。那么调用min( )函数时只需要看看栈顶元素中记录的最小值即可。

但是这样解法存在的问题是，如果堆栈的需要记录的元素非常多，那么这样的方法将会消耗大量的空间。因为我们在每个堆栈的元素中都记录来了最小值。这个能不能改进呢？
我们可以在创建一个辅助的堆栈只用来记录最小的元素。

这样的方法就是不是有更高的效率呢，在堆栈s2中只记录最小值，避免了大量的冗余数据的记录。

3.3 想象下啊：一堆盘子，如果堆得太高的话，就容易倒下来。所以在现实中如果盘子堆到一定高度，我们就会重新起一个堆。现在实现一个新的数据结构来模拟这样现象。SetOfStack当中包含很多的堆栈，当一个堆栈达到上限的时候，启用下一个堆栈。SetOfStack.push 和 SetOfStack.pop应该和普通堆栈的操作一样。
进阶：
实现一个函数popAt(int index)，指定在哪个堆栈上弹出元素。
3.3解答：
根据题意，我们的数据结构大体上应该是这么一个框架：

由于要和普通的堆栈的push()有相同的效果，也就是说每次push()都必须将元素放到最近使用的一个堆栈中。但是在这个堆栈已经满了情况下，那就必须建一个新的堆栈然后再入栈。那么push的实现如下:

那pop()如何实现呢？和push()差不多，也一定要在最近的一个堆栈上操作。但是如果最后一个堆栈是空的话，就应该将其移除。

那进阶的问题这么处理呢？
这个问题确实有点难度。实现起来也比较麻烦，因为整个系统看起来应该像一个“翻转”系统。如果我从堆栈1中弹出一个元素，那么我们需要将堆栈2底部的元素压到堆栈1的顶端。堆栈3的元素要到堆栈2....
注：你可能会不同意我的说法。认为实现这个函数不需要“翻转”整个堆栈。系统中的每个堆栈并不需要都是满栈的，这样的话也可以省下很多的时间复杂度，特别是在堆栈非常大的时候。但是如果假设除了最后一个堆栈之外，所有的堆栈必须满栈的话，这样的方法就不行了。具体采用什么样的结构，你可以在面试时和面试官好好沟通然后决定。

3.4 经典的汉诺塔问题，有3根柱子，柱子上串有N个尺寸不同的碟子。汉诺塔问题的起始状态为，所有的碟子都从小到大的穿在柱子上(下面的碟子最大)。在满足下面三个限制：(A) 每次只能移动一个碟子；(B) 只有每根柱子顶端的碟子才能移动；(C)任何碟子只能放在比它大的碟子上。写一段程序(要求使用堆栈)，将第一个根柱子上所有的碟子移动到移到最后一根柱子上。

3.4解答：
首先我们考虑解题的算法：将N个碟子从第一根柱子移到最后一根柱子。我们先从最简单的情况开始。如果只有一个碟子，那么直接将它移到最后的柱子。那两个碟子呢？
(1)先将第一个碟子从第一根柱子移到第二根
(2)将第二个碟子从第一根柱子上移动到第三根
(3)再将第二根柱子上的碟子移动到第三根上，完成！
那三个碟子呢?
(1)采用两个碟子移动的方法，讲上两个碟子移动到第二根柱子上
(2)将第三个碟子移动到第三根柱子
(3)在采用运来的方法将第二根柱子上的两个碟子移动到第三根柱子。
很明显采用递归算法就能解决本题：

3.5 用两个堆栈来实现一个队列
3.5解答：
堆栈和队列的最大区别在于：一个是先进后出，一个是后进先出。但是题目的要求使得peek和pop的动作恰好相反。那么我们就可以利用第二个堆栈完成入栈元素顺序的反转。(先所有的元素进堆栈S1，这样最先进栈的元素在栈底，最后的在栈顶；然后将S1中的元素依次弹出，并压入堆栈S2中。这样S2中先进的元素就在栈顶后进的就在栈底了。)
但是如果对队列和出队列的动作反复进行的话，我就要在S1和S2两个堆栈中反复的倒来倒去。其实有偷懒的方法。
当有元素要进入队列的时候，直接压如堆栈S1中，元素需要从队列中出列的话，检查S2中是否有元素，如果没有再采用之前的方法将S1中的元素“倒”入到S2中，如果S2中非空在直接弹出元素即为队列中出列的元素。这样的方法就免于在两个堆栈之间倒来倒去了：

3.6 写一个程序将堆栈升序排序。该堆栈就是一个普通的堆栈，不能有其他假设。函数实现是只能调用函数push(),pop(),peek()和isEmpty这几个函数。
3.6解答：
再建一个堆栈，从原堆栈中弹出一个元素到新的堆栈中。然后再比较原堆栈栈顶元素和新堆栈栈顶大小。如果符合排序规则，再次入新堆栈。如果不符合，在弹出新堆栈中的元素逐个比较直到满足排序关系。这样类似插入排序的方法，之间复杂度为O(n^2)。

面试题集-树和图

如何着手

这类问题主要有以下两种形式：

1、完成创建一个树/查找一个结点/删除一个结点/其他常见的算法

2、完成对一个已知算法的修改

不管怎样，我们强烈推荐你在面试之前搞懂与树有关的重要算法。如果你对树非常熟悉，那么就可以轻松应对一些棘手的问题了。我们给出一些非常重要的几点：

重要提示：并非所有的二叉树都是二叉查找树当被问到有关二叉树的时候，许多面试者自以为面试官是指二叉查找树，而面试官实际上是说二叉树。所以，认真听是否有“查找”那个词。如果你没有听到，那么面试官可能就是指那些没有经过特定排序的结点的二叉树。如果你不确定，那就问下吧。

有关二叉树的最基础算法

在你面试之前你应该熟知以下算法：

1、中序遍历：首先访问左结点，接着访问根结点，然后访问右结点（通常在二叉查找树中使用）。

2、先序遍历：首先访问根节点，接着访问根节点的左子节点下的子树内的节点，然后访问根节点的右子节点下的子树内的节点。

3、后序遍历：首先访问根节点，接着访问根节点的右子节点下的子树内的节点，然后访问根节点的左子节点下的子树内的节点。

4、插入结点：在二叉查找树中，我们插入一个变量v的方法是这样的。跟根节点比较，如果v大于root，那么去右边，否则去左边。我们重复这样的比较直到有一个空结点。

注意：调整或者删除查找树的问题很少会问到，但你应该知道他们是如何工作的。这有助于你从其他面试者区分出来。

有关图遍历的最基础算法

在你面试之前你应该熟知以下算法：

1、深度优先搜索DFS（Depth First Search）：DFS算法涉及在访问兄弟结点前先访问自身以及子结点。

2、广度优先搜索BFS（Broad First Search）： BFS算法涉及在访问子结点前先访问自身以及兄弟结点。

例题

4.1 完成一个用来判断一颗树是否是平衡树的函数。这个问题的目的是，平衡树是指两个叶结点在距离根结点的距离上不会超过1。pg123

解答

思路很简单：最小深度与最大深度的差别是不超过1.因此最大与最小深度的差值就是树中最大的深度差值。

4.2 对于一个有方向的图，设计一种算法用来判断在两个顶点之间是否有路径。pg124思路很简单：最小深度与最大深度的差别是不超过1.因此最大与最小深度的差值就是树中最大的深度差值。

解答

这个问题通过对图的遍历就可以轻松解决，比如深度优先搜索或者广度优先搜索。我们从其中一个结点开始遍历，遍历过程中检查另外一个结点是否被找到。我们应该对算法中遍历过的结点进行标记，以避免对结点的重复访问以及循环访问。

4.3 对于一个升序排列的数组，给出创建最小高度二叉树的算法。pg125

解答

如果可能，我们尝试建立这样一个二叉树，对于每一个结点，他左分支的结点总数与右分支的结点总数一致。

算法如下：

1、插入数组中的中间数

2、将中间数左边的元素插入到左分支

3、将中间数右边的元素插入到右分支

4、递归

4.4 对于一个二叉查找树，设计可以给出在任一深度所有结点的链表的算法（比如树的深度是D，就有D个链接。）pg126

解答

我们可以做对树一层层的遍历，对树的初次遍历可以做轻微的修改。

在常见的初次遍历中，我们在遍历结点的时候不关心现在所在的层。在这个问题中，就有必要知道当前的层信息。因此我们使用一个虚拟结点来预测我们是否完成了本层并进行下一层访问。

4.5 对于一个每一个结点都有一个指向其父结点的二叉查找树，设计一个寻找给定结点下一个结点的算法。pg127

解答

解决这个问题，我们需要仔细思考中序遍历中到底发生了什么。在先序遍历中，我们访问X.left,X,然后是X.right.

因此，如果我们想找到X.successor(),我们这样解决：

1、如果X有右分支，那么所谓的继承者肯定在X的右侧。很明确，在树的那个分支上，需要首先访问最左边的子结点。

2、否则我们访问X的父结点（记做P）

a) 如果X有一个左子结点（P.left=X），那么P就是X的继承者。

b) 如果X有一个右子结点（P.right=X），因此我们就调用successor(P)。

4.6 设计一个二叉树中两个结点的第一个共同祖先结点的算法，并给出代码。避免在数据结构中存储额外的结点。注意：这不一定需要是二叉查找树。pg128

解答

假设这是二叉查找树，我们可以在这两个结点上做一个改进的搜索来看这两路径在哪里分叉。可惜的是，这不是二叉查找树，因此我们得试其他思路。

思路1

如果每个结点都连接到他的父结点，那么我们就可以跟踪p跟q的路径直到他们交叉。

思路2

另外，你可以看一个p跟q都在同一侧的一个分割线。也就是说，如果p跟q都在结点的左侧，那就在左侧分支中去寻找共同的祖先。当p跟q不在同一侧的时候，你不得另想其他办法。

思路3

对于任意一个结点r，我们有以下：

1、如果p在一侧，q在另外一侧，那么r就是最近的共同的祖先。

2、否则的话，最近的共同的祖先就在左侧或者右侧。

因此，我们可以给出一个叫左搜索-右搜索的递归算法来计算当前结点的左侧跟右侧分别有多少个结点（p或者q）。如果在某一侧只有2个结点，那么我们就需要判断这个子结点是不是p或者q（因为这种情况下，当前结点就是最近的共同的祖先）。如果不是p或者q，那我们就得从子结点开始继续搜索。

如果需要寻找的结点（p或者q）在当前结点的右侧，此外另一个结点在另一侧。那么当前及诶点就是最近的共同的祖先。

4.7 如果有两个巨大的树，T1、T2，其中前者有百万个结点，后者有几百个结点。设计一种算法判断T2是否是T1的一个分支。pg130

解答

注意问题的特别指出T1有百万个结点，也就是说我们应该特别注意空间的开支。举个例子，如果T1有1000万个结点，那么单单数据量就是大约40mb。我们可以创建一个字符串来表示中序跟先序的遍历。如果T2的先序遍历是T1先序遍历的一个分支，T2的中序遍历是T1中序遍历的一个分支，那么T2就是T1的第一分支。我们可以通过使用一个后缀树来确认。然而，我们可能会受到内存的限制，因为后缀树对于内存是极端敏感的。如果这个成了一个问题，那么我们就得试下另外一个思路。

其他思路：treeMatch程序访问T2的每个结点最多一次，对于T1的每个结点的访问次数不超过1。最极端的情况是O(m*n)，n跟m分别表示T1跟T2的大小。如果k表示T2的根节点在T1中出现的次数，那么极端的时间复杂度是O(k*m+n)。

4.8 对于一个任何结点都包含值的二叉树，设计一种算法实现打印出和是那个值的所有路径。注意可以是任何路径（不需要一定从根结点开始）。pg131undefined

解答undefined

undefined

我们通过简化这个问题来求解。假设这个路径从根结点开始会怎样？这样的话，我们就得到一个更简单的问题了：undefined

从根节点开始，然后左分支跟右分支，计算每个路径的总数。当我们找到这个总和的时候，我们就打印出当前路径。注意我们直到找到这个总和才停止计算。为什么？因为我们可以遇到下面这种情况（假设我们找总和是5的路径）：2 + 3 + –4 + 3 + 1 + 2。如果我们遇到2+3就停止计算，我们就可以错过其他一些路径（2 + 3 + -4 + 3 + 1 和3 + -4 + 3 + 1 + 2）。因此我们对于每个可能的路径都要试一次。undefined

好，现在假设这个路径可以从任何一个结点开始？在这种情况下，我们做个小修改。在每个结点，我们核对下是否找到总和。这并不是指我们是否从一个有这个总和的路径开始，而是这个路径达到总和了吗？undefined

这个算法的时间复杂度如何呢？假设一个在第r层的结点，我们做r数量级的计算。我们猜测是O(nlgn)，或者我们仔细算下：第r层有2^r个结点
类似的逻辑，空间复杂度是O(nlgn)。

undefined