最近两天连续面了四次,公司就不说了。觉得对我来说心态还是很重要的因素。
还是说题目吧:
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):如果这个元素在树中则返回所在的结点;不在该树中则返回小于该元素的最大数所在的结点。
思路:
考察二叉查找树的性质:(左孩子<=根结点<=右孩子)。根据这个性质进行二分查找,会出现两种情况:
- 找到该元素,返回其所在结点。
- 找不到元素,必定到达某个叶子结点某个孩子结点(为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)。