最近几天的面试题

最近两天连续面了四次，公司就不说了。觉得对我来说心态还是很重要的因素。

还是说题目吧：

1.1 求连通图个数

题目：

一个二维数组（M*N），每一个元素可以是任意26个小写字母。如果数组中一个字母和周围（上下左右）任意一个字母相同，则将这些字母一起看做一个“块”。给定一个二维数组，求包含块的多少。

思路：

有点求最小连通图的味道。申请一个M*N的数组status用于记录元素处理的状态：没有处理过的就为0，处理过的就为1。依次扫描数组中每一个元素，对于每一个元素，将周围（上下左右）和其相等的元素的状态置为1，并且递归处理这些元素。

代码：

#include</usr/include/stdio.h>
#define MAX_M 1000
#define MAX_N 1000

int status[MAX_M][MAX_N];
void setNeighber(char *a, int m,int n,int m_size, int n_size);

int func(char *a, int m,int n)
{
int i,j;
int result=0;
if(m<=0 || n<=0 || m>MAX_M || n>MAX_N || a==NULL)
return -1;

for(i=0;i<m;i++)
for(j=0;j<n;j++)
{
if(status[i][j]==0)
{
result++;
setNeighber(a,i,j,m,n);
}

}
return result;

}

void setNeighber(char *a, int m,int n,int m_size,int n_size)
{
status[m]
=1;
if(m>0 && status[m-1]
==0 && a[m*n_size+n]==a[(m-1)*n_size+n])
setNeighber(a,m-1,n,m_size,n_size);
if(m<m_size-1 && status[m+1]
==0 && a[m*n_size+n]==a[(m+1)*n_size+n])
setNeighber(a,m+1,n,m_size,n_size);
if(n>0 && status[m][n-1]==0 && a[m*n_size+n]==a[m*n_size+n-1])
setNeighber(a,m,n-1,m_size,n_size);
if(n<n_size-1 && status[m][n+1]==0 && a[m*n_size+n]==a[m*n_size+n+1])
setNeighber(a,m,n+1,m_size,n_size);
}

int main(int argc,char * argv[])
{
char a[4][4]={
'a','c','d','d',
'a','a','c','d',
'b','b','b','d',
'e','a','d','d',
};//此用例输出7
printf("%d",func(a,4,4));
return 0;
}

1.2 二叉查找树问题

题目：

给定一个二叉查找树和一个元素（假设key为int）：如果这个元素在树中则返回所在的结点；不在该树中则返回小于该元素的最大数所在的结点。

思路：

考察二叉查找树的性质：（左孩子<=根结点<=右孩子）。根据这个性质进行二分查找，会出现两种情况：

找到该元素，返回其所在结点。
找不到元素，必定到达某个叶子结点某个孩子结点（为NULL指针），又分两种情况：

找到某个叶子结点的右孩子，返回这个叶子结点
找到某个叶子结点的左孩子，返回查找路径中的最后一个小于该元素的结点（即最后一个向右拐的结点）。

代码：

#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
struct Node* left;
struct Node* right;
int element;
} *TreeNode;

TreeNode find(TreeNode root,int m)
{
TreeNode TmpNode = root;
TreeNode result = NULL;
while(TmpNode != NULL)
{
if(TmpNode->element == m)
{
printf("Found!The node <= %d is %d.\n",m,TmpNode->element);
return TmpNode;
}
else if(TmpNode->element > m)
TmpNode = TmpNode->left;
else
{
result = TmpNode;
TmpNode = TmpNode->right;
}
}
if(result== NULL)
printf("Not found!\n");
else
printf("Found!The node <= %d is %d.\n",m,result->element);
return result;
}

int main(int argc,char* argv[])
{
TreeNode root = (TreeNode)malloc(sizeof(struct Node));
TreeNode node01 = (TreeNode)malloc(sizeof(struct Node));
TreeNode node02 = (TreeNode)malloc(sizeof(struct Node));
TreeNode node21 = (TreeNode)malloc(sizeof(struct Node));
TreeNode pResult = NULL;

root->element = 20;
node01->element = 10;
node02->element = 30;
node21->element = 25;

root->left = node01;
root->right = node02;
node01->left = NULL;
node01->right = NULL;
node02->left = node21;
node02->right = NULL;
node21->left = NULL;
node21->right = NULL;

pResult=find(root,10);
pResult=find(root,20);
pResult=find(root,25);
pResult=find(root,30);

pResult=find(root,15);
pResult=find(root,22);
pResult=find(root,28);

pResult=find(root,40);

return 0;

}

output

:! gcc -Wall -O ms2.c -o ms2
:!./ms2
Found!The node <= 10 is 10.
Found!The node <= 20 is 20.
Found!The node <= 25 is 25.
Found!The node <= 30 is 30.
Found!The node <= 15 is 10.
Found!The node <= 22 is 20.
Found!The node <= 28 is 25.
Found!The node <= 40 is 30.

1.3.1海量数据处理的一个问题

答案无非就是：hash划分成内存可以放下的小文件；在对应的小文件中求解。

1.3.2带有random指针的单向链表的复制问题

题目：

一个特殊的单链表，除了带有一个element元素（不妨设为int），和指向下一个结点的next指针外，还带有个一个特殊的random指针：该指针随机的指向该链表中的任意一个元素。给定一个这样的链表，“克隆”一个。

思路：

直接复制肯定不行，因为新旧链表中的random指针的值（即新旧结点中结点的地址）发生了变化。
解法1：一个简单的方法为：先扫描一遍原链表，复制element和next指针。再扫描一个原链表，对每个结点的random指针，判断其所指向的结点在原链表中的位置，即从头开始next几次和random相等(注意：必须根据next和random相等来判断是否是这个结点，而不应该根据)。将目标链表中的对应结点的地址赋给对应结点的random指针。时间复杂度为O（n^2）。
解法2：其实非常非常非常简单！我们要的只是新旧链表的一个对应关系，so，只要用一个（旧链表结点地址->新链表结点地址）的map就行了！仅扫描两遍（第一遍建立新链表，并建立map，第二遍只需根据map给新链表的结点赋值就行了）就可以了。
当时只想起这个方法，感觉肯定存在线性算法，但死活想不出来了，然后还没走回宿舍就想起来了……

2.1.经典的快排代码

注意：

可以优化的地方有两个：

取划分元素的时候不是随机取，而是随机取三个，用中间那个来划分，这样可以一定程提高效率。
当元素数小于某个阈值的时候，可以用插入、冒泡、选择等简单排序方法，而不是继续递归。

代码：

2.2.上台阶的方法问题

题目：

N阶台阶，一次可以上1层或2层，问有多少种上台阶的方法。

思路：

递推：
解法1：假设用f(n)表示上n阶台阶的方法。则上完n-1阶只需在上一层就可以；上完n-2阶只需上2层就可以了。所以f(n)=f(n-1)+f(n-2)（其实就是那个斐波那契数列）。可能有人觉得上完n-2阶后，剩下两阶有两种方法，但是上两个1阶的方法已经在前一项f(n-1)中包含了，再算上的话就重复了。可能解法2的思路更清晰。
解法2：不是从最后考虑，而是从第一步考虑：第一步上1阶，剩下有f(n-1)种方法；第一步上2阶，剩下有f(n-2)种方法。所以f(n)=f(n-1)+f(n-2)。

3. 8/18/2012

3.1

3.1.1 求多精度浮点数x的n次幂。

3.1.2 序列化和发序列化二叉树

http://blog.csdn.net/ssjhust123/article/details/7777665

3.2

3.2.1 股票一年中每天的价格曲线，只能买入卖出一次，求最大收益。假设买入数量一定。

3.2.2 the k-th biggest

3.3 将一个字符串转化为ASCII码。