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

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函数的栈。

3.求子数组的最大和

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

10

/ \

5 12

/ \

4 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个元素(采用小根堆 和 大根堆 来解决)

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;
``````

}

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

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);
}

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

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

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

（先亮A灯一段时间,再关闭A灯亮B灯,进入有灯的房间,得出结论:亮着的是B灯,暗着的两盏灯中,热的灯是A灯,剩下的是C灯）

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

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

//非递归方式翻转
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倍。

(思路是序列最后一个必是根节点，从前往后遍历，比根节点小的都是其左子树，并且位于序列的左半部分，比其大的为其右子树，应该位于其右半部分。)

# 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;
}

struct ListNode

{

int m_nKey;

ListNode* m_pNext;

};

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

};

8

/ \

6 10

/ \ / \

5 7 9 11

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

/ 0 n=0

f(n)= 1 n=1

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

2010年中兴面试题

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

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

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

4个角坐标;

1:(., 0.0, .)

2:(., 0.0, .)

3:(., 0.0, .)

4:(., 0.0, .)

（1）.单链表就地逆置，

（2）合并链表

outputstr所指的值为123456789

26.左旋转字符串

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

/----------------------------
Copyright by yuucyf. 2011.08.16
-----------------------------
/

# 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;
}

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

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 1，push 2，push 3，push 4，pop，push 5，pop，pop，pop，pop，

# 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出现的次数

# 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 <string>

using namespace std;

# 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;
}
``````

}

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

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

# 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;
}

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

1 2 0 3 4

2 3 4 5 1

1 1 5 3 0

4 5

5 3

//非最优解

# 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.引用自网友：longzuo

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

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

answer:二分法

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

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

(1).

(2).

40.百度研发笔试题

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

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

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

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

*词语的数量级为10W；

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

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

42.请修改append函数，利用这个函数实现：

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

44.腾讯面试题：

1.设计一个魔方（六面）的程序。

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

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

45.雅虎：

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

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

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

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

46.搜狐：

47.创新工场：

48.微软：

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

50.网易有道笔试：

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

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

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

52.二元树的深度。

``````                                        10

/     \

6        14

/         /   \

4         12     16
``````

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、acb、bac、bca、cab和cba。

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

class CMyString

{

public:

``````  CMyString(char* pData = NULL);

CMyString(const CMyString& str);

~CMyString(void);

CMyString& operator = (const CMyString& str);
``````

private:

``````  char* m_pData;
``````

};

56.最长公共字串。

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.不能被继承的类。

60.在O（1）时间内删除链表结点。

struct ListNode

{

``````  int        m_nKey;

ListNode* m_pNext;
``````

};

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

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

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

struct ListNode

{

``````  int         m_nKey;

ListNode*   m_pNext;
``````

};

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

1. 寻找丑数。

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

66.颠倒栈。

67.俩个闲玩娱乐。

1.扑克牌的顺子

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

2.n个骰子的点数。

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

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

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

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

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

71.数值的整数次方。

double Power(double base, int exponent)

{

``````  double result = 1.0;

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

result *= base;

return result;
``````

}

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

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

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

struct TreeNode

{

``````int m_nvalue;

TreeNode* m_pLeft;

TreeNode* m_pRight;
``````

};

76.复杂链表的复制

struct ComplexNode

{

``````int m_nValue;

ComplexNode* m_pNext;

ComplexNode* m_pSibling;
``````

};

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

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

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

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

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

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

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

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

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

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

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

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

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

80.阿里巴巴一道笔试题

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