最近几天的面试题

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

还是说题目吧：

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][n]=1;
        if(m>0 && status[m-1][n]==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][n]==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）：如果这个元素在树中则返回所在的结点；不在该树中则返回小于该元素的最大数所在的结点。

思路：

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

1. 找到该元素，返回其所在结点。
2. 找不到元素，必定到达某个叶子结点某个孩子结点（为NULL指针），又分两种情况：
   1. 找到某个叶子结点的右孩子，返回这个叶子结点
   2. 找到某个叶子结点的左孩子，返回查找路径中的最后一个小于该元素的结点（即最后一个向右拐的结点）。

代码：

#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.经典的快排代码

注意：

可以优化的地方有两个：

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

代码：

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码。