算法与数据结构面试题(转自网络)

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

};

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

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

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

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

};

5.查找最小的k个元素(采用小根堆 和 大根堆 来解决)

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

例如输入1,2,3,4,5,6,7和8这8个数字,则最小的4个数字为1,2,3和4。

public static void FindKMin(int[] sort, int k)
{
int[] heap = sort;
int rootIndex = k / 2 - 1;
while (rootIndex >= 0)
{
reheap(heap, rootIndex, k - 1);
rootIndex--;
}

for (int i = k, len=heap.Length; i < len; i++)
{
    if (heap[i]<heap[0])
    {
        heap[0] = heap[i];
        reheap(heap, 0, k - 1);
    }
}

Console.WriteLine("The {0} min element =",k);
for (int i = 0; i < k; i++)
{
    Console.Write(heap[i] + " ");
}

}

private static void reheap(int[] heap, int rootIndex, int lastInddex)
{
int orphan = heap[rootIndex];
bool done = false;
int leftIndex = rootIndex * 2 + 1;
while (!done && leftIndex <= lastInddex)
{
int largerIndex = leftIndex;
if (leftIndex+1 <= lastInddex)
{
int rightIndex = leftIndex + 1;
if (heap[rightIndex] > heap[leftIndex])
{
largerIndex = rightIndex;
}
}

    if (orphan < heap[largerIndex])
    {
        heap[rootIndex] = heap[largerIndex];
        rootIndex = largerIndex;
        leftIndex = rootIndex * 2 + 1;
    }
    else
    {
        done = true;
    }
}

heap[rootIndex] = orphan;

}

第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次....

以此类推..

完整代码如下:

include<iostream>

using namespace std;
const int Len = 4;
bool isLegal(int* A,int n)
{
for(int i=0;i<n;++i)
{
int count=0;
for(int j=0;j<n;++j)
{
if(i==A[j])
++count;
}
if(A[i] != count)
return false;
}
return true;
}
void ArrayF(int* A,int n,int Sum)
{
if(!A || n < 1 || Sum < 1)//处理异常,A==NULL,n <=0,Sum<1
return ;
if( n==1 )
{
A[0]=Sum;
if(isLegal(A,Len))
{
for(int i=0;i<Len;++i)
cout<<A[i]<<' ';
cout<<endl;
}
}
else
{
for(int i=0;i<=Sum;++i)
{
A[n-1]=i;
ArrayF(A,n-1,Sum-i);
}
}
}
void main()
{
int A[20]={0};
ArrayF(A,Len,Len);
}

第7题

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

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

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

问题扩展:

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

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

第8题
1.有两个房间,一间房里有三盏灯,另一间房有控制着三盏灯的三个开关,
这两个房间是 分割开的,从一间里不能看到另一间的情况。
现在要求受训者分别进这两房间一次,然后判断出这三盏灯分别是由哪个开关控制的。
有什么办法呢?
(先亮A灯一段时间,再关闭A灯亮B灯,进入有灯的房间,得出结论:亮着的是B灯,暗着的两盏灯中,热的灯是A灯,剩下的是C灯)

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

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

3. ★用一种算法来颠倒一个链接表的顺序。现在在不用递归式的情况下做一遍。
a1 -> a2 ->a3
第一对:(NULL,a1) ——开始
第二对:(a1,a2)
第三对:(a2,a3)
第四对:(a3,NULL) ——完毕
//非递归方式翻转
void Reverse_non_recursive(){
Node *pair1 = NULL;
Node *pair2 = head;
while (pair2 != NULL){
Node *temp = pair2->next;
pair2->next = pair1;
pair1 = pair2;
pair2 = temp;
}
head = pair1;
}

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

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

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

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

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

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

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

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

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

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

第9题

判断整数序列是不是二元查找树的后序遍历结果
(思路是序列最后一个必是根节点,从前往后遍历,比根节点小的都是其左子树,并且位于序列的左半部分,比其大的为其右子树,应该位于其右半部分。)

include <iostream>

using namespace std;

void test(const int data[],int start,int node,bool &flag){
if(flag&&start<node){ // 判断条件,注意start<node
int left=start;
while(data[node]>data[left]){ //取得其左子树
left++;
}
for(int j=left;j<node;j++){ //判断是否为其右子树
if(data[j]<data[node]) {flag=false; return;} //若
}
test(data,0,left-1,flag); //递归
test(data,left,node-1,flag);
}
}
int main(void){
bool flag=true;
int a[]={5,7,6,9,11,10,8};
test(a,0,6,flag);
if(flag) cout<<"yes"<<endl;
else cout<<"no"<<endl;
int b[]={7,4,6,5};
test(b,0,3,flag);
if(flag) cout<<"yes"<<endl;
else cout<<"no"<<endl;
system("pause");
return 0;
}

第10题

翻转句子中单词的顺序。

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

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

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

第11题

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

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

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

写一个程序,

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

第12题

题目:求1+2+…+n,

要求不能使用乘除法、for、while、if、else、switch、case等关键字以及条件判断语句(A?B:C)。

第13题:

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

链表结点定义如下:

struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

第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

定义二元查找树的结点为:

struct BSTreeNode // a node in the binary search tree (BST)

{

int m_nValue; // value of node

BSTreeNode *m_pLeft; // left child of node

BSTreeNode *m_pRight; // right child of node

};

第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个数字。

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

July:我想,这个题目,不少人已经 见识过了。

第19题:

题目:定义Fibonacci数列如下:

/ 0 n=0

f(n)= 1 n=1

\ f(n-1)+f(n-2) n=2

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

分析:在很多C语言教科书中讲到递归函数的时候,都会用Fibonacci作为例子。

因此很多程序员对这道题的递归解法非常熟悉,但....呵呵,你知道的。。

第20题:

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

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

第21题

2010年中兴面试题

编程求解:

输入两个整数 n 和 m,从数列1,2,3.......n 中 随意取几个数,

使其和等于 m ,要求将其中所有的可能组合列出来.

第22题:

有4张红色的牌和4张蓝色的牌,主持人先拿任意两张,再分别在A、B、C三人额头上贴任意两张牌,

A、B、C三人都可以看见其余两人额头上的牌,看完后让他们猜自己额头上是什么颜色的牌,

A说不知道,B说不知道,C说不知道,然后A说知道了。

请教如何推理,A是怎么知道的。

如果用程序,又怎么实现呢?

第23题:

用最简单,最快速的方法计算出下面这个圆形是否和正方形相交。"

3D坐标系 原点(0.0,0.0,0.0)

圆形:

半径r = 3.0

圆心o = (., 0.0, .)

正方形:

4个角坐标;

1:(., 0.0, .)

2:(., 0.0, .)

3:(., 0.0, .)

4:(., 0.0, .)

第24题:

链表操作,

(1).单链表就地逆置,

(2)合并链表

第25题:

写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)

功能:

在字符串中找出连续最长的数字串,并把这个串的长度返回,

并把这个最长数字串付给其中一个函数参数outputstr所指内存。

例如:"abcd12345ed125ss123456789"的首地址传给intputstr后,函数将返回9,

outputstr所指的值为123456789

26.左旋转字符串

题目:

定义字符串的左旋转操作:把字符串前面的若干个字符移动到字符串的尾部。

如把字符串abcdef左旋转2位得到字符串cdefab。请实现字符串左旋转的函数。

要求时间对长度为n的字符串操作的复杂度为O(n),辅助内存为O(1)。

27.跳台阶问题(其实这是斐波拉茨公式)

题目:一个台阶总共有n级,如果一次可以跳1级,也可以跳2级。

求总共有多少总跳法,并分析算法的时间复杂度。
/----------------------------
Copyright by yuucyf. 2011.08.16
-----------------------------
/

include "stdafx.h"

include <iostream>

using namespace std;

int JumpStep(int n)
{
if (n <= 0) return 0;
if (n == 1 || n == 2) return n;
return (JumpStep(n-1) + JumpStep(n-2));
}

int _tmain(int argc, _TCHAR* argv[])
{
int nStep = 0;
cout << "请输入台阶数:";
cin >> nStep;
cout << "台阶数为" << nStep << ",那么总共有" << JumpStep(nStep) << "种跳法." << endl;
return 0;
}

这道题最近经常出现,包括MicroStrategy等比较重视算法的公司

都曾先后选用过个这道题作为面试题或者笔试题。

28.整数的二进制表示中1的个数

题目:输入一个整数,求该整数的二进制表达中有多少个1。

例如输入10,由于其二进制表示为1010,有两个1,因此输出2。
hamming_weight
int calculate_one(int n)
{
n = (n&0x55555555) + ((n>>1)&0x55555555);
n = (n&0x33333333) + ((n>>2)&0x33333333);
n = (n&0x0f0f0f0f) + ((n>>4)&0x0f0f0f0f);
n = (n&0x00ff00ff) + ((n>>8)&0x00ff00ff);
n = (n&0x0000ffff) + ((n>>16)&0x0000ffff);
return n;
}

方法二
int calculate_one(int n)
{
int count=0;
while(n != 0){
n &= n-1;
count ++;
}
return count;
}

29.栈的push、pop序列

题目:输入两个整数序列。其中一个序列表示栈的push顺序,

判断另一个序列有没有可能是对应的pop顺序。

为了简单起见,我们假设push序列的任意两个整数都是不相等的。

比如输入的push序列是1、2、3、4、5,那么4、5、3、2、1就有可能是一个pop系列。

因为可以有如下的push和pop序列:

push 1,push 2,push 3,push 4,pop,push 5,pop,pop,pop,pop,

这样得到的pop序列就是4、5、3、2、1。

但序列4、3、5、1、2就不可能是push序列1、2、3、4、5的pop序列。

思路是:让输入的push序列与pop序列的第一位相比较,如不同,则进栈,若相同,则跳过,同时pop序列的元素也向后移动一位。

include <iostream>

include <stack>

using namespace std;

bool isPopSerial(int push[], int pop[], int n)//我自己写的一种方法,注意函数名
{
int i=0,j=0;
stack<int> mystack;
while(i < n)//只要没有全部将push数组push到栈中
{
mystack.push(push[i]);
i++;
while(!mystack.empty() && mystack.top() == pop[j])
{
mystack.pop();
j++;
}

}
if( mystack.empty() && j==n)//最后是pop序列的唯一条件:栈变空了,且pop序列游标到了最后
    return true;
return false;//除此之外都不是pop序列

}

30.在从1到n的正数中1出现的次数

题目:输入一个整数n,求从1到n这n个整数的十进制表示中1出现的次数。

include<iostream>

2 #include<string>

3 using namespace std;

4

5 int NumbersOf1sFrom1ToN(unsigned int n)

6 {

7 int currentN = n;

8

9 //计数器

10 int cnt = 0;

11

12 //商,计算该数字包含多少个10,100,1000等

13 int quotient = 0;

14

15 //余数,计算除去“整”的包含,剩下的数字包含的1的个数

16 int remainder = 0;

17

18 //每一轮循环中的权重,分别记录10,100,1000中包含多少个位1,十位1,百位1;

19 int mult = 1;

20

21 while(currentN)

22 {

23 quotient = currentN / 10;

24 remainder = currentN % 10;

25

26 //包含多少个10,100,1000,乘以对应的数量的个位1,十位1,百位1

27 cnt += quotient * mult;

28

29 //余数大于1,多加一个该轮下的权重

30 if(remainder > 1)

31 {

32 cnt += mult;

33 }

34 //余数等于1

35 else if(remainder == 1)

36 {

37 cnt += n - currentN * mult + 1;

38 }

39

40

41 currentN = currentN / 10;

42 mult *= 10;

43 }

44

45 return cnt;

46 }

47

48 int main()

49 {

50 cout<<"please enter the number N:"<<endl;

51 unsigned int number = 0;

52 cin>>number;

53

54 cout<<"the number of 1s From 1 to N is:"<<endl;

55 cout<<NumbersOf1sFrom1ToN(number)<<endl;

56 return 0;
}

31.一类似于蜂窝的结构的图,进行搜索最短路径(要求5分钟)
迪杰斯特拉算法

include <iostream>

include <iomanip>

include <string>

using namespace std;

define INFINITY 65535//无边时的权值

define MAX_VERTEX_NUM 10//最大顶点数

typedef struct MGraph{
string vexs[10];//顶点信息
int arcs[10][10];//邻接矩阵
int vexnum, arcnum;//顶点数和边数
}MGraph;

int LocateVex(MGraph G, string u)//返回顶点u在图中的位置
{
for(int i=0; i<G.vexnum; i++)
if(G.vexs[i]==u)
return i;
return -1;
}

void CreateDN(MGraph &G)//构造有向网
{
string v1, v2;
int w;
int i, j, k;
cout<<"请输入顶点数和边数:";
cin>>G.vexnum>>G.arcnum;

cout<<"请输入顶点:";
for(i=0; i<G.vexnum; i++)
    cin>>G.vexs[i];

for(i=0; i<G.vexnum; i++)
    for(j=0; j<G.vexnum; j++)
        G.arcs[i][j]=INFINITY;

cout<<"请输入边和权值:"<<endl;
for(k=0; k<G.arcnum; k++)
{
    cin>>v1>>v2>>w;
    i=LocateVex(G, v1);
    j=LocateVex(G, v2);
    G.arcs[i][j]=w;
}

}

//迪杰斯特拉算法求有向网G的v0顶点到其余顶点v的最短路径p[v]及带权长度D[v]
//p[][]=-1表示没有路径,p[v][i]存的是从v0到v当前求得的最短路径经过的第i+1个顶点(这是打印最短路径的关键),则v0到v的最短路径即为p[v][0]到p[v][j]直到p[v][j]=-1,路径打印完毕。
//final[v]为true当且仅当v∈S,即已经求得从v0到v的最短路径。
void ShortestPath_DIJ(MGraph G, int v0, int p[][MAX_VERTEX_NUM], int D[])
{
int v, w, i, j, min;
bool final[10];

for(v=0; v<G.vexnum; v++)
{
    final[v]=false;//设初值
    D[v]=G.arcs[v0][v];//D[]存放v0到v得最短距离,初值为v0到v的直接距离
    for(w=0; w<G.vexnum; w++)
        p[v][w]=-1;//设p[][]初值为-1,即没有路径
    if(D[v]<INFINITY)//v0到v有直接路径
    {
        p[v][0]=v0;//v0到v最短路径经过的第一个顶点
        p[v][1]=v;//v0到v最短路径经过的第二个顶点
    }
}

D[v0]=0;//v0到v0距离为0
final[v0]=true;//v0顶点并入S集

for(i=1; i<G.vexnum; i++)//其余G.vexnum-1个顶点
{//开始主循环,每次求得v0到某个顶点v的最短路径,并将v并入S集,然后更新p和D
    min=INFINITY;
    for(w=0; w<G.vexnum; w++)//对所有顶点检查
        if(!final[w] && D[w]<min)//在S集之外(即final[]=false)的顶点中找离v0最近的顶点,将其赋给v,距离赋给min
        {
            v=w;
            min=D[w];
        }
        final[v]=true;//v并入S集
        for(w=0; w<G.vexnum; w++)//根据新并入的顶点,更新不在S集的顶点到v0的距离和路径数组
        {
            if(!final[w] && min<INFINITY && G.arcs[v][w]<INFINITY && (min+G.arcs[v][w]<D[w]))
            {//w不属于S集且v0->v->w的距离<目前v0->w的距离
                D[w]=min+G.arcs[v][w];//更新D[w]
                for(j=0; j<G.vexnum; j++)//修改p[w],v0到w经过的顶点包括v0到v经过的所有顶点再加上顶点w
                {
                    p[w][j]=p[v][j];
                    if(p[w][j]==-1)//在p[w][]第一个等于-1的地方加上顶点w
                    {
                        p[w][j]=w;
                        break;
                    }
                }                   
                
            }
        }
}   

}

void main()
{
int i, j;
MGraph g;
CreateDN(g);
int p[MAX_VERTEX_NUM][MAX_VERTEX_NUM];//最短路径数组p
int D[MAX_VERTEX_NUM];//最短距离数组D
ShortestPath_DIJ(g, 0, p, D);

cout<<"最短路径数组p[i][j]如下:"<<endl;
for(i=0; i<g.vexnum; i++)
{
    for(j=0; j<g.vexnum; j++)
        cout<<setw(3)<<p[i][j]<<" ";
    cout<<endl;
}

cout<<g.vexs[0]<<"到各顶点的最短路径及长度为:"<<endl;
for(i=0; i<g.vexnum; i++)
{
    if(i!=0 && D[i]!=INFINITY)
    {
        cout<<g.vexs[0]<<"-"<<g.vexs[i]<<"的最短路径长度为:"<<D[i];
        cout<<"  最短路径为:";
        for(j=0; j<g.vexnum; j++)
        {
            if(p[i][j]>-1)
                cout<<g.vexs[p[i][j]]<<" ";
        }
        cout<<endl;         
    }
    else if(D[i]==INFINITY)
        cout<<g.vexs[0]<<"-"<<g.vexs[i]<<":"<<"不可达"<<endl;
}

}

有两个序列a,b,大小都为n,序列元素的值任意整数,无序;

要求:通过交换a,b中的元素,使[序列a元素的和]与[序列b元素的和]之间的差最小。

例如:

var a=[100,99,98,1,2, 3];

var b=[1, 2, 3, 4,5,40];

include "stdio.h"

include "stdlib.h"

void balanceArray(int a[],int b[],int n);
int sumArray(int a[],int n);

int main(void)
{
int i;
int a[5]={0,1,2,3,4},b[5]={5,6,7,8,9};
balanceArray(a,b,5);

for(i=0;i<5;i++)
    printf("%3d",a[i]);
printf("\n");   
for(i=0;i<5;i++)
    printf("%3d",b[i]);
    
printf("\n");
return 0;

}

void balanceArray(int a[],int b[],int n)
{
int p,q;
int i,j,itemDValue,sumDValue,tmp,flag=1;

if(sumArray(a,n) < sumArray(b,n))
{
    p = b;
    q = a;
}

while(flag)
{
    flag=!flag;
    for(i=0;i<n;i++)
    {   
        for(j=0;j<n;j++)
        {
            itemDValue = p[i]-q[j];
            sumDValue = sumArray(p,n) - sumArray(q,n);
            if((itemDValue < sumDValue)&&(itemDValue > 0))
            {
                flag=!flag;
                tmp = p[i];
                p[i] = q[j];
                q[j] = tmp;
            }
        }
    }       
}

}

int sumArray(int a[],int n)
{
int i,count=0;
for(i=0;i<n;i++)
count += a[i];
return count;
}

实现一个挺高级的字符匹配算法:

给一串很长字符串,要求找到符合要求的字符串,例如目的串:123

1******3***2 ,12*****3这些都要找出来

其实就是类似一些和谐系统。。。。。

实现一个队列。

队列的应用场景为:

一个生产者线程将int类型的数入列,一个消费者线程将int类型的数出列

求一个矩阵中最大的二维矩阵(元素和最大).如:

1 2 0 3 4

2 3 4 5 1

1 1 5 3 0

中最大的是:

4 5

5 3

要求:(1)写出算法;(2)分析时间复杂度;(3)用C写出关键代码
//非最优解

include<iostream>

using namespace std;

int max_matrix(int (*array)[5], int maxx, int maxy, int& posi, int& posj)
{
int max = 0;
int i = 0, j = 0;
while(i < maxx - 1)
{
j = 0;
while( j < maxy - 1)
{
int t = array[i][j] + array[i+1][j] + array[i][j+1] + array[i+1][j+1];
if( max < t)
{
max = t;
posi = i;
posj = j;
}
j ++;
}
i ++;
}
return max;
}

int main()
{
int a[3][5] = {{1,2,0,3,4}, {2,3,4,5,1}, {1,1,5,3,0}};
int i = 0, j = 0;
int max = max_matrix(a, 3, 5, i, j);
cout << "max num: " << max <<endl;
cout << "matrix: " << endl;
cout << a[i][j] << " " << a[i][j+1] << endl;
cout << a[i+1][j] << " " << a[i+1][j+1] << endl;

}

第36题-40题(有些题目搜集于CSDN上的网友,已标明):

36.引用自网友:longzuo

谷歌笔试:

n支队伍比赛,分别编号为0,1,2。。。。n-1,已知它们之间的实力对比关系,

存储在一个二维数组w[n][n]中,w[i][j] 的值代表编号为i,j的队伍中更强的一支。

所以w[i][j]=i 或者j,现在给出它们的出场顺序,并存储在数组order[n]中,

比如order[n] = {4,3,5,8,1......},那么第一轮比赛就是 4对3, 5对8。.......

胜者晋级,败者淘汰,同一轮淘汰的所有队伍排名不再细分,即可以随便排,

下一轮由上一轮的胜者按照顺序,再依次两两比,比如可能是4对5,直至出现第一名

编程实现,给出二维数组w,一维数组order 和 用于输出比赛名次的数组result[n],

求出result。

有n个长为m+1的字符串,

如果某个字符串的最后m个字符与某个字符串的前m个字符匹配,则两个字符串可以联接,

问这n个字符串最多可以连成一个多长的字符串,如果出现循环,则返回错误。

百度面试:

1.用天平(只能比较,不能称重)从一堆小球中找出其中唯一一个较轻的,使用x次天平,

最多可以从y个小球中找出较轻的那个,求y与x的关系式。
answer:二分法

2.有一个很大很大的输入流,大到没有存储器可以将其存储下来,

而且只输入一次,如何从这个输入流中随机取得m个记录。

3.大量的URL字符串,如何从中去除重复的,优化时间空间复杂度

网易有道笔试:

(1).

求一个二叉树中任意两个节点间的最大距离,

两个节点的距离的定义是 这两个节点间边的个数,

比如某个孩子节点和父节点间的距离是1,和相邻兄弟节点间的距离是2,优化时间空间复杂度。

(2).

求一个有向连通图的割点,割点的定义是,如果除去此节点和与其相关的边,

有向图不再连通,描述算法。

40.百度研发笔试题

引用自:zp155334877

1)设计一个栈结构,满足一下条件:min,push,pop操作的时间复杂度为O(1)。

2)一串首尾相连的珠子(m个),有N种颜色(N<=10),

设计一个算法,取出其中一段,要求包含所有N中颜色,并使长度最短。

并分析时间复杂度与空间复杂度。

3)设计一个系统处理词语搭配问题,比如说 中国 和人民可以搭配,

则中国人民 人民中国都有效。要求:

*系统每秒的查询数量可能上千次;

*词语的数量级为10W;

*每个词至多可以与1W个词搭配

当用户输入中国人民的时候,要求返回与这个搭配词组相关的信息。

41.求固晶机的晶元查找程序

晶元盘由数目不详的大小一样的晶元组成,晶元并不一定全布满晶元盘,

照相机每次这能匹配一个晶元,如匹配过,则拾取该晶元,

若匹配不过,照相机则按测好的晶元间距移到下一个位置。

求遍历晶元盘的算法 求思路。

42.请修改append函数,利用这个函数实现:

两个非降序链表的并集,1->2->3 和 2->3->5 并为 1->2->3->5

另外只能输出结果,不能修改两个链表的数据。

43.递归和非递归俩种方法实现二叉树的前序遍历。

44.腾讯面试题:

1.设计一个魔方(六面)的程序。

2.有一千万条短信,有重复,以文本文件的形式保存,一行一条,有重复。

请用5分钟时间,找出重复出现最多的前10条。

3.收藏了1万条url,现在给你一条url,如何找出相似的url。(面试官不解释何为相似)

45.雅虎:

1.对于一个整数矩阵,存在一种运算,对矩阵中任意元素加一时,需要其相邻(上下左右)

某一个元素也加一,现给出一正数矩阵,判断其是否能够由一个全零矩阵经过上述运算得到。

2.一个整数数组,长度为n,将其分为m份,使各份的和相等,求m的最大值

比如{3,2,4,3,6} 可以分成{3,2,4,3,6} m=1;

{3,6}{2,4,3} m=2

{3,3}{2,4}{6} m=3 所以m的最大值为3

46.搜狐:

四对括号可以有多少种匹配排列方式?比如两对括号可以有两种:()()和(())

47.创新工场:

求一个数组的最长递减子序列 比如{9,4,3,2,5,4,3,2}的最长递减子序列为{9,5,4,3,2}

48.微软:

一个数组是由一个递减数列左移若干位形成的,比如{4,3,2,1,6,5}

是由{6,5,4,3,2,1}左移两位形成的,在这种数组中查找某一个数。

49.一道看上去很吓人的算法面试题:

如何对n个数进行排序,要求时间复杂度O(n),空间复杂度O(1)

50.网易有道笔试:

1.求一个二叉树中任意两个节点间的最大距离,两个节点的距离的定义是 这两个节点间边的个数,

比如某个孩子节点和父节点间的距离是1,和相邻兄弟节点间的距离是2,优化时间空间复杂度。

2.求一个有向连通图的割点,割点的定义是,

如果除去此节点和与其相关的边,有向图不再连通,描述算法。


51.和为n连续正数序列。

题目:输入一个正数n,输出所有和为n连续正数序列。

例如输入15,由于1+2+3+4+5=4+5+6=7+8=15,所以输出3个连续序列1-5、4-6和7-8。

分析:这是网易的一道面试题。

52.二元树的深度。

题目:输入一棵二元树的根结点,求该树的深度。

从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。

例如:输入二元树:

                                        10

                                      /     \

                                    6        14

                                  /         /   \

                                4         12     16

输出该树的深度3。

二元树的结点定义如下:

struct SBinaryTreeNode // a node of the binary tree

{

  int               m_nValue; // value of node

  SBinaryTreeNode *m_pLeft; // left child of node

  SBinaryTreeNode *m_pRight; // right child of node

};

分析:这道题本质上还是考查二元树的遍历。

53.字符串的排列。

题目:输入一个字符串,打印出该字符串中字符的所有排列。

例如输入字符串abc,则输出由字符a、b、c所能排列出来的所有字符串

abc、acb、bac、bca、cab和cba。

分析:这是一道很好的考查对递归理解的编程题,

因此在过去一年中频繁出现在各大公司的面试、笔试题中。

54.调整数组顺序使奇数位于偶数前面。

题目:输入一个整数数组,调整数组中数字的顺序,使得所有奇数位于数组的前半部分,

所有偶数位于数组的后半部分。要求时间复杂度为O(n)。

题目:类CMyString的声明如下:

class CMyString

{

public:

  CMyString(char* pData = NULL);

  CMyString(const CMyString& str);

  ~CMyString(void);

  CMyString& operator = (const CMyString& str);

private:

  char* m_pData;

};

请实现其赋值运算符的重载函数,要求异常安全,即当对一个对象进行赋值时发生异常,对象的状态不能改变。

56.最长公共字串。

题目:如果字符串一的所有字符按其在字符串中的顺序出现在另外一个字符串二中,

则字符串一称之为字符串二的子串。

注意,并不要求子串(字符串一)的字符必须连续出现在字符串二中。

请编写一个函数,输入两个字符串,求它们的最长公共子串,并打印出最长公共子串。

例如:输入两个字符串BDCABA和ABCBDAB,字符串BCBA和BDAB都是是它们的最长公共子串,

则输出它们的长度4,并打印任意一个子串。

分析:求最长公共子串(Longest Common Subsequence, LCS)是一道非常经典的动态规划题,

因此一些重视算法的公司像MicroStrategy都把它当作面试题。

57.用俩个栈实现队列。

题目:某队列的声明如下:

template<typename T> class CQueue

{

public:

  CQueue() {}

  ~CQueue() {}



  void appendTail(const T& node); // append a element to tail

  void deleteHead();               // remove a element from head

private:

 T> m_stack1;

 T> m_stack2;

};

分析:从上面的类的声明中,我们发现在队列中有两个栈。

因此这道题实质上是要求我们用两个栈来实现一个队列。

相信大家对栈和队列的基本性质都非常了解了:栈是一种后入先出的数据容器,

因此对队列进行的插入和删除操作都是在栈顶上进行;队列是一种先入先出的数据容器,

我们总是把新元素插入到队列的尾部,而从队列的头部删除元素。

58.从尾到头输出链表。

题目:输入一个链表的头结点,从尾到头反过来输出每个结点的值。链表结点定义如下:

struct ListNode

{

  int       m_nKey;

  ListNode* m_pNext;

};

分析:这是一道很有意思的面试题。

该题以及它的变体经常出现在各大公司的面试、笔试题中。

59.不能被继承的类。

题目:用C++设计一个不能被继承的类。

分析:这是Adobe公司2007年校园招聘的最新笔试题。

这道题除了考察应聘者的C++基本功底外,还能考察反应能力,是一道很好的题目。

60.在O(1)时间内删除链表结点。

题目:给定链表的头指针和一个结点指针,在O(1)时间删除该结点。链表结点的定义如下:

struct ListNode

{

  int        m_nKey;



  ListNode* m_pNext;

};

函数的声明如下:

void DeleteNode(ListNode* pListHead, ListNode* pToBeDeleted);

分析:这是一道广为流传的Google面试题,能有效考察我们的编程基本功,还能考察我们的反应速度,

更重要的是,还能考察我们对时间复杂度的理解。


61.找出数组中两个只出现一次的数字

题目:一个整型数组里除了两个数字之外,其他的数字都出现了两次。

请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n),空间复杂度是O(1)。

分析:这是一道很新颖的关于位运算的面试题。

62.找出链表的第一个公共结点。

题目:两个单向链表,找出它们的第一个公共结点。

链表的结点定义为:

struct ListNode

{

  int         m_nKey;



  ListNode*   m_pNext;

};

分析:这是一道微软的面试题。微软非常喜欢与链表相关的题目,

因此在微软的面试题中,链表出现的概率相当高。

63.在字符串中删除特定的字符。

题目:输入两个字符串,从第一字符串中删除第二个字符串中所有的字符。例如,输入”They are students.”和”aeiou”,

则删除之后的第一个字符串变成”Thy r stdnts.”。

分析:这是一道微软面试题。在微软的常见面试题中,与字符串相关的题目占了很大的一部分,

因为写程序操作字符串能很好的反映我们的编程基本功。

  1. 寻找丑数。

题目:我们把只包含因子2、3和5的数称作丑数(Ugly Number)。例如6、8都是丑数,

但14不是,因为它包含因子7。习惯上我们把1当做是第一个丑数。

求按从小到大的顺序的第1500个丑数。

分析:这是一道在网络上广为流传的面试题,据说google曾经采用过这道题。

65.输出1到最大的N位数

题目:输入数字n,按顺序输出从1最大的n位10进制数。比如输入3,

则输出1、2、3一直到最大的3位数即999。

分析:这是一道很有意思的题目。看起来很简单,其实里面却有不少的玄机。

66.颠倒栈。

题目:用递归颠倒一个栈。例如输入栈{1, 2, 3, 4, 5},1在栈顶。

颠倒之后的栈为{5, 4, 3, 2, 1},5处在栈顶。

67.俩个闲玩娱乐。

1.扑克牌的顺子

从扑克牌中随机抽5张牌,判断是不是一个顺子,即这5张牌是不是连续的。

2-10为数字本身,A为1,J为11,Q为12,K为13,而大小王可以看成任意数字。

2.n个骰子的点数。

把n个骰子扔在地上,所有骰子朝上一面的点数之和为S。输入n,

打印出S的所有可能的值出现的概率。

68.把数组排成最小的数。

题目:输入一个正整数数组,将它们连接起来排成一个数,输出能排出的所有数字中最小的一个。

例如输入数组{32, 321},则输出这两个能排成的最小数字32132。

请给出解决问题的算法,并证明该算法。

分析:这是09年6月份百度的一道面试题,

从这道题我们可以看出百度对应聘者在算法方面有很高的要求。

69.旋转数组中的最小元素。

题目:把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。输入一个排好序的数组的一个旋转,

输出旋转数组的最小元素。例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转,该数组的最小值为1。

分析:这道题最直观的解法并不难。从头到尾遍历数组一次,就能找出最小的元素,

时间复杂度显然是O(N)。但这个思路没有利用输入数组的特性,我们应该能找到更好的解法。

70.给出一个函数来输出一个字符串的所有排列。

ANSWER 简单的回溯就可以实现了。当然排列的产生也有很多种算法,去看看组合数学,

还有逆序生成排列和一些不需要递归生成排列的方法。

印象中Knuth的<TAOCP>第一卷里面深入讲了排列的生成。这些算法的理解需要一定的数学功底,

也需要一定的灵感,有兴趣最好看看。

71.数值的整数次方。

题目:实现函数double Power(double base, int exponent),求base的exponent次方。

不需要考虑溢出。

分析:这是一道看起来很简单的问题。可能有不少的人在看到题目后30秒写出如下的代码:

double Power(double base, int exponent)

{

  double result = 1.0;

  for(int i = 1; i <= exponent; ++i)

        result *= base;

  return result;

}

题目:设计一个类,我们只能生成该类的一个实例。

分析:只能生成一个实例的类是实现了Singleton模式的类型。

73.对策字符串的最大长度。

题目:输入一个字符串,输出该字符串中对称的子字符串的最大长度。

比如输入字符串“google”,由于该字符串里最长的对称子字符串是“goog”,因此输出4。

分析:可能很多人都写过判断一个字符串是不是对称的函数,这个题目可以看成是该函数的加强版。

74.数组中超过出现次数超过一半的数字

题目:数组中有一个数字出现的次数超过了数组长度的一半,找出这个数字。

分析:这是一道广为流传的面试题,包括百度、微软和Google在内的多家公司都

曾经采用过这个题目。要几十分钟的时间里很好地解答这道题,

除了较好的编程能力之外,还需要较快的反应和较强的逻辑思维能力。

75.二叉树两个结点的最低共同父结点

题目:二叉树的结点定义如下:

struct TreeNode

{

int m_nvalue;

TreeNode* m_pLeft;

TreeNode* m_pRight;

};

输入二叉树中的两个结点,输出这两个结点在数中最低的共同父结点。

分析:求数中两个结点的最低共同结点是面试中经常出现的一个问题。这个问题至少有两个变种。

76.复杂链表的复制

题目:有一个复杂链表,其结点除了有一个m_pNext指针指向下一个结点外,

还有一个m_pSibling指向链表中的任一结点或者NULL。其结点的C++定义如下:

struct ComplexNode

{

int m_nValue;

ComplexNode* m_pNext;

ComplexNode* m_pSibling;

};

下图是一个含有5个结点的该类型复杂链表。

图中实线箭头表示m_pNext指针,虚线箭头表示m_pSibling指针。为简单起见,

指向NULL的指针没有画出。

请完成函数ComplexNode* Clone(ComplexNode* pHead),以复制一个复杂链表。

分析:在常见的数据结构上稍加变化,这是一种很新颖的面试题。

要在不到一个小时的时间里解决这种类型的题目,我们需要较快的反应能力,

对数据结构透彻的理解以及扎实的编程功底。

77.关于链表问题的面试题目如下:

1.给定单链表,检测是否有环。

使用两个指针p1,p2从链表头开始遍历,p1每次前进一步,p2每次前进两步。如果p2到达链表尾部,

说明无环,否则p1、p2必然会在某个时刻相遇(p1==p2),从而检测到链表中有环。

2.给定两个单链表(head1, head2),检测两个链表是否有交点,如果有返回第一个交点。

    如果head1==head2,那么显然相交,直接返回head1。

否则,分别从head1,head2开始遍历两个链表获得其长度len1与len2,假设len1>=len2,

那么指针p1由head1开始向后移动len1-len2步,指针p2=head2,

下面p1、p2每次向后前进一步并比较p1p2是否相等,如果相等即返回该结点,

否则说明两个链表没有交点。

3.给定单链表(head),如果有环的话请返回从头结点进入环的第一个节点。

    运用题一,我们可以检查链表中是否有环。

    如果有环,那么p1p2重合点p必然在环中。从p点断开环,

方法为:p1=p, p2=p->next, p->next=NULL。此时,原单链表可以看作两条单链表,

一条从head开始,另一条从p2开始,于是运用题二的方法,我们找到它们的第一个交点即为所求。

4.只给定单链表中某个结点p(并非最后一个结点,即p->next!=NULL)指针,删除该结点。

办法很简单,首先是放p中数据,然后将p->next的数据copy入p中,接下来删除p->next即可。

5.只给定单链表中某个结点p(非空结点),在p前面插入一个结点。

办法与前者类似,首先分配一个结点q,将q插入在p后,接下来将p中的数据copy入q中,

然后再将要插入的数据记录在p中。

78.链表和数组的区别在哪里?

分析:主要在基本概念上的理解。

但是最好能考虑的全面一点,现在公司招人的竞争可能就在细节上产生,

谁比较仔细,谁获胜的机会就大。

1.编写实现链表排序的一种算法。说明为什么你会选择用这样的方法?

2.编写实现数组排序的一种算法。说明为什么你会选择用这样的方法?

3.请编写能直接实现strstr()函数功能的代码。

80.阿里巴巴一道笔试题

问题描述:

12个高矮不同的人,排成两排,每排必须是从矮到高排列,而且第二排比对应的第一排的人高,问排列方式有多少种?

这个笔试题,很YD,因为把某个递归关系隐藏得很深。

推荐阅读更多精彩内容