微软等面试100题系列--（1-20）

1.把二元查找树转变成排序的双向链表

题目：

输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。

要求不能创建任何新的结点，只调整指针的指向。

10

/ /

6 14

/ / / /

4 8 12 16

转换成双向链表

4=6=8=10=12=14=16。

首先我们定义的二元查找树 节点的数据结构如下：

struct BSTreeNode

{

int m_nValue; // value of node

BSTreeNode *m_pLeft; // left child of node

BSTreeNode *m_pRight; // right child of node

};

解法：中序遍历

void change(Node *p, Node *&last) //中序遍历

{

if (!p)

return;

change(p->left, last);

if (last)

last->right = p;

p->left = last;

last = p;

change(p->right, last);

}

void main()

{

Node *root = create();

Node *tail = NULL;

change(root, tail);

while (tail)

{

cout << tail->data << " ";

tail = tail->left;

}

cout << endl;

}

2.设计包含min函数的栈。

定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。

要求函数min、push以及pop的时间复杂度都是O(1)。

结合链表一起做。

首先我做插入以下数字：10，7，3，3，8，5，2， 6

0: 10 -> NULL (MIN=10, POS=0)

1: 7 -> [0] (MIN=7, POS=1) 用数组表示堆栈，第0个元素表示栈底

2: 3 -> [1] (MIN=3, POS=2)

3: 3 -> [2] (MIN=3, POS=3)

4: 8 -> NULL (MIN=3, POS=3) 技巧在这里，因为8比当前的MIN大，所以弹出8不会对当前的MIN产生影响

5：5 -> NULL (MIN=3, POS=3)

6: 2 -> [2] (MIN=2, POS=6) 如果2出栈了，那么3就是MIN

7: 6 -> [6]

出栈的话采用类似方法修正。

所以，此题的第1小题，即是借助辅助栈，保存最小值，

且随时更新辅助栈中的元素。

如先后，push 2 6 4 1 5

stack A stack B（辅助栈）

4: 5 1 //push 5,min=p->[3]=1 ^

3: 1 1 //push 1,min=p->[3]=1 | //此刻push进A的元素1小于B中栈顶元素2

2: 4 2 //push 4,min=p->[0]=2 |

1: 6 2 //push 6,min=p->[0]=2 |

0: 2 2 //push 2,min=p->[0]=2 |

push第一个元素进A，也把它push进B，

当向Apush的元素比B中的元素小， 则也push进B，即更新B。否则，不动B，保存原值。

向栈A push元素时，顺序由下至上。

辅助栈B中，始终保存着最小的元素。

然后，pop栈A中元素，5 1 4 6 2

A B ->更新

4: 5 1 1 //pop 5,min=p->[3]=1 |

3: 1 1 2 //pop 1,min=p->[0]=2 |

2: 4 2 2 //pop 4,min=p->[0]=2 |

1: 6 2 2 //pop 6,min=p->[0]=2 |

0: 2 2 NULL //pop 2,min=NULL v

当pop A中的元素小于B中栈顶元素时，则也要pop B中栈顶元素。

---------------------------------------------------

template<typename T>

class StackSuppliedMin{

public:

vector<T> datas;

vector<size_t> minStack;

void push(T data){

datas.push_back(data);

if (minStack.empty() || data < datas[minStack.back()])

minStack.push_back(datas.size()-1);

}

void pop(){

assert(!datas.empty());

if (datas.back() == datas[minStack.back()])

minStack.pop_back();

datas.pop_back();

}

T min(){

assert(!datas.empty() && !minStack.empty());

return datas[minStack.back()];

}

void display();

};

3.求子数组的最大和

题目：

输入一个整形数组，数组里有正数也有负数。

数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

求所有子数组的和的最大值。要求时间复杂度为O(n)。

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，

因此输出为该子数组的和18。

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

题目：输入一个整数和一棵二元树。

从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。

打印出和与输入整数相等的所有路径。

例如 输入整数22和如下二元树

10

/ /

5 12

/ /

4 7

则打印出两条路径：10, 12和10, 5, 7。

二元树节点的数据结构定义为：

struct BinaryTreeNode // a node in the binary tree

{

int m_nValue; // value of node

BinaryTreeNode *m_pLeft; // left child of node

BinaryTreeNode *m_pRight; // right child of node

};

当访问到某一结点时，把该结点添加到路径上，并累加当前结点的值。如果当前结点为叶结点并且当前路径的和刚好等于输入的整数，则当前的路径符合要求，我们把它打印出来。

如果当前结点不是叶结点，则继续访问它的子结点。当前结点访问结束后，递归函数将自动回到父结点。

因此我们在函数退出之前要在路径上删除当前结点并减去当前结点的值，以确保返回父结点时路径刚好是根结点到父结点的路径。

我们不难看出保存路径的数据结构实际上是一个栈结构，因为路径要与递归调用状态一致，而递归调用本质就是一个压栈和出栈的过程。

void FindPath

(

BinaryTreeNode* pTreeNode, // a node of binary tree

int expectedSum, // the expected sum

std::vector<int>& path, // a path from root to current node

int& currentSum // the sum of path

)

{

if(!pTreeNode)

return;

currentSum += pTreeNode->m_nValue;

path.push_back(pTreeNode->m_nValue);

bool isLeaf = (!pTreeNode->m_pLeft && !pTreeNode->m_pRight);

if(currentSum == expectedSum && isLeaf)

{

std::vector<int>::iterator iter = path.begin();

for(; iter != path.end(); ++ iter)

std::cout << *iter << '/t';

std::cout << std::endl;

}

// if the node is not a leaf, goto its children

if(pTreeNode->m_pLeft)

FindPath(pTreeNode->m_pLeft, expectedSum, path, currentSum);

if(pTreeNode->m_pRight)

FindPath(pTreeNode->m_pRight, expectedSum, path, currentSum);

currentSum -= pTreeNode->m_nValue;

path.pop_back();

}

5.查找最小的k个元素

题目：输入n个整数，输出其中最小的k个。

例如输入1，2，3，4，5，6，7和8这8个数字，

则最小的4个数字为1，2，3和4。

解法：k个元素的最大堆，快排思想的划分

第6题

------------------------------------

腾讯面试题：

给你10分钟时间，根据上排给出十个数，在其下排填出对应的十个数

要求下排每个数都是先前上排那十个数在下排出现的次数。

上排的十个数如下：

【0，1，2，3，4，5，6，7，8，9】

初看此题，貌似很难，10分钟过去了，可能有的人，题目都还没看懂。

举一个例子，

数值: 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次....

以此类推..

// 引用自July 2010年10月18日。

//数值: 0,1,2,3,4,5,6,7,8,9

//分配: 6,2,1,0,0,0,1,0,0,0

详细数学推导：http://blog.csdn.net/stormbjm/article/details/8890627

第7题

------------------------------------

微软亚院之编程判断俩个链表是否相交

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

为了简化问题，我们假设俩个链表均不带环。

问题扩展：

1.如果链表可能有环列?

2.如果需要求出俩个链表相交的第一个节点列?

1.首先假定链表不带环

那么，我们只要判断俩个链表的尾指针是否相等。

相等，则链表相交；否则，链表不相交。

2.如果链表带环，

那判断一链表上俩指针相遇的那个节点，在不在另一条链表上。

如果在，则相交，如果不在，则不相交。

所以，事实上，这个问题就转化成了：

1.先判断带不带环

2.如果都不带环，就判断尾节点是否相等

3.如果都带环，判断一链表上俩指针相遇的那个节点，在不在另一条链表上。

如果在，则相交，如果不在，则不相交。

//用两个指针，一个指针步长为1，一个指针步长为2，判断链表是否有环

bool check(const node* head)

{

if(head==NULL)

return false;

node *low=head, *fast=head->next;

while(fast!=NULL && fast->next!=NULL)

{

low=low->next;

fast=fast->next->next;

if(low==fast) return true;

}

return false;

}

//如果链表可能有环，则如何判断两个链表是否相交

//思路：链表1 步长为1，链表2步长为2 ，如果有环且相交则肯定相遇，否则不相交

list1 head: p1

list2 head: p2

while( p1 != p2 && p1 != NULL && p2 != NULL )

//但当链表有环但不相交时，此处是死循环。!

{

p1 = p1->next;

if ( p2->next )

p2 = p2->next->next;

else

p2 = p2->next;

}

if ( p1 == p2 && p1 && p2)

//相交

else

//不相交

所以，判断带环的链表，相不相交，只能这样：

如果都带环，判断一链表上俩指针相遇的那个节点，在不在另一条链表上。

如果在，则相交，如果不在，则不相交。(未写代码实现，见谅。:)..

------------------

第8题（算法）

此贴选一些 比较怪的题，，由于其中题目本身与算法关系不大，仅考考思维。特此并作一题。

1.有两个房间，一间房里有三盏灯，另一间房有控制着三盏灯的三个开关，

这两个房间是 分割开的，从一间里不能看到另一间的情况。

现在要求受训者分别进这两房间一次，然后判断出这三盏灯分别是由哪个开关控制的。

有什么办法呢？

思路：摸一摸热不热

2.你让一些人为你工作了七天，你要用一根金条作为报酬。金条被分成七小块，每天给出一块。

如果你只能将金条切割两次，你怎样分给这些工人?

思路：把金条分成三段（就是分两次，或者切两刀），分别是整根金条的1/7、2/7 4/7 第一天：给1/7的， 第二天：给2/7的，收回1/7的 第三天，给1/7的 第四天：给4/7的，收回1/7和2/7的 第五天：给1/7的 第六天：给2/7的，收回1/7的

3.　★用一种算法来颠倒一个链接表的顺序。现在在不用递归式的情况下做一遍。

　　★用一种算法在一个循环的链接表里插入一个节点，但不得穿越链接表。

　　★用一种算法整理一个数组。你为什么选择这种方法?

　　★用一种算法使通用字符串相匹配。

　　★颠倒一个字符串。优化速度。优化空间。

　　★颠倒一个句子中的词的顺序，比如将“我叫克丽丝”转换为“克丽丝叫我”，

实现速度最快，移动最少。

　　★找到一个子字符串。优化速度。优化空间。

　　★比较两个字符串，用O(n)时间和恒量空间。

　　★假设你有一个用1001个整数组成的数组，这些整数是任意排列的，但是你知道所有的整数都在1到1000(包括1000)之间。此外，除一个数字出现两次外，其他所有数字只出现一次。假设你只能对这个数组做一次处理，用一种算法找出重复的那个数字。如果你在运算中使用了辅助的存储方式，那么你能找到不用这种方式的算法吗?

　　★不用乘法或加法增加8倍。现在用同样的方法增加7倍。

第9题（树）

判断整数序列是不是二元查找树的后序遍历结果

题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。

如果是返回true，否则返回false。

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

8

/ /

6 10

/ / / /

5 7 9 11

因此返回true。

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

July：

int is_post_traverse(int *arr, int len)

{

int *head, *pos, *p;

if (arr == NULL || len <= 0)

return 0;

if (len == 1)

return 1;

head = arr + len - 1;

p = arr;

while (*p < *head)

p++;

pos = p;

while (p < head)

{

if (*p < *head)

return 0;

p++;

}

if (!is_post_traverse(arr, pos - arr))

return 0;

return is_post_traverse(pos, head - pos);

}

第10题（字符串）

翻转句子中单词的顺序。

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

句子中单词以空格符隔开。为简单起见，标点符号和普通字母一样处理。

例如输入“I am a student.”，则输出“student. a am I”。

#include<iostream>

#include<string>

using namespace std;

class ReverseWords{

public:

ReverseWords(string* wo):words(wo){}

void reverse_()

{

int length=words->size();

int begin=-1,end=-1;

for(int i=0;i<length;++i){

if(begin==-1&&words->at(i)==' ')

continue;

if(begin==-1)

{

begin=i;

continue;

}

if(words->at(i)==' ')

end=i-1;

else if(i==length-1)

end=i;

else

continue;

reverse__(begin,end); //1.字母翻转

begin=-1,end=-1;

}

reverse__(0,length-1); //2.单词翻转

}

private:

void reverse__(int begin,int end) //

{

while(begin<end)

{

char t=words->at(begin);

words->at(begin)=words->at(end);

words->at(end)=t;

++begin;

--end;

}

}

string* words;

};

int main(){

string s="I am a student.";

ReverseWords r(&s);

r.reverse_();

cout<<s<<endl;

return 0;

}

运行结果：

student. a am I

Press any key to continue

第11题（树）

求二叉树中节点的最大距离...

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，

我们姑且定义"距离"为两节点之间边的个数。

写一个程序，

求一棵二叉树中相距最远的两个节点之间的距离

计算一个二叉树的最大距离有两个情况:

* 情况A: 通过根节点，路径经过左子树的最深节点，再到右子树的最深节点。

* 情况B: 不通过根节点，而是左子树或右子树的最大距离路径，取其大者。

只需要计算这两个情况的路径距离，并取其大者，就是该二叉树的最大距离。

RESULT GetMaximumDistance(NODE* root)

{

if (!root)

{

RESULT empty = { 0, -1 };

// trick: nMaxDepth is -1 and then caller will plus 1 to balance it as zero.

return empty;

}

RESULT lhs = GetMaximumDistance(root->pLeft);

RESULT rhs = GetMaximumDistance(root->pRight);

RESULT result;

//nMaxDepth 就是左子树或右子树的深度加1；

result.nMaxDepth = max(lhs.nMaxDepth + 1, rhs.nMaxDepth + 1);

//nMaxDistance 则取A和B情况的最大值。

result.nMaxDistance =

max(max(lhs.nMaxDistance, rhs.nMaxDistance), lhs.nMaxDepth + rhs.nMaxDepth + 2);

//B：不通过根节点时，取左右子树中最大距离的大值，A：通过根节点，左+右+2.

return result;

}

第12题

题目：求1+2+…+n，

要求不能使用乘除法、for、while、if、else、switch、case等关键字

以及条件判断语句（A?B:C）

思路：递归。 或new n个对象，构造函数累加

第13题：

题目：

输入一个单向链表，输出该链表中倒数第k个结点,

链表的倒数第0个结点为链表的尾指针。

第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题

题目：输入一颗二元树，从上往下按层打印树的每个结点，同一层中按照从左往右的顺序打印。

例如输入

8

/ /

6 10

// //

5 7 9 11

输出8 6 10 5 7 9 11。

第17题：

题目：在一个字符串中找到第一个只出现一次的字符。

如输入abaccdeff，则输出b。

这道题是2006年google的一道笔试题。

思路剖析：由于题目与字符出现的次数相关，我们可以统计每个字符在该字符串中出现的次数.

要达到这个目的，需要一个数据容器来存放每个字符的出现次数。

第18题：

题目：n个数字（0,1,…,n-1）形成一个圆圈，从数字0开始，

每次从这个圆圈中删除第m个数字（第一个为当前数字本身，第二个为当前数字的下一个数字）。

当一个数字删除后，从被删除数字的下一个继续删除第m个数字。

求出在这个圆圈中剩下的最后一个数字。

第19题：

题目：定义Fibonacci数列如下：

/ 0 n=0

f(n)= 1 n=1,2

/ f(n-1)+f(n-2) n>2

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

第20题：

题目：输入一个表示整数的字符串，把该字符串转换成整数并输出。

例如输入字符串"345"，则输出整数345。

1.转换的思路：每扫描到一个字符，我们把在之前得到的数字乘以10再加上当前字符表示的数字。这个思路用循环不难实现。

2.由于整数可能不仅仅之含有数字，还有可能以'+'或者'-'开头，表示整数的正负。

如果第一个字符是'+'号，则不需要做任何操作；如果第一个字符是'-'号，则表明这个整数是个负数，在最后的时候我们要把得到的数值变成负数。

3.接着我们试着处理非法输入。

由于输入的是指针，在使用指针之前，我们要做的第一件是判断这个指针是不是为空。如果试着去访问空指针，将不可避免地导致程序崩溃。

4.输入的字符串中可能含有不是数字的字符。

每当碰到这些非法的字符，我们就没有必要再继续转换。

最后一个需要考虑的问题是溢出问题。由于输入的数字是以字符串的形式输入，

因此有可能输入一个很大的数字转换之后会超过能够表示的最大的整数而溢出。