-
本版专家分：361结帖率 92.5% -
[汇总I]精选微软等数据结构+算法面试100题[第1-80题]
此100道选自微软等公司数据结构+算法的面试题，皆是极具代表性+经典的。
论坛上，经常能见到此些题的翻版，刚刚就解决了一个，题目还是跟我这帖子上一样的。
即本帖的第21题：
输入两个整数 n 和 m，从数列1，2，3.......n 中 随意取几个数,
使其和等于 m ,要求将其中所有的可能组合列出来.
正因为如此，自觉自己，实在很有必要将此100道题目，一道一道做完。
更希望，各位，能与我一起交流、讨论、思考这100道题。
我们不注重贴代码写答案，我们更注重每一道题的算法，
如何思考，如何更优质的编写代码。
请享用：
第1-40题：
[整理I]算法面试：精选微软经典的算法面试100题[前40题] [推荐]
http://topic.csdn.net/u/20101023/20/5652ccd7-d510-4c10-9671-307a56006e6d.html
第41-60题
[整理II]精选微软等数据结构+算法面试100题[第41题-60题]
http://topic.csdn.net/u/20101113/08/7aba8531-b148-4e01-8755-e68ee004484f.html
现在首次公布整理的第61-80题（11.19最新整理公布）：
---------------------------------------
61.找出数组中两个只出现一次的数字
题目：一个整型数组里除了两个数字之外，其他的数字都出现了两次。
请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
分析：这是一道很新颖的关于位运算的面试题。
62.找出链表的第一个公共结点。
题目：两个单向链表，找出它们的第一个公共结点。
链表的结点定义为：
struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};
分析：这是一道微软的面试题。
微软非常喜欢与链表相关的题目，因此在微软的面试题中，链表出现的概率相当高。
63.在字符串中删除特定的字符。
题目：输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.”。
分析：这是一道微软面试题。在微软的常见面试题中，与字符串相关的题目占了很大的一部分，
因为写程序操作字符串能很好的反映我们的编程基本功。
64. 寻找丑数。
题目：我们把只包含因子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.给出一个函数来输出一个字符串的所有排列。
分析：简单的回溯就可以实现了。当然排列的产生也有很多种算法，去看看组合数学，
还有逆序生成排列和一些不需要递归生成排列的方法。
印象中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;
}
72.
题目：设计一个类，我们只能生成该类的一个实例。
分析：只能生成一个实例的类是实现了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)，以复制一个复杂链表。
//图，接下来，自会补上。July、11.19.
分析：在常见的数据结构上稍加变化，这是一种很新颖的面试题。
要在不到一个小时的时间里解决这种类型的题目，
我们需要较快的反应能力，对数据结构透彻的理解以及扎实的编程功底。
77.关于链表问题的面试题目如下：
题一、 给定单链表，检测是否有环。
使用两个指针p1,p2从链表头开始遍历，p1每次前进一步，p2每次前进两步。
如果p2到达链表尾部，说明无环，否则p1、p2必然会在某个时刻相遇(p1==p2)，从而检测到链表中有环。
题二、 给定两个单链表(head1, head2)，检测两个链表是否有交点，如果有返回第一个交点。
如果head1==head2，那么显然相交，直接返回head1。
否则，分别从head1,head2开始遍历两个链表获得其长度len1与len2，假设len1>=len2，
那么指针p1由head1开始向后移动len1-len2步，指针p2=head2，
下面p1、p2每次向后前进一步并比较p1p2是否相等，如果相等即返回该结点，
否则说明两个链表没有交点。
题三、 给定单链表(head)，如果有环的话请返回从头结点进入环的第一个节点。
运用题一，我们可以检查链表中是否有环。
如果有环，那么p1p2重合点p必然在环中。从p点断开环，方法为：p1=p, p2=p->next,
p->next=NULL。此时，原单链表可以看作两条单链表，一条从head开始，另一条从p2开始，
于是运用题二的方法，我们找到它们的第一个交点即为所求。
题四、只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。
办法很简单，首先是放p中数据,然后将p->next的数据copy入p中，接下来删除p->next即可。
题五、只给定单链表中某个结点p(非空结点)，在p前面插入一个结点。
办法与前者类似，首先分配一个结点q，将q插入在p后，
接下来将p中的数据copy入q中，然后再将要插入的数据记录在p中。
78.链表和数组的区别在哪里？
分析：主要在基本概念上的理解。
但是最好能考虑的全面一点，现在公司招人的竞争可能就在细节上产生，
谁比较仔细，谁获胜的机会就大。
79.
1.编写实现链表排序的一种算法。说明为什么你会选择用这样的方法？
2.编写实现数组排序的一种算法。说明为什么你会选择用这样的方法？
3.请编写能直接实现strstr()函数功能的代码。
80.阿里巴巴一道笔试题
引自baihacker
问题描述:
12个高矮不同的人,排成两排,每排必须是从矮到高排列,而且第二排比对应的第一排的人高,问排列方式有多少种?
这个笔试题,很YD,因为把某个递归关系隐藏得很深.
//第81-100题正在整理中。
--------------------------------------
整理资源下载地址：
题目系列：
1.[第一部分]精选微软等公司数据结构+算法经典面试100题[1-40题]
http://download.csdn.net/source/2778852
2.[第二部分]精选微软等公司结构+算法面试100题[前41-60题]：
http://download.csdn.net/source/2811703
3.[第1题-60题汇总]微软等数据结构+算法面试100题
http://download.csdn.net/source/2826690
答案系列：
4.[最新答案V0.3版]微软等数据结构+算法面试100题[第21-40题答案]
http://download.csdn.net/source/2832862
5.[答案V0.2版]精选微软数据结构+算法面试100题[前20题]--修正
http://download.csdn.net/source/2813890
//此份答案是针对最初的V0.1版本，进行的校正与修正。
6.[答案V0.1版]精选微软数据结构+算法面试100题[前25题]
http://download.csdn.net/source/2796735
更多资源，下载地址：
http://v_july_v.download.csdn.net/
谢谢。
本人July对以上所有任何内容和资料享有版权，转载请注明出处。
向你的厚道致敬。谢谢。
2010年11月19日。![]()
-
本版专家分：14200 -
我会都搞定的。
-
本版专家分：361
-
上说的第21题：
-
本版专家分：1466 -
非常感谢
-
本版专家分：361
-
一起，来搞定，做吧。:)
-
本版专家分：361
-
这俩帖子，都已经结帖了，
第1-40题：
[整理I]算法面试：精选微软经典的算法面试100题[前40题] [推荐]
http://topic.csdn.net/u/20101023/20/5652ccd7-d510-4c10-9671-307a56006e6d.html
第41-60题
[整理II]精选微软等数据结构+算法面试100题[第41题-60题]
http://topic.csdn.net/u/20101113/08/7aba8531-b148-4e01-8755-e68ee004484f.html
对100道题中，任何一道，有任何问题，
都回复到 本帖子上把。:)。![]()
-
本版专家分：361
-
前40题：
如下：
--------------- --------------
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。
第6题
------------------------------------
腾讯面试题：
给你10分钟时间，根据上排给出十个数，在其下排填出对应的十个数
要求下排每个数都是先前上排那十个数在下排出现的次数。
上排的十个数如下：
【0，1，2，3，4，5，6，7，8，9】
初看此题，貌似很难，10分钟过去了，可能有的人，题目都还没看懂。
举一个例子，
数值: 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次....
以此类推..
第7题
------------------------------------
微软亚院之编程判断俩个链表是否相交
给出俩个单向链表的头指针，比如h1，h2，判断这俩个链表是否相交。
为了简化问题，我们假设俩个链表均不带环。
问题扩展：
1.如果链表可能有环列?
2.如果需要求出俩个链表相交的第一个节点列?
第8题
------------------------------------
此贴选一些 比较怪的题，，由于其中题目本身与算法关系不大，仅考考思维。特此并作一题。
1.有两个房间，一间房里有三盏灯，另一间房有控制着三盏灯的三个开关，这两个房间是 分割开的，
从一间里不能看到另一间的情况。
现在要求受训者分别进这两房间一次，然后判断出这三盏灯分别是由哪个开关控制的。
有什么办法呢？
2.你让一些人为你工作了七天，你要用一根金条作为报酬。金条被分成七小块，每天给出一块。
如果你只能将金条切割两次，你怎样分给这些工人?
3 ★用一种算法来颠倒一个链接表的顺序。现在在不用递归式的情况下做一遍。
★用一种算法在一个循环的链接表里插入一个节点，但不得穿越链接表。
★用一种算法整理一个数组。你为什么选择这种方法?
★用一种算法使通用字符串相匹配。
★颠倒一个字符串。优化速度。优化空间。
★颠倒一个句子中的词的顺序，比如将“我叫克丽丝”转换为“克丽丝叫我”，实现速度最快，移动最少。
★找到一个子字符串。优化速度。优化空间。
★比较两个字符串，用O(n)时间和恒量空间。
★假设你有一个用1001个整数组成的数组，这些整数是任意排列的，但是你知道所有的整数都在1到1000(包括1000)之间。此外，除一个数字出现两次外，其他所有数字只出现一次
。假设你只能对这个数组做一次处理，用一种算法找出重复的那个数字。
如果你在运算中使用了辅助的存储方式，那么你能找到不用这种方式的算法吗?
★不用乘法或加法增加8倍。现在用同样的方法增加7倍。
第9题
判断整数序列是不是二元查找树的后序遍历结果
题目：输入一个整数数组，判断该数组是不是某二元查找树的后序遍历的结果。
如果是返回true，否则返回false。
例如输入5、7、6、9、11、10、8，由于这一整数序列是如下树的后序遍历结果：
8
/ \
6 10
/ \ / \
5 7 9 11
因此返回true。
如果输入7、4、6、5，没有哪棵树的后序遍历的结果是这个序列，因此返回false。
第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级。
求总共有多少总跳法，并分析算法的时间复杂度。
这道题最近经常出现，包括MicroStrategy等比较重视算法的公司都
曾先后选用过个这道题作为面试题或者笔试题。
28.整数的二进制表示中1的个数
题目：输入一个整数，求该整数的二进制表达中有多少个1。
例如输入10，由于其二进制表示为1010，有两个1，因此输出2。
分析：
这是一道很基本的考查位运算的面试题。
包括微软在内的很多公司都曾采用过这道题。
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序列。
30.在从1到n的正数中1出现的次数
题目：输入一个整数n，求从1到n这n个整数的十进制表示中1出现的次数。
例如输入12，从1到12这些整数中包含1 的数字有1，10，11和12，1一共出现了5次。
分析：这是一道广为流传的google面试题。
31.华为面试题：
一类似于蜂窝的结构的图，进行搜索最短路径（要求5分钟）
32.
有两个序列a,b，大小都为n,序列元素的值任意整数，无序；
要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。
例如:
var a=[100,99,98,1,2, 3];
var b=[1, 2, 3, 4,5,40];
33.
实现一个挺高级的字符匹配算法：
给一串很长字符串，要求找到符合要求的字符串，例如目的串：123
1******3***2 ,12*****3这些都要找出来
其实就是类似一些和谐系统。。。。。
34.
实现一个队列。
队列的应用场景为：
一个生产者线程将int类型的数入列，一个消费者线程将int类型的数出列
35.
求一个矩阵中最大的二维矩阵(元素和最大).如:
1 2 0 3 4
2 3 4 5 1
1 1 5 3 0
中最大的是:
4 5
5 3
要求:(1)写出算法;(2)分析时间复杂度;(3)用C写出关键代码
第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。
37.
有n个长为m+1的字符串，
如果某个字符串的最后m个字符与某个字符串的前m个字符匹配，则两个字符串可以联接，
问这n个字符串最多可以连成一个多长的字符串，如果出现循环，则返回错误。
38.
百度面试：
1.用天平（只能比较，不能称重）从一堆小球中找出其中唯一一个较轻的，使用x次天平，
最多可以从y个小球中找出较轻的那个，求y与x的关系式
2.有一个很大很大的输入流，大到没有存储器可以将其存储下来，而且只输入一次，如何从这个输入
流中随机取得m个记录
3.大量的URL字符串，如何从中去除重复的，优化时间空间复杂度
39.
网易有道笔试：
(1).
求一个二叉树中任意两个节点间的最大距离，
两个节点的距离的定义是 这两个节点间边的个数，
比如某个孩子节点和父节点间的距离是1，和相邻兄弟节点间的距离是2，优化时间空间复杂度。
(2).
求一个有向连通图的割点，割点的定义是，如果除去此节点和与其相关的边，
有向图不再连通，描述算法。
40.百度研发笔试题
引用自：zp155334877
1)设计一个栈结构，满足一下条件：min，push，pop操作的时间复杂度为O(1)。
2)一串首尾相连的珠子(m个)，有N种颜色(N<=10)，
设计一个算法，取出其中一段，要求包含所有N中颜色，并使长度最短。
并分析时间复杂度与空间复杂度。
3)设计一个系统处理词语搭配问题，比如说 中国 和人民可以搭配，
则中国人民 人民中国都有效。要求：
*系统每秒的查询数量可能上千次；
*词语的数量级为10W；
*每个词至多可以与1W个词搭配
当用户输入中国人民的时候，要求返回与这个搭配词组相关的信息。
-
本版专家分：5 -
都是难题啊
-
本版专家分：361
-
本版专家分：361
-
资料介绍：
---------------------
昨日，11.19，最新整理了，第61-80题，现在公布上传。
另加上之前公布的第1-60 题，在此做一次汇总上传，以飨各位。
可以这么说，绝大部分的面试题，都是这100 道题系列的翻版，
此微软等公司数据结构+算法面试100 题系列，是极具代表性的经典面试题。
我曾经暗暗问自己，不知道我是否把面试题基本上都搜集整理尽了，
而当然，对你更重要的是，我自个还提供了答案下载，提供思路，呵。
所以，这份资料+答案，在网上是独一无二的。
-----------------------------------------------
暂时，免积分下载。
![]()
-
本版专家分：361
-
接上，第41-60道：
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)。
55.
题目：类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都把它当作面试题。
July声明：17:02:53 2010-11-09
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面试题，能有效考察我们的编程基本功，还能考察我们的反应
速度，更重要的是，还能考察我们对时间复杂度的理解。
-
本版专家分：55
-
Lz，这100道题还没做完 哈~
-
本版专家分：361
-
做到了第45道，好多不会...
先看搜集于网友longzuo的这几道：
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}左移两位形成的，在这种数组中查找某一个数。
-
本版专家分：361
-
网友fire_woods(风林火山)给的回复：
45. 1.有2个弱判断准则,不过不知道3个加起来是不是和题目等价
1) 讲矩阵分成黑白棋盘格, 所有黑色格子的数字和等于白色格子的.
2)对任意一个位置, 他的值不大于周围(上下左右)4个临格的数值的和.
45.2. 背包问题, 当然有些条件可以预先判断,比如(所有元素的和%m)!=0, 那么就不需要处理了.
46. 1*1+3*3+2*2=14
47. 直接遍历, O(n)
48. 二分法查找分界点, 再二分法查找O(ln(n))
-
本版专家分：361
-
Galasxy：
第3题组合问题
Catalan数![]()
-
本版专家分：14200
-
帮你断楼～
-
本版专家分：361
-
thank you。
我还得坚持到，把这100题全部做完。
再到最后，把100题的答案全部整理出来，就够了。
现在，已不稀罕有人来做了。
想做就做，不想就不想。
-
本版专家分：361
-
49.一道看上去很吓人的算法面试题：
如何对n个数进行排序，要求时间复杂度O(n)，空间复杂度O(1)
-
本版专家分：361
-
引自张裔的Blog：
看上去似乎任何已知的算法都无法做到，如果谁做到了，
那么所有的排序方法：QuickSort，ShellSort，HeapSort，BubbleSort等等等等，都可以扔掉了，
还要这些算法干吗阿，呵呵。
不过实际上，在数字范围有限制的情况下，是有一个这样的算法的，
只需要用一个数组记录每个数字出现次数就可以了。
假定你的数字范围在0到65535范围之内，定义一个数组count[65536]
（这个空间是常量，和n无关，所以是O(1) )，初值全部为0。
那么假设有下面这些数字：
100
200
300
119
0
6
...
那么对于每个这个数字，都做在count中记录一下：
100 => count[100]++
200 => count[200]++
300 => count[300]++
119 => count[119]++
0 => count[0]++
6 => count[6]++
...
最后，遍历一边所有这些数字就可得到0~65535每个数字的个数（在count数组中），
然后再顺序遍历count数组，count[n] = m，则输出m个n，
（比如说有count[3] = 2, 那么说明有2个数字3），依次输出，最后可得结果。
第一次遍历是O(n)，第二次遍历是O(1)，为常量，所以最后的时间复杂度为O(n)，而空间复杂度为O(1)
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ATField/archive/2007/04/28/1589603.aspx
July:
更多请参考 算法导论 第8章 线性时间排序。
目前，我仍在思考 这道面试题 本身的意义何在?..
-
本版专家分：55
-
奉陪到底。
![]()
-
本版专家分：55
-
以下引自 算法导论 第8章 线性时间排序：
-------------
到目前为止，我们已经介绍了几种能在O（n*lgn）时间内排序的算法，
平均 最差
基数， O（logRB） O（logRB） //
shell， O（nlogn） O（nlogn）
快速， O（nlogn） O（n^2）
归并， O（nlogn） O（nlogn）
堆排序 O（nlogn） O（nlogn）
-------
计数排序
计数排序 假设n个输入元素中的每一个都是介于0到k之间的整数，
此处k为某个整数。
当，k=O（n）时，计数排序的运行时间为O（n）。
-
本版专家分：361
-
so，thanks much。:)
整理资源下载地址：
题目系列：
[最新整理公布][汇总II]微软等数据结构+算法面试100题[第1-80题]http://download.csdn.net/source/2846055
2.[第一部分]精选微软等公司数据结构+算法经典面试100题[1-40题]
http://download.csdn.net/source/2778852
3.[第二部分]精选微软等公司结构+算法面试100题[前41-60题]：
http://download.csdn.net/source/2811703
4.[第1题-60题汇总]微软等数据结构+算法面试100题
http://download.csdn.net/source/2826690
答案系列：
5.[最新答案V0.3版]微软等数据结构+算法面试100题[第21-40题答案]http://download.csdn.net/source/2832862
6.[答案V0.2版]精选微软数据结构+算法面试100题[前20题]--修正
http://download.csdn.net/source/2813890
//此份答案是针对最初的V0.1版本，进行的校正与修正。
7.[答案V0.1版]精选微软数据结构+算法面试100题[前25题]
http://download.csdn.net/source/2796735
更多资源，下载地址：
http://v_july_v.download.csdn.net/
谢谢。
-
本版专家分：361
-
整理资源下载地址：
题目系列：
[最新整理公布][汇总II]微软等数据结构+算法面试100题[第1-80题]
http://download.csdn.net/source/2846055
2.[第一部分]精选微软等公司数据结构+算法经典面试100题[1-40题]
http://download.csdn.net/source/2778852
3.[第二部分]精选微软等公司结构+算法面试100题[前41-60题]：
http://download.csdn.net/source/2811703
4.[第1题-60题汇总]微软等数据结构+算法面试100题
http://download.csdn.net/source/2826690
答案系列：
5.[最新答案V0.3版]微软等数据结构+算法面试100题[第21-40题答案]
http://download.csdn.net/source/2832862
6.[答案V0.2版]精选微软数据结构+算法面试100题[前20题]--修正
http://download.csdn.net/source/2813890
//此份答案是针对最初的V0.1版本，进行的校正与修正。
7.[答案V0.1版]精选微软数据结构+算法面试100题[前25题]
http://download.csdn.net/source/2796735
更多资源，下载地址：
http://v_july_v.download.csdn.net/
谢谢。
-
本版专家分：91
-
第65题:
/*
* question description:
* print the number from 1 to max value with N dicemal digits
*
* example: for n = 3;
* the print result is : 1, 2, 3, ..., 999
*
* solution thought:
* as we known, the long long double can only 1.79769e+308 on my machine
* ( cpu i3 330 ), that means the number you can handle is no larger than
* 309 if you use the built-in type.
* so, i think whether we can emulates the decimal scale with a char string
* that only includes: '0', '1', '2', ..., '9'.
*
* the following is the code
*/
#include <iostream>
#include <cstring>
#include <climits>
using namespace std;
/*
* define a class that emulates decimal scale with char*
*/
class CCharDecimal{
public:
CCharDecimal( int numDigits, const char* charDecimal=NULL )
{
m_numDigit = numDigits+1;
m_charDecimal = new char[m_numDigit];
memset( m_charDecimal, '\0', m_numDigit-1 );
if( charDecimal != NULL )
{
strncpy( m_charDecimal, charDecimal, m_numDigit );
m_charDecimal[m_numDigit] = '\0';
}
}
CCharDecimal( const CCharDecimal &value )
{
m_numDigit = value.m_numDigit;
strcpy(m_charDecimal, value.m_charDecimal);
}
~CCharDecimal()
{
m_numDigit = 0;
delete []m_charDecimal;
m_charDecimal = NULL;
}
//the max value of n digits
CCharDecimal MaxValue( void )
{
int i;
char *temp = new char[m_numDigit];
for( i=0; i<m_numDigit-1; i++ )
{
temp[i] = '9';
}
temp[i] = '\0';
CCharDecimal result( m_numDigit, temp );
delete []temp;
temp = NULL;
return result;
}
//prefix
CCharDecimal& operator ++ ()
{
//if the lowest digit now is '9', then we set it to
//'0', and add the next higher with 1
int i = 0;
while( m_charDecimal[i] == '9' )
{
m_charDecimal[i] = '0';
i++;
}
//add the current highest digit with one
//if m_charDecimal is used at the first time, its value
//is 0, so we firstly set it to '0', then start adding
if( m_charDecimal[i]<'0')
{
m_charDecimal[i] = '0';
}
m_charDecimal[i]++;
return *this;
}
//postfix
CCharDecimal operator ++ ( int )
{
CCharDecimal result( m_numDigit, m_charDecimal );
++(*this);
return result;
}
friend bool operator< ( const CCharDecimal & lvalue, const CCharDecimal &rvalue );
friend ostream& operator<< ( ostream& out, const CCharDecimal &value );
private:
int m_numDigit;
char *m_charDecimal;
};
bool operator< ( const CCharDecimal &lvalue, const CCharDecimal &rvalue )
{
if( strcmp( lvalue.m_charDecimal, rvalue.m_charDecimal ) < 0 )
{
return true;
}
return false;
}
ostream& operator<< ( ostream& out, const CCharDecimal &value )
{
int i=0;
while( value.m_charDecimal[i] != '\0')
{
i++;
}
while( i > 0 )
cout << value.m_charDecimal[--i];
return out;
}
int main( void )
{
int n;
cout<< "please input a number: " << endl;
cin>>n;
CCharDecimal value( n , "1");
CCharDecimal maxValue = value.MaxValue();
unsigned int i = 1;
while( value < maxValue )
{
cout << value++ << ' ';
if( i%10 == 0 )
{
cout<< endl;
}
if( i == UINT_MAX )
{
i=1;
}
else
{
i++;
}
}
cout<< value << endl;
return 0;
}
-
本版专家分：4612 -
想放假再慢慢研究 没想到你们这么积极 啊
-
本版专家分：361
-
简单贴一下，算法，可能更好。:)。
-
本版专家分：361
-
怕就怕，此刻不积极，以后就忘记懒得看了。:)
-
本版专家分：91
-
说说你的思路吧, 大家一起学习
-
本版专家分：361
-
额，我现在 还没做到第65题。
我是从第1-100道题，依着顺序做的。
现在，只看到了第50题。:)
-
本版专家分：123
-
//输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的
#include<iostream>
#include<string>
#include<map>
#include<stdlib.h>
#include<algorithm>
#include<vector>
using namespace std;
int min(int,int);
void m_sort(int num,int m);
bool judge(string &left,string &right,int num);
vector<string> total;
int ma;
int main()
{
int number;
ma=0;
while(cin>>number)
{
char transe[10];
itoa(number,transe,10);
string str(transe);
total.push_back(str);
if(str.size()>ma)
ma=str.size();
m_sort(0,ma);
for(int a=0;a!=total.size();++a)
cout<<total[a]<<endl;
}
return 0;
}
void m_sort(int num,int m)
{
if(num>m)
return;
for(int a=0;a!=total.size()-1;++a)
{
for(int b=a;b!=total.size()-1;++b)
{
if(judge(total[b],total[b+1],num))
{
string str(total[b]);
total[b+1]=total[b];
total[b]=str;
}
}
}
m_sort(++num,m);
}
bool judge(string &left,string &right,int num)
{
if(num==0)
return left[num]>right[num];
//如果之前不等，不再一个优先级里
for(int a=0;a!=min(min(left.size(),right.size()),num);++a)
if(left[a]!=right[a])
return false;
if(left.size()<num&&right.size()>=num)
{
if(right[num]<left[0])
return true;
else if(right[num]==left[0])
for(int a=0;a!=num-1;++a)
{
if(right[a]<right[a+1])
return true;
}
}
else if(left.size()>num&&right.size()<num)
{
if(left[num]>left[0])
return true;
else if(left[num]==left[0])
for(int a=0;a!=num-1;++a)
{
if(right[a]>right[a+1])
return true;
}
}
else if(left.size()>num&&right.size()>num)
return left[num]>right[num];
return false;
}
int min(int a ,int b)
{
return a>b?b:a;
}
-
本版专家分：361
-
贴代码之前，若能简要写下算法，更好。
即便，用伪代码，都行。
-
本版专家分：1467 -
输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的
#include<iostream>
#include<string>
#include<map>
#include<stdlib.h>
#include<algorithm>
#include<vector>
using namespace std;
int min(int,int);
void m_sort(int num,int m);
bool judge(string &left,string &right,int num);
vector<string> total;
int ma;
int main()
{
int number;
ma=0;
while(cin>>number)
{
char transe[10];
itoa(number,transe,10);
string str(transe);
total.push_back(str);
if(str.size()>ma)
ma=str.size();
m_sort(0,ma);
for(int a=0;a!=total.size();++a)
cout<<total[a]<<endl;
}
return 0;
}
void m_sort(int num,int m)
{
if(num>m)
return;
for(int a=0;a!=total.size()-1;++a)
{
for(int b=a;b!=total.size()-1;++b)
{
if(judge(total[b],total[b+1],num))
{
string str(total[b]);
total[b+1]=total[b];
total[b]=str;
}
}
}
m_sort(++num,m);
}
bool judge(string &left,string &right,int num)
{
if(num==0)
return left[num]>right[num];
//如果之前不等，不再一个优先级里
for(int a=0;a!=min(min(left.size(),right.size()),num);++a)
if(left[a]!=right[a])
return false;
if(left.size()<num&&right.size()>=num)
{
if(right[num]<left[0])
return true;
else if(right[num]==left[0])
for(int a=0;a!=num-1;++a)
{
if(right[a]<right[a+1])
return true;
}
}
else if(left.size()>num&&right.size()<num)
{
if(left[num]>left[0])
return true;
else if(left[num]==left[0])
for(int a=0;a!=num-1;++a)
{
if(right[a]>right[a+1])
return true;
}
}
else if(left.size()>num&&right.size()>num)
return left[num]>right[num];
return false;
}
int min(int a ,int b)
{
return a>b?b:a;
}
-
本版专家分：361
-
原来，俩位在做第68题：
----------------------------
68.把数组排成最小的数。
题目：输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的一个。
例如输入数组{32, 321}，则输出这两个能排成的最小数字32132。
请给出解决问题的算法，并证明该算法。
分析：这是09年6月份百度的一道面试题，
从这道题我们可以看出百度对应聘者在算法方面有很高的要求。
搞不懂的是，为什么大家，都喜欢贴代码。
而不注重题目本身的思路、算法。即是怎么一步一步想的，
大段大段的代码，如果算法不清晰，也没几个人愿去看啊。
希望，以下的哥们，
在做题贴代码之前(甚至不必贴代码），能简单描述下自己的算法、或思路。
-
本版专家分：361
-
以下俩题，是从网友funnyone在我的另一个已经结帖的帖子上，移过来的。
47.创新工场：
求一个数组的最长递减子序列 比如{9，4，3，2，5，4，3，2}
的最长递减子序列为{9，5，4，3，2}。
//求一个数组的最长递减子序列 比如{9，4，3，2，5，4，3，2}的
//最长递减子序列为{9，5，4，3，2}
int m_max(int *num,int total)
{
int point1=-1,point2=-1;
int max=1;
int base=1;
bool flags=true;
for(int a=0;a!=total-1;++a)
{
if(num[a]>=num[a+1])
{
if(point1==-1&&flags)
point1=a;
else if(point1!=-1&&flags) point2=a;
++base;
flags=false;
}
else if(num[a]<num[a+1])
{
if(base>max)
{
max=base;
point1=-1;
}
else point2=-1;
flags=true;
base=1;
}
}
for(int a=(point1==-1?point2:point1);a!=(point1==-1?point2:point1)+max;++a)
cout<<num[a]<<" "<<flush;
}
54.调整数组顺序使奇数位于偶数前面。
题目：输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，
所有偶数位于数组的后半部分。要求时间复杂度为O(n)。
//输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，
void move(int *num,int total)
{
int move1[total],move2[total];
int total1=-1,total2=-1;
for(int a=0;a!=total;++a)
{
if(num[a]%2)//jishu
{
++total1;
move1[total1]=num[a];
}
else //oushu
{
++total2;
move2[total2]=num[a];
}
}
//yidong memory
memcpy(num,move1,total1+1);
memcpy(num+total1+1,move2,total2);
}
以后，对已经公布的前80题，有任何问题，都清回复到此帖子上。
其它，所有的帖子，都已经结帖了。:)..
-
本版专家分：361
-
++
-
本版专家分：55
-
永远，无限支持。
-
本版专家分：361
- 【论文笔记】 知识图谱 之 TransE算法（Translating Embedding）
- 最近对知识图谱比较感兴趣，觉得这会是未来整个人工智能领域的发展方向。知识图谱是对人类知识的结构化总结，试想以后所有我们知道的不知道的事情都能通过知识图谱串在一起，形成一个云图书馆。那么知识图谱是如何建立的呢？下面分享一篇文章，来自刘知远老师<em>1</em>5年AAA<em>I</em>的文章。 文章链接：Yankai Lin, Zhiyuan Liu, Maosong Sun, Yang Liu, Xuan Zhu. Le
- 挑战数据结构与算法面试题——80题全解析（一）
- <em>题</em>目来源“<em>数据结构</em>与<em>算法</em><em>面试</em><em>题</em>80道”。这是第一部分，包含其中的第<em>1</em><em>题</em>到第5<em>题</em>。 在此给出我的解法，如你有更好的解法，欢迎留言。 问<em>题</em>分析：二叉查找树是一种二叉树的结构，其中，根节点的值大于左子树的值，小于右子树的值。而二叉查找树的中序遍历即为排序的结果。对于根节点，前驱指针指向左子树中最大的节点，同理，后驱指针指向右子树中最小的节点，如下图所示： 树是一种递归的结果，因...
- 数据结构面试刷题
- 树的计算<em>题</em>技巧： <em>1</em>.在二叉树的第i层至多有2^i <em>-</em> <em>1</em> 个节点 2.深度为k的二叉树至多有2^k<em>-</em><em>1</em> 个节点 3. 设度为0,<em>1</em>,2节点为n0，n<em>1</em>,n2，总结点是n，则n0=n2+<em>1</em>;（根据4.5条推出） 4.n0 + n<em>1</em> + n2 = n 5.n = 分支线数 + <em>1</em> = 2*n2 + <em>1</em>*n<em>1</em> + 0*n0（分支数就是两点的连线的数目，n个点两两连线有n<em>-</em><em>1</em>条线） 满二叉树...
- 挑战一个经典的算法题！高人
- 实现一个函数， 计算<em>1</em>到n的和，当然n是变量 不能出现以下： 乘除操作，位操作，if<em>-</em>else，for，while，switch，？：三目运算符，全局变量，模版，标准库函数。 高手贴代码吧
- 个人不熟悉的面试题目（c++，数据结构）
- 个人不熟悉的<em>面试</em><em>题</em>目（c++，<em>数据结构</em>） 整理：
- 各大公司数据结构与算法面试题解答(一)
- 还有一年就要找工作了，从现在开始找些公司的<em>数据结构</em>和<em>算法</em>的<em>题</em>来做一做，不定时贴出笔试<em>面试</em><em>题</em>代码。 <em>1</em>.创新工场： 求一个数组的最长递减子序列比如{9，4，3，2，5，4，3，2}的最长递减子序列为{9，5，4，3，2} <em>算法</em>描述: <em>1</em>. 对原序列进行递减排序（选择快速排序法）； 2. 删掉重复数字； 3. 得到子序列。 C++源代码： #i
- 面试 数据结构 算法
- From: blog.chinaunix.net/u3/<em>1</em>00577/showart.php?id=220467<em>1</em> <em>面试</em>常考的常用<em>数据结构</em>与<em>算法</em> <em>数据结构</em>与<em>算法</em>，这个部分的内容其实是十分的庞大，要想都覆盖到不太容易。在校学习阶段我们可能需要对每种结构，每种<em>算法</em>都学习，但是找工作笔试或者<em>面试</em>的时候，要在很短的时间内考察一个人这方面的能力，把每种结构和<em>算法</em>都问一遍不太现实。所以，实
- 数据结构常考面试题
- <em>数据结构</em>与<em>算法</em>，这个部分的内容其实是十分的庞大，要想都覆盖到不太容易。在校学习阶段我们可能需要对每种结构，每种<em>算法</em>都学习，但是找工作笔试或者<em>面试</em>的时候，要在很短的时间内考察一个人这方面的能力，把每种结构和<em>算法</em>都问一遍不太现实。所以，实际的情况是，企业一般考察一些看起来很基本的概念和<em>算法</em>，或者是一些变形，然后让你去实现。也许看起来简单，但是如果真让你在纸上或者是计算机上快速地完成一个<em>算法</em>，并且设计测
- 数据结构—二叉树相关概念及经典面试题
- 二叉树概念 一棵二叉树是结点的有限集合，该集合或者为空， 或者是由根结点加上两棵分别称为左子树和右子树的二叉树构成 二叉树的特点： 每个结点最多有两棵子树，即二叉树不存在度大于2的结点 二叉树的子树有左右之分，其子树的次序不能颠倒 满二叉树、完全二叉树 满二叉树：在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子节点都在同一层上 完全二叉树： 如果一棵具有N个结点的二叉...
- TransE的理解
- github.com/thunlp/OpenKE 先看下train2id.txt，大概是这样子： 253 3643 35 438 <em>1</em>0640 94 36 <em>1</em>3<em>1</em>72 <em>1</em>8 8484 35 <em>1</em>7 406 3869 38 6039 6038 384 577<em>1</em> 8658 50 7<em>1</em><em>1</em><em>1</em> 683 <em>1</em>0 7293 947<em>1</em> 6<em>1</em> 43<em>1</em>2 2557 382 就只有head tail relatio...
- 数据结构——栈（面试题）
- 在一个栈的输入序列为<em>1</em>2345 下面哪个不可能是栈的输出序列？A. 234<em>1</em>5 B.54<em>1</em>32 C.23<em>1</em>45 D.<em>1</em>5432第二个。54<em>1</em>32不可能。234<em>1</em>5<em>-</em><em>-</em><em>-</em><em>-</em><em>-</em><em>-</em>&gt;<em>1</em>进栈，2进栈，2出栈，3进栈，3出栈，4进栈，4出栈，<em>1</em>出栈，5进栈，5出栈23<em>1</em>45<em>-</em><em>-</em><em>-</em><em>-</em><em>-</em><em>-</em>&gt;<em>1</em>进栈，2进栈，2出栈，3进栈，3出栈，<em>1</em>出栈，4进栈，4出栈，5进栈，5出栈<em>1</em>5432<em>-</em><em>-</em><em>-</em><em>-</em><em>-</em><em>-</em>&g...
- 轻松搞定面试中的链表题目
- 版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7393<em>1</em>34 链表是最基本的<em>数据结构</em>，<em>面试</em>官也常常用链表来考察<em>面试</em>者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表<em>题</em>目在<em>面试</em>中占据着很重要的地位。本文
- DeepID人脸识别算法之三代
- Deep<em>I</em>D人脸识别<em>算法</em>之三代 Deep<em>I</em>D，目前最强人脸识别<em>算法</em>，已经三代。 如今，深度学习方兴未艾，大数据风起云涌，各个领域都在处于使用深度学习进行强突破的阶段，人脸识别也不例外，香港中文大学的团队使用卷积神经网络学习特征，将之用于人脸识别的子领域人脸验证方面，取得了不错的效果。虽然是今年7月份才出的成果，但连发三箭，皆中靶心，使用的卷积神经网络已经改进了三次，破竹之势节节高。故而在这里将Deep<em>I</em>D神经网络的三代进化史总结一下，以期相互讨论，互有增益。
- 【Stanford CNN课程笔记】4. 反向传播算法
- 本课程笔记是基于今年斯坦福大学Feifei Li, Andrej Karpathy & Justin Johnson联合开设的Convolutional Neural Networks for Visual Recognition课程的学习笔记。目前课程还在更新中，此学习笔记也会尽量根据课程的进度来更新。在这一章中，我们将介绍backpropagation,也就是反向传播<em>算法</em>。
- Train_TransE代码注释
- #include#include#include#include#include#include#include#include#includeusing namespace std;#define pi 3.<em>1</em>4<em>1</em>5926535897932384626433832795bool L<em>1</em>_flag=<em>1</em>;//normal distributiondouble rand(double min, doub
- TransH论文：Experiments-Link prediction
- <em>-</em>
- FM算法能够学习到原始特征的embedding表示
- FM<em>算法</em>是CTR预估中的经典<em>算法</em>,其优势是能够自动学习出交叉特征.因为这种特性,FM在CTR预估上的效果会远超LR. 说明：通过FM的公式可以看出,FM自动学习交叉是通过学习到每个特征xi的向量表示vi得到的.比如说,对于field A,其特征有<em>1</em>00w种取值,如果使用one<em>-</em>hot编码。那么,每个特征需要使用<em>1</em>00w维特征表示.使用了FM<em>算法</em>学习之后,比如说使用vi的特征维度是<em>1</em>0
- 三元组
- 假设nn的稀疏矩阵A采用三元组表示，设计一个程序exp6<em>-</em>4.cpp实现如下功能： （<em>1</em>）生成如下两个稀疏矩阵的三元组a和b； （2）输出a转置矩阵的三元组； （3）输出a+b的三元组； （4）输出ab的三元组。 #include #include #define MaxSize <em>1</em>6 #define M 4 #define N 4 typedef struct { i
- 简单的程序诠释C++ STL算法系列之十八：transform
- 前篇我们已经了解了一种区间元素交换swap_ranges函数，现在我们再来学习另外一种区间元素交换transform。该<em>算法</em>用于实行容器元素的变换操作。有如下两个使用原型，一个将迭代器区间[first，last)中元素，执行一元函数对象op操作，交换后的结果放在[result，result+（last<em>-</em>first)）区间中。另一个将迭代器区间[first<em>1</em>，last<em>1</em>)的元素*i，依次与[firs
- 【论文笔记】视频物体检测(VID)系列 NoScope:1000x的视频检索加速算法
- 计算机视觉的进展，特别是近期深度神经网络的进展，使得在不断增长的视频数据中进行检索成为可能。但是，基于神经网络去做大规模视频检索，直接的问<em>题</em>就是计算量激增。比如现在最快的物体检测器能达到<em>1</em>～2.5x real time的效率（30～80fps），前提是买一个$4000的GPU。
- 阿里凑单算法首次公开！基于Graph Embedding的打包购商品挖掘系统解析
- 阿里妹导读：你是否也曾遇到类似的情况——差5块钱就能包邮，跨店满400减50就少20怎么办？凑单作为购物券导购链路的一个重要环节，旨在帮助你找到合适的商品。如何在凑单场景突破找相似、发现惊喜的同时做到成交翻倍，实现体验和数据上的双赢？今天我们一起来破解。 一、背景 凑单作为购物券导购链路的一个重要环节，旨在帮助用户找到商品，达成某个满减门槛（比如满4
- TransE算法
- TransE<em>算法</em>中存在一个设定，它将关系看作是实体间的平移向量，也就是说对于一个三元组（h,r,t）对应的向量lh，lr，lt，希望 lh+lr =lt 这源于Mikolov等人在20<em>1</em>3年提出的word2vec词表示学习模型，他们发现词向量空间存在着平移不变现象，如 C(king)−C(queen)≈C(man...
- 单链表面试题集合
- <em>1</em>、找出单链表的倒数第K个元素（仅允许遍历一遍链表） 使用指针追赶的方法。定义两个指针fast和slow，fast先走K步，然后fast和slow同时继续走。当fast到链表尾部时，slow指向倒数第K个。注意要考虑链表长度应该大于K。 2、找出单链表的中间元素（仅允许遍历一遍链表） 使用指针追赶的方法。fast每次走一步，s...
- 链表经典算法题实现
- 本文包含链表的以下内容： <em>1</em>、单链表的创建和遍历 2、求单链表中节点的个数 3、查找单链表中的倒数第k个结点（剑指offer，<em>题</em><em>1</em>5） 4、查找单链表中的中间结点 5、合并两个有序的单链表，合并之后的链表依然有序【出现频率高】（剑指offer，<em>题</em><em>1</em>7） 6、单链表的反转【出现频率最高】（剑指offer，<em>题</em><em>1</em>6） 7、从尾到头打印单链表（剑指offer，<em>题</em>5...
- C语言单链表相关问题求解，具体要求如下
- <em>-</em>
- 数据结构算法题，小白不是很会做，这个用C语言如何求解？
- <em>-</em>
- 链表算法题技巧总结
- <em>1</em>.旋转链表，遍历一遍求链表长度，将链表首尾相接再断开(6<em>1</em>.rorate) 2.将两条排序链表连接,直接连接即可(2<em>1</em>.mergetwolist) 3.当提示越界时，应该注意左式不为NULL，右式可为NULL，如 p<em>-</em>>next==p<em>-</em>>next<em>-</em>>next 条件满足p<em>-</em>>next!=NULL即可 或者是两次引用成员，如p<em>-</em>>next<em>-</em>>val，如果p<em>-</em>>
- 数据结构与算法题目集（中文）（6-1 单链表逆转（20 分））
- List Reverse( List L ){ PtrToNode h,ln; int i=0; if(!L) return NULL; //空表 else if(!L<em>-</em>&gt;Next) return L; //只有一个结点 else{ ln=L<em>-</em>&gt;Next; //逆转第...
- 剑指offer（链表的算法题）
- 本文包含链表的以下内容： <em>1</em>、查找单链表中的倒数第k个结点（剑指offer，<em>题</em><em>1</em>5） 2、合并两个有序的单链表，合并之后的链表依然有序【出现频率高】（剑指offer，<em>题</em><em>1</em>7） 3、单链表的反转【出现频率最高】（剑指offer，<em>题</em><em>1</em>6） 4、从尾到头打印单链表（剑指offer，<em>题</em>5） 5、单链表中，取出环的起始点（剑指offer，<em>题</em>56） 6、判断两个单链表相交的...
- 【算法】链表算法题思路
- 做了很多链表相关的<em>算法</em><em>题</em>，感觉解<em>题</em>思路不外乎下面三种： <em>1</em>. 一快一慢双指针 比如，倒数第k个节点问<em>题</em>，判断有环链表的入环节点 2. 使用栈结构 比如， 3. pre，cur，next三指针同时出击。 比如，链表翻转问<em>题</em>...
- 算法面试题
- <em>1</em>.比较两个字符串如果不等返回True？ 答案： Java代码 package com.test.kaoshi; public class StringDemo { private static String a = "abc"; private static Stri
- 大型公司面试必答之数据结构与算法精讲下载
- 大型公司<em>面试</em>必答之<em>数据结构</em>与<em>算法</em>精讲...................... 相关下载链接：//download.csdn.net/download/u0<em>1</em>25<em>1</em>0443/<em>1</em>0264848?utm
- JAVA数据结构和算法+面试题
- 有JAVA<em>数据结构</em>和<em>算法</em>的教程 还有<em>算法</em><em>题</em> 加部分<em>面试</em><em>题</em> 从别人那下的 在这一次给了 希望能帮到大家
- 数据结构和算法面试题
- <em>微软</em><em>数据结构</em>与<em>算法</em>，看到该文件的网友有福了，哈哈！
- php面试题之二——数据结构和算法（高级部分）
- 二、<em>数据结构</em>和<em>算法</em> <em>1</em>.使对象可以像数组一样进行foreach循环，要求属性必须是私有。(<em>I</em>terator模式的PHP5实现，写一类实现<em>I</em>terator接口)（腾讯） class Test implements <em>I</em>terator{ private $item = array('id'=><em>1</em>,'name'=>'php'); public function rewi
- 面试——数据结构与算法
- 分类： <em>数据结构</em>与<em>算法</em>（<em>1</em>4） 作者同类文章X <em>面试</em>（5） 作者同类文章X <em>1</em>、快速排序： 2、哈夫曼树： 哈夫曼树是带权路径长度最短的树。 3、最小生成树： 最小生成树能够保证整个拓扑图的所有路径之和最小，但不能保证任意两点之间是最短路径。 http://www.cnblo
- 精选微软等公司数据结构+算法经典面试100题及答案
- <em>1</em>.把二元查找树转变成排序的双向链表 <em>题</em>目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 <em>1</em>0 / \ 6 <em>1</em>4 / \ / \ 4 8 <em>1</em>2 <em>1</em>6 转换成双向链表 4=6=8=<em>1</em>0=<em>1</em>2=<em>1</em>4=<em>1</em>6。 首先我们定义的二元查找树节点的<em>数据结构</em>如下： struct BSTreeNode { int m_nVa
- 大厂面试题（四）数据结构和算法
- <em>数据结构</em>和<em>算法</em>博大精深，博客中写不完的。《剑指offer》这本书中列出了很多<em>面试</em>中<em>算法</em>问<em>题</em>的解决方案，很有学习价值。 <em>1</em>. 链表与数组。 数组,在内存上给出了连续的空间.链表,内存地址上可以是不连续的,每个链表的节点包括值和下一个节点的位置(单向的一个,双向链表的话,会有两个). 数组优于链表的地方: <em>1</em>.存储相同的值，数组内存空间占用的少,因为链表节点会附加上一块或两块下一个节点的
- 面试题库 之 数据结构与算法 100题
- <em>1</em>.把二元查找树转变成排序的双向链表 <em>题</em>目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 <em>1</em>0 / \ 6 <em>1</em>4 / \ / \ 4 8 <em>1</em>2 <em>1</em>6 转换成双向链表 4=6=8=<em>1</em>0=<em>1</em>2=<em>1</em>4=<em>1</em>6。 首先我们定义的二元查找树节点的<em>数据结构</em>如下： struct BSTreeNode { int m_nValue; // value o
- 算法与数据结构——微软笔试题
- <em>算法</em><em>题</em> 94：前序中序遍历（<em>微软</em>笔试<em>题</em>） <em>题</em>目：如果一个二叉树的前序遍历结果是abcdefg，下面哪一个是可能的中序遍历结果？ A、abcdefg B、gfedcba C、bcdefga D、bceadfg ******************************************************************************************
- 算法数据结构面试分享（二）- 解决算法问题的一般方法
- 先看一道<em>题</em>目： 给你一个整型数组，我想找出来最大的两个数，能帮我写一个<em>算法</em>吗？拿到这个<em>题</em>目，大家会怎么想到用什么方法解决吗？我见过很多同学的回答是，先排序，取最大的两个数就好了。那么接下来我们的问<em>题</em>就变成了如何给这个整型数组排序了。我们有很多种方法，冒泡排序，快速排序等等。很有可能<em>面试</em>官就让你开始写具体的排序<em>算法</em>了。当然，有些有经验的同学可能会说了，排序我直接调用sort方法就好了哈。 ...
- 转行程序员？你可能忽略了一件事。
- 程序 = <em>数据结构</em> + <em>算法</em> ——图灵奖得主，计算机科学家N.Wirth(沃斯)作为程序员，我们做机器学习也好，做python开发也好，java开...
- 【程序猿必备】数据结构与算法精选面试题
- 有很多计算机科学技术专业的毕业生和程序员申请在Uber和Netflix这样的初创公司、谷歌和阿里巴巴这样的大公司以及<em>I</em>nfosys或Luxsoft等以服务为基础的公司从事编程、编码和软件开发工作，但他们中的许多人都不知道，当你申请这些公司的职位时，你会遇到什么样的编程<em>面试</em>问<em>题</em>。 在这篇文章中，我将分享一些常见的来自不同经验水平程序员的编程<em>面试</em>问<em>题</em>，...
- 大公司的C语言面试，面试时体现你使用算法，数据结构解决问题的思路
- 大公司的C语言<em>面试</em>，<em>面试</em>时体现你使用<em>算法</em>，<em>数据结构</em>解决问<em>题</em>的思路
- 数据结构面试题（含答案）
- <em>1</em>.栈和队列的共同特点是（只允许在端点处插入和删除元素） 4.栈通常采用的两种存储结构是（线性存储结构和链表存储结构） 5.下列关于栈的叙述正确的是（D） A.栈是非线性结构B.栈是一种树状结构C.栈具有先进先出的特征D.栈有后进先出的特征 6.链表不具有的特点是（B）A.不必事先估计存储空间 B.可随机访问任一元素 C.插入删除不需要移动元素 D.所需空间与线性表
- 【数据结构】链表的原理及与其相关的常见面试题总结
- 链表是一种<em>数据结构</em>，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。 单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Nod
- 数据结构经典面试题——练习3
- <em>1</em>. 在计算机中，<em>算法</em>是指（解<em>题</em>方案的准确而完整的描述） 2.在下列选项中，哪个不是一个<em>算法</em>一般应该具有的基本特征（无穷性） 说明：<em>算法</em>的四个基本特征是：可行性、确定性、有穷性和拥有足够的情报。 3. <em>算法</em>一般都可以用哪几种控制结构组合而成（顺序、选择、循环） 4.<em>算法</em>的时间复杂度是指（<em>算法</em>执行过程中所需要的基本运算次数） 5. <em>算法</em>的空间复杂度是指（执行过程中所需要的存储空间） 6
- 【数据结构】--几道栈和队列面试题
- 用两个栈实现一个队列 <em>1</em>、思路分析 拿到这道<em>题</em>，会有以下几种思路： 思路一：入队时，将所有的元素压入到s<em>1</em>中 出队时，将s<em>1</em>中的所有元素倒入到s2中，然后让s2中栈顶的元素出栈，然后将s2中所有的元素倒入到s<em>1</em>中问<em>题</em>所在：我们不难发现，在这种解法中，要进行来回倒栈，时间复杂度就会比较大，做起来也比较麻烦 思路二： 说明：是对第一种的优化我们不难发现，其实在进行倒栈的时候，没必要进行最后一个元
- 面试题目汇总(JAVA算法/数据结构)
- <em>1</em>.<em>题</em>目：输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，32<em>1</em>}，则打印出这三个数字能排成的最小数字为32<em>1</em>323。 代码： import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.u
- 数据结构面试题 java面试题
- <em>1</em>.栈和队列的共同特点是（只允许在端点处插入和删除元素） 4.栈通常采用的两种存储结构是（线性存储结构和链表存储结构） 5.下列关于栈的叙述正确的是（D） A.栈是非线性结构B.栈是一种树状结构C.栈
- 面试复习重点——数据结构、操作系统、计算机网络、数据库。
- 必看书籍：剑指offer、程序员<em>面试</em>宝典 来自：腾讯、搜狐、网易、烽火、百度、大众点评、美团、风行 <em>1</em>. 死锁是什么？什么情况下产生？怎么解决？ 2. 设计模式（尤其是单例模式，要会写该模式的程序框架，要注意同步问<em>题</em>，怎么实现在要用时才创建） 3. 线程的同步？为什么要同步？线程间通信方式。 4. 进程与线程的区别，进程间通信方式。 5. 容器类：hashmap与hasht
- 数据结构面试题(含答案)
- 转自： http://wenku.baidu.com/link?url=7WfOwEBOMGC5mJQ_c8YVdZl8SZkR_MCysY<em>I</em>We_dkM6LeleTQThXkyw8Q0OtXFtmU05pDrMphPybkXxFVkcdooAY8n<em>I</em>UrsU8OXw5e<em>1</em>v3ne2m
- C语言 ，嵌入式 ，数据结构 面试题目（1）
- <em>1</em>. 用预处理指令#define 声明一个常数，用以表明<em>1</em>年中有多少秒（忽略闰年问<em>题</em>）#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 2. 写一个“标准”宏M<em>I</em>N，这个宏输入两个参数并返回较小的一个。#define M<em>I</em>N(A,B) ((A) &lt;= (B) (A) : (B)) 注意大小写的问<em>题</em>、括号的问<em>题</em>4. 嵌入式系统中经常要用到无限循环，...
- 计算s=1+2!+3!+……+n!
- 以下函数的功能是计算s=<em>1</em>+2!+3!+……+n!，请填空。 double fun(int n) {double s=0.0,fac=<em>1</em>.0; int i; for(i=<em>1</em>;i<=n;i++) { f
- 学会了这些技术，你离BAT大厂不远了
- 每一个程序员都有一个梦想，梦想着能够进入阿里、腾讯、字节跳动、百度等一线互联网公司，由于身边的环境等原因，不知道 BAT 等一线互联网公司使用哪些技术？或者该如何去学习这些技术？或者我该去哪些获取这些技术资料？没关系，平头哥一站式服务，上面统统不是问<em>题</em>。平头哥整理了 BAT 等一线大厂的必备技能，并且帮你准备了对应的资料。对于整理出来的技术，如果你掌握的不牢固，那就赶快巩固，如果你还没有涉及，现在...
- Linux文件操作高频使用命令
- 文章目录0.新建操作：<em>1</em>.查看操作2.删除操作3.复制操作4.移动操作：5.重命名操作：6.解压压缩操作 0.新建操作： mkdir abc #新建一个文件夹 touch abc.sh #新建一个文件 <em>1</em>.查看操作 查看目录： ll #显示目录文件详细信息 查看文件内容： cat|head|tail命令 cat abc.txt #查看abc的内容 head <em>-</em>5 abc.txt #...
- 程序员实用工具网站
- 目录 <em>1</em>、搜索引擎 2、PPT 3、图片操作 4、文件共享 5、应届生招聘 6、程序员<em>面试</em><em>题</em>库 7、办公、开发软件 8、高清图片、视频素材网站 9、项目开源 <em>1</em>0、<em>算法</em> <em>1</em><em>1</em>、在线工具宝典大全 程序员开发需要具备良好的信息检索能力，为了备忘（收藏夹真是满了），将开发过程中常用的网站进行整理。 <em>1</em>、搜索引擎 <em>1</em>.<em>1</em>、秘迹搜索 一款无敌有良心、无敌安全的搜索引擎，不会收...
- 脉搏血氧饱和度检测系统设计中干扰信号的处理方法下载
- 脉搏血氧饱和度检测系统是一种将血氧浓度的光电检测技术与容积脉搏描记技术结合起来 实现无创伤、连续血氧浓度测量的新型医疗监护仪器。消除测量系统中各种干扰的影响, 设法正确 地检出光电容积脉搏波信号是关系到测量系统准确性及其精度的关键问题之一。本文着重介绍了 脉搏血氧饱和度检测系统中干扰的主要来源、处理方法及其应用现状, 从而为脉搏血氧饱和度检 测系统设计提供了依据。 相关下载链接：[url=//download.csdn.net/download/su06260432/2308646?utm_source=bbsseo]//download.csdn.net/download/su06260432/2308646?utm_source=bbsseo[/url]
- Ubuntu_10.04运用crosstool-ng-1.9.0建立arm-linux交叉工具链下载
- Ubuntu_10.04运用crosstool-ng-1.9.0建立arm-linux交叉工具链 相关下载链接：[url=//download.csdn.net/download/zfaquir/4247342?utm_source=bbsseo]//download.csdn.net/download/zfaquir/4247342?utm_source=bbsseo[/url]
- MPLS_VPN入门中文版V1.2下载
- MPLS_VPN入门~为哪些不了解MPLS的同学提供一个范例，思科官方技术文档。 相关下载链接：[url=//download.csdn.net/download/elvaelf/5178564?utm_source=bbsseo]//download.csdn.net/download/elvaelf/5178564?utm_source=bbsseo[/url]
我们是很有底线的