笔试、面试100题（1---20）

1.把二元查找树转变成排序的双向链表
 题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
   10
  / \
  6  14
 / \ / \
4  8 12 16
 转换成双向链表
4=6=8=10=12=14=16。

 

        题目要求转化成一个有序双向链表，可以这样考虑：先从树中找出最小的元素，插入双向链表中。然后，再从树中找出次小的元素，插入链表中…。题目中给出的是一个二叉查找树，如果对树进行中序遍历，得到的元素恰好是由大到小排列的。于是整个转化的过程是这样的：对树进行中序遍历。先处理左子树、再处理当前的根（即，把根加入到双向链表的末尾）、最后处理右子树。

        具体实现的时候，可能需要一个pHead指向链表的第一个元素，pPre指向链表的最后一个元素，这样可以很方便的把当前节点插入到双向链表的末尾。

2.设计包含min函数的栈。
定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。
要求函数min、push以及pop的时间复杂度都是O(1)。

 

        最容易想到的是，在stack的实现中加入一个数据成员：m_min,用它来记录stack中当前的最小元素。这样，min()函数可以直接return m_min，故可以在O(1)内完成。push()函数压栈的时候做一个简单的判断，也可以在O(1)内完成

        关键是pop()函数弹栈的时候可能会出现问题。如果pop()恰好把当前最小的元素弹出了栈，如何得到剩下元素中最小值？题目要求O(1)内完成，即常数时间内完成，显然只有直接查找可以做到了。即，我们把每个元素入栈时，当前栈中的最小值都记录下来，这样就可以在O(1)内得到最小值。因为元素都存储在栈中，所以对应的最小值也存储在另个一个辅助栈中，且两个栈同步操作（即，同时push, 同时pop）。

3.求子数组的最大和
题目：
输入一个整形数组，数组里有正数也有负数。
数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
求所有子数组的和的最大值。要求时间复杂度为O(n)。

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，
因此输出为该子数组的和18。

 

        最大子序列的和，已经出现了太多次。用DP可以直接求解，时间复杂度O( n ),空间复杂度O( n )。如果仔细观察DP可以得到更优化的解法：从前到后扫描数组，并记录当前的累加和。如果当前累加和小于0，则从数组下一个数开始重新计算。同时，在整个过程中适时的更新最大和。这样，算法的空间复杂度为O( 1 )。 

4.在二元树中找出和为某一值的所有路径

题目：输入一个整数和一棵二元树。
从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。
打印出和与输入整数相等的所有路径。
例如 输入整数22和如下二元树
  10 
  / \  
 5    12  
 /   \  
4     7
则打印出两条路径：10, 12和10, 5, 7。

 

        因为树本身具有递归结构，所以树上的许多问题都可以使用递归解决，该题也不例外。求整个树上的路径，可以先求出左子树上的路径，再求出右子树上的路径。这样不断递归，直到叶子节点。这时，判断当前的累加值是否满足条件，如果满足条件，则把路径上的所有节点打印出来。显然，在递归遍历的时候，需要记录路径上的节点。

5.查找最小的k个元素
题目：输入n个整数，输出其中最小的k个。
例如输入1，2，3，4，5，6，7和8这8个数字，则最小的4个数字为1，2，3和4。

 

方法一：排序，然后求最小的K个元素。时间复杂度O( n*lgn )

方法二：首先，对数组的前k个元素建大顶堆。然后，用数组剩下的元素不断更新大顶堆。即，如果剩下的某个元素比大顶堆的堆顶元素值小，则用这个值替换堆顶元素，然后对堆进行调整。最终，堆里的元素就是最小的k个元素。建堆的时间复杂度O( n )，调整堆的时间复杂度O( lgk )，这样总的复杂度O( n + n*lgk)

方法三：类似方法二，只不过不用建堆，直接不断更新数组的前k个元素，直到最后，前k个就是要求的结果。

方法四：类似中位数的求法。使用中位数的方法，可以找到第k小的元素。这里不过是求前k小的元素。根据枢轴元素对数组进行划分，找到第k小的元素的位置。最后，第k小的元素连同它左边的元素就是要求的结果。 

第6题 ：腾讯面试题：
给你10分钟时间，根据上排给出十个数，在其下排填出对应的十个数
要求下排每个数都是先前上排那十个数在下排出现的次数。
上排的十个数如下：
【0，1，2，3，4，5，6，7，8，9】

举一个例子，
数值: 0,1,2,3,4,5,6,7,8,9
分配: 6,2,1,0,0,0,1,0,0,0
0在下排出现了6次，1在下排出现了2次，
2在下排出现了1次，3在下排出现了0次....
以此类推..

 

暂时没什么思路。 

第7题：微软亚院之编程判断两个链表是否相交。

给出两个单向链表的头指针，比如h1，h2，判断这两个链表是否相交。 

当两个链表都不带环。此时，如果相交，则尾指针必相同。所以，要判断是否相交，只要判断尾指针是否相等即可。

当只有一个链表带环。此时，比不相交。

当两个链表都带环。此时，如果相交，一个链表的环上的所有元素恰好也是另一个链表环上的所有元素。所以，此时只要在链表的环上取一个元素，判断它是否也在另一个链表中即可。至于，取哪个元素？因为判断是否带环时，要用两个指针追赶，不妨取这两个指针的相遇点。
第8题
此贴选一些 比较怪的题，由于其中题目本身与算法关系不大，仅考考思维。特此并作一题。
1.有两个房间，一间房里有三盏灯，另一间房有控制着三盏灯的三个开关，

这两个房间是 分割开的，从一间里不能看到另一间的情况。
现在要求受训者分别进这两房间一次，然后判断出这三盏灯分别是由哪个开关控制的。有什么办法呢？

2.你让一个人为你工作了七天，你要用一根金条作为报酬。金条被分成七小块，每天给出一块。如果你只能将金条切割两次，你怎样分给这个工人?

3.　★用一种算法来颠倒一个链接表的顺序。现在不用递归式的情况下做一遍。
　　★用一种算法在一个循环的链接表里插入一个节点，但不得穿越链接表。
　　★用一种算法整理一个数组。你为什么选择这种方法?
　　★用一种算法使通用字符串相匹配。
　　★颠倒一个字符串。优化速度。优化空间。
　　★颠倒一个句子中的词的顺序，比如将“我叫克丽丝”转换为“克丽丝叫我”，

实现速度最快，移动最少。
　　★找到一个子字符串。优化速度。优化空间。
　　★比较两个字符串，用O(n)时间和恒量空间。
　　★假设你有一个用1001个整数组成的数组，这些整数是任意排列的，但是你知道所有的整数都在1到1000(包括1000)之间。此外，除一个数字出现两次外，其他所有数字只出现一次。假设你只能对这个数组做一次处理，用一种算法找出重复的那个数字。如果你在运算中使用了辅助的存储方式，那么你能找到不用这种方式的算法吗?
　　★不用乘法或加法增加8倍。现在用同样的方法增加7倍。 

 

        灯泡和开关的问题。三个灯泡、三个开关，要在灯泡和开关之间建立对应关系。使用一条准则，一个灯泡可以关联一个开关。再使用一条准则，又一个灯泡可以再关联一个开关。那么，最后剩下的灯泡就必然和剩下的开关对应。因此，只要找到两条判断的依据即可。依据1：当前灯泡的亮灭。依据2：亮过的灯泡会发热。

 

       两刀分金条。共7天，每天给1/7。

第一天从金条上切1/7支付给工人。

第二天从金条上切2/7，这时剩下4/7。支付2/7给工人，收回1/7。

第三天将收回的1/7支付给工人

第四天将4/7支付给工人，并将1/7、2/7收回

…

第9题：判断整数序列是不是二元查找树的后序遍历结果
题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。
如果是返回true，否则返回false。

例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：

          8
       /  \
     6     10
    / \    / \
   5  7  9  11
因此返回true。
如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。

 

        把数组最后一个元素当作二叉树的根，然后分别找树的左子树、右子树。左子树都小于根，右子树都大于等于根。也就是说，我们遍历序列，找到第一个大于根的元素。那么，这个元素后面的所有元素都要大于根。如果不满足，则必然不是二叉查找树的后序遍历结果。然后，对左右子树再继续分别进行判断。

第10题：翻转句子中单词的顺序。
题目：输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。

句子中单词以空格符隔开。为简单起见，标点符号和普通字母一样处理。
例如输入“I am a student.”，则输出“student. a am I”。

 

        用string存储单词，用string的数组存储这个句子。然后对数组进行反转即可。可以用两个指针，一个指向数组头，另一指向数组尾。交换数组所指的元素。然后，前端的指针++，后端的指针--，直到后端指针小于前端指针。

第11题：求二叉树中节点的最大距离。

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，
我们姑且定义"距离"为两节点之间边的个数。
写一个程序，求一棵二叉树中相距最远的两个节点之间的距离。

 

当二叉树的左右子树都不为空。哪两个点之间的距离最大呢？左子树中深度最大的点、右子树中深度最大的点。所以，求最远距离就是求左右子树的深度。当然，树的深度用递归很容易求得。整个树的深度是左右子树中较大的深度。

当左子树为空时，最远距离就是右子树的深度。

当右子树为空时，最远距离就是左子树的深度。 

第12题：求1+2+…+n，
要求不能使用乘除法、for、while、if、else、switch、case等关键字以及条件判断语句（A?B:C）。

 

自己不会做，网上找的方法，很巧妙。

#include <iostream>
using namespace std;

class A
{
private:
	static int value;
	static int sum;
public:
	A()
	{
		sum += value;
		value++;		
	}
	int GetSum()
	{
		return sum;
	}
};
int A::value = 1;
int A::sum = 0;

void Solve( int n )
{	
	for( int i=1; i<=n-1; i++ )
	{
		A a;		
	}
	A b;
	cout << b.GetSum() << endl;
}

int main()
{
	int n = 100;
	Solve( n );
	return 0;
}

有人说，用模板元解决。模板元什么东东？

第13题：输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。

 

还是用两个指针。两个指针距离为k，其中一个指向链表第一个元素。然后，同步移动这两个指针，直到链表末尾。 

第14题：输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。要求时间复杂度是O(n)。如果有多对数字的和等于输入的数字，输出任意一对即可。例如输入数组1、2、4、7、11、15和数字15。由于4+11=15，因此输出4和11。

 

         因为数组是有序的，所以难度减小了不少。两个指针，一个指向头、一个指向尾。求两个指针所指元素的和，如果和比目标数字小，前端指针++，如果和比目标数字大，后端指针--.

第15题：输入一颗二元查找树，将该树转换为它的镜像，即在转换后的二元查找树中，左子树的结点都大于右子树的结点。用递归和循环两种方法完成树的镜像转换。  例如输入：
   8
   / \
 6   10
 /\   /\
5  7  9 11

输出：
     8
   /  \
 10    6
 /  \    /\
11  9  7  5

 

递归处理。先处理左子树、再处理右子树。处理的时候，只要交换左右指针即可。

非递归处理。层序遍历，使用队列，队列中存储指向节点的指针。 

第16题：（微软）：输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印。 
层序遍历，使用队列，不解释。

第17题：在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b。 （2006年google的一道笔试题）

 

       使用hash。字符的取值范围：0---255。Hash函数：f( x ) = x对应的ASIC值。使用一个int cnt[256]。然后，在数组中统计每个字符出现的次数。 

第18题： n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始，每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。当一个数字删除后，从被删除数字的下一个继续删除第m个数字。
求出在这个圆圈中剩下的最后一个数字。 

约瑟夫环问题。怎么做？？？ 

第19题：定义Fibonacci数列如下： 
      /    0               n=0
f(n)=      1               n=1
      \    f(n-1)+f(n-2)      n>=2

输入n，用最快的方法求该数列的第n项。

 

        当然，不能直接使用递归了，因为递归会有很多重复的计算。最起码应该用记忆化搜索，需要存储f[n]的值，记忆化搜索空间复杂度O( n )。当然，最好使用DP，也不用打表，只需要记录前两项的值，时间复杂度O( n )，空间复杂度O( 1 )。 

第20题：输入一个表示整数的字符串，把该字符串转换成整数并输出。例如输入字符串"345"，则输出整数345。 

已讨论好多遍了，不过多解释。注意几个问题：1.正负号 2.非法字符 3.各种进制 4.防止溢出 5.字符串转成整数值。