面试题合集

面试题合集

1. 在购物的时候把一个商品加入到购物车这个功能应该怎么测试
   首先未登录添加一个商品看是否符合预期效果
   然后登录状态添加一个商品看看是否符合预期
   然后看看最多能提交多少个商品，是不是符合预期设计
   还可以测试代码的接口 (就是提交功能有相应的实现代码入口，有时可以直接修改提交参数)
   还可以直接用修改url的方式提交看是否可以(就是网址后面的参数修改后购买不同的商品)

2. 如果一个瓶子从一级摔下来没有碎，从第二级摔下来也没有碎，从第三极摔下来碎掉了，那么这个瓶子的强度是2。级数代表高度。如果强度可能有m级，给你两个一样的瓶子要怎么最快地测出它的强度。

首先让自我介绍
其次。。。。

1. 在购物的时候把一个商品加入到购物车这个功能应该怎么测试
   首先未登录添加一个商品看是否符合预期效果
   然后登录状态添加一个商品看看是否符合预期
   然后看看最多能提交多少个商品，是不是符合预期设计
   还可以测试代码的接口 (就是提交功能有相应的实现代码入口，有时可以直接修改提交参数)
   还可以直接用修改url的方式提交看是否可以(就是网址后面的参数修改后购买不同的商品)

2. 如果一个瓶子从一级摔下来没有碎，从第二级摔下来也没有碎，从第三极摔下来碎掉了，那么这个瓶子的强度是2。级数代表高度。如果强度可能有m级，给你两个一样的瓶子要怎么最快地测出它的强度。
   题目同于：一幢 200 层的大楼,给你两个鸡蛋. 如果在第 n 层扔下鸡蛋,鸡蛋不碎,那么从前 n-1 层扔鸡蛋都不碎.
   这两只鸡蛋一模一样,不碎的话可以扔无数次. 已知鸡蛋在0层扔不会碎.
   提出一个策略, 要保证能测出鸡蛋恰好会碎的楼层, 并使此策略在最坏情况下所扔次数最少.
   解法：http://www.zhihu.com/question/19690210
   搞清楚这题的意思:
   第一个鸡蛋用来试探, 只要它从 k 层楼扔下去没碎, 则目标就在[k+1, 200]之间了.
   但一旦运气不好碎了, 对于已知的区间, 我们只能用剩下一个鸡蛋从小到大一层层试,
   因为我们要保证策略必须成功, 不能冒险了.

"最坏情况下代价最小"这句话十分重要, 它反映了题目的重要数学结构:
我们可以把任何一种策略都看成一个决策树,
每一次扔瓶子都会有两个子节点, 对应碎与不碎的情况下下一步应该扔的楼层.
那么, 策略的一次执行, 是树中的一条从根往下走的路,
当且仅当这条路上出现过形如 k 没碎 与 k+1 碎了的一对节点时, 路停止, 当前节点不再扩展.
那么要找的是这么一棵树, 使得所有路里最长者尽量短, 也即, 要找一个最矮的决策树.

再看一个节点处, 选择楼层时会发生什么.
容易看出, 选择的楼层如果变高, 那么"碎子树"高度不减, "不碎子树"高度不增.
同样的, 选择的楼层变矮的话, "碎子树"高度不增, "不碎子树"高度不减.

这时候答案很明显了: 为了使两子树中高度最大者尽量小, 我们的选择应当使两子树高度尽量接近.
最终希望的结果是, 整个二叉树尽量像一个满二叉树.

假设第一次在根节点上, 我们选择扔k层, 其"碎子树"的高度显然是k - 1.
为了考虑不碎子树的高度, 设不碎后第二次扔m层(显然m > k ),
则这个新节点的碎子树高度为 m - k - 1, 不碎子树高度仍然未知,
但按照满二叉树的目标, 我们认为它与碎子树相同或少1就好.
那么在根节点上的不碎子树的高度就是m -k-1 + 1, 令它与碎子树高度相同, 于是:
m - k - 1 + 1 = k - 1 => m = k + k - 1

也即, 如果第一次扔在k层, 第二次应该高k-1 层, 这可以有直观一点的理解:
每扔一次, 就要更保守一些, 所以让区间长度少1. [1, k) -> [k + 1, 2k - 1).
用类似刚才的分析, 可以继续得到, 下一次应该增高k - 2, 再下一次应该增高k - 3.

如果大楼100层, 考虑:

所以第一次扔14层, 最坏需要14次(策略不唯一, 树的叶子可以交换位置).200层的话, 类似得到k =20.

以上是数学做法…当然还有代码做法…
设f(n, m)为n层楼, m个蛋所需次数, 那么它成了一道DP题…

以下代码python3 only:
import functools
@functools.lru_cache(maxsize=None)
def f(n, m):
if n == 0:
return 0
if m == 1:
return n

ans = min([max([f(i - 1, m - 1), f(n - i, m)]) for i in range(1, n + 1)]) + 1
return ans

print(f(100, 2)) # 14
print(f(200, 2)) # 20

3. 在html和数据库的连接上问了几个问题
4. 为什么选择测试开发工程师，和对测试开发工程师工作内容的理解。目前的研究内容、方向、算法，最后问了一些数据库方面的基础问题。C#的GC实现的内部机制的了解（对应java的垃圾回收机制）
   （）
   1.JVM的gc概述
   gc即垃圾收集机制是指jvm用于释放那些不再使用的对象所占用的内存。java语言并不要求jvm有gc，也没有规定gc如何工作。不过常用的jvm都有gc，而且大多数gc都使用类似的算法管理内存和执行收集操作。
   在充分理解了垃圾收集算法和执行过程后，才能有效的优化它的性能。有些垃圾收集专用于特殊的应用程序。比如，实时应用程序主要是为了避免垃圾收集中断，而大多数OLTP应用程序则注重整体效率。理解了应用程序的工作负荷和jvm支持的垃圾收集算法，便可以进行优化配置垃圾收集器。
   垃圾收集的目的在于清除不再使用的对象。gc通过确定对象是否被活动对象引用来确定是否收集该对象。gc首先要判断该对象是否是时候可以收集。两种常用的方法是引用计数和对象引用遍历。
   1.1.引用计数
   引用计数存储对特定对象的所有引用数，也就是说，当应用程序创建引用以及引用超出范围时，jvm必须适当增减引用数。当某对象的引用数为0时，便可以进行垃圾收集。
   1.2.对象引用遍历
   早期的jvm使用引用计数，现在大多数jvm采用对象引用遍历。对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。在对象遍历阶段，gc必须记住哪些对象可以到达，以便删除不可到达的对象，这称为标记（marking）对象。
   下一步，gc要删除不可到达的对象。删除时，有些gc只是简单的扫描堆栈，删除未标记的未标记的对象，并释放它们的内存以生成新的对象，这叫做清除（sweeping）。这种方法的问题在于内存会分成好多小段，而它们不足以用于新的对象，但是组合起来却很大。因此，许多gc可以重新组织内存中的对象，并进行压缩（compact），形成可利用的空间。
   为此，gc需要停止其他的活动活动。这种方法意味着所有与应用程序相关的工作停止，只有gc运行。结果，在响应期间增减了许多混杂请求。另外，更复杂的gc不断增加或同时运行以减少或者清除应用程序的中断。有的gc使用单线程完成这项工作，有的则采用多线程以增加效率。
   2.几种垃圾回收机制
   2.1.标记－清除收集器
   这种收集器首先遍历对象图并标记可到达的对象，然后扫描堆栈以寻找未标记对象并释放它们的内存。这种收集器一般使用单线程工作并停止其他操作。
   2.2.标记－压缩收集器
   有时也叫标记－清除－压缩收集器，与标记－清除收集器有相同的标记阶段。在第二阶段，则把标记对象复制到堆栈的新域中以便压缩堆栈。这种收集器也停止其他操作。
   2.3.复制收集器
   这种收集器将堆栈分为两个域，常称为半空间。每次仅使用一半的空间，jvm生成的新对象则放在另一半空间中。gc运行时，它把可到达对象复制到另一半空间，从而压缩了堆栈。这种方法适用于短生存期的对象，持续复制长生存期的对象则导致效率降低。
   2.4.增量收集器
   增量收集器把堆栈分为多个域，每次仅从一个域收集垃圾。这会造成较小的应用程序中断。
   2.5.分代收集器
   这种收集器把堆栈分为两个或多个域，用以存放不同寿命的对象。jvm生成的新对象一般放在其中的某个域中。过一段时间，继续存在的对象将获得使用期并转入更长寿命的域中。分代收集器对不同的域使用不同的算法以优化性能。
   2.6.并发收集器
   并发收集器与应用程序同时运行。这些收集器在某点上（比如压缩时）一般都不得不停止其他操作以完成特定的任务，但是因为其他应用程序可进行其他的后台操作，所以中断其他处理的实际时间大大降低。
   2.7.并行收集器
   并行收集器使用某种传统的算法并使用多线程并行的执行它们的工作。在多cpu机器上使用多线程技术可以显著的提高java应用程序的可扩展性。
   GC运行的三种方式
   在java5和java6中有4中垃圾回收的算法，有一种算法将不再支持，剩余的三种垃圾回收算法是：serial,throughput and concurrent low pause。

• Stop the world（停止所有程序的方式）：在这种方式运行的GC，在GC完成前，JVM中的所有程序都不允许运行。Serial collector此时做minor和major收集。Throughput collector此时做major collector。
• Incremental（增量运行方式）：目前没要Java GC算法支持这种运行方式。GC以这种方式运行时，GC允许程序做一小段时间的工作，然后做垃圾回收工作。
• Concurrent（并行运行）：Throughput collector此时做minor collect，Concurrent low pause collector此时做minor和major收集。在这种运行方式下，GC和程序并行的运行，因此程序仅仅被短暂的暂停。

GC的阶段
对每个对象而言，垃圾回收分为两个阶段：finalization和reclamation。

• finalization: 指运行这个对象的finalize的方法。
• reclamation: 回收被这个对象使用的内存。
GC的过程的基本步骤

• 首先确认对象是不可达的，即将被回收。
• 其次，如果对象有finalize方法，那么对象被添加进finalization queue中；然后在某个时间点finalize方法被调用以释放finalize中的资源。
• 最后，回收对象占用的内存。
关于finalize方法的问题

• finalize方法使得GC过程做了更多的事情，增加的GC的负担。
• 如果某个对象的finalize方法运行时间过长，它会使得其他对象的finalize方法被延迟执行。
• finalize方法中如果创建了strong reference引用了其他对象，这会阻止此对象被GC。
• finalize方法有可能以不可确定的顺序执行（也就是说要在安全性要求严格的场景中尽量避免使用finalize方法）。
• 不确保finalize方法会被及时调用，也许程序都退出了，但是finalize方法还没被调用。
对象引用的类型

• Reference(or named Strong Reference)（ 强引用）：普通类型的引用。
• SoftReference（ 软引用）：被这种引用指向的对象，如果此对象没要再被其他Strong Reference引用的话，可能在任何时候被GC。虽然是可能在任何时候被GC，但是通常是在可用内存数比较低的时候，并且在程序抛出OutOfMemoryError之前才发生对此对象的GC。SoftReference通常被用作实现Cache的对象引用，如果这个对象被GC了，那么他可以在任何时候再重新被创建。另外，根据JDK文档中介绍，实际JVM的实现是鼓励不回收最近创建和最近使用的对象。SoftReference 类的一个典型用途就是用于内存敏感的高速缓存。
• WeakReference（弱引用）：如果一个被WeakReference引用的对象，当没要任何SoftReference和StrongReference引用时，立即会被GC。和SoftReference的区别是：WeakReference对象是被eagerly collected，即一旦没要任何SoftReference和StrongReference引用，立即被清楚；而只被SoftReference引用的对象，不回立即被清楚，只有当内存不够，即将发生OutOfMemoryError时才被清除，而且是先清除不常用的。SoftReference适合实现Cache用。WeakReference 类的一个典型用途就是规范化映射（ canonicalized mapping ）
• PhantomReference（虚引用）：当没有StrongReference，SoftReference和WeakReference引用时，随时可被GC。通常和ReferenceQueue联合使用，管理和清除与被引用对象（没有finalize方法）相关的本地资源。
衡量GC的指标（GC Metrics）

• Throughput（吞吐量）：所有没有花在执行GC上的时间占总运行时间的比重。
• Pauses（暂停）：当GC在运行时程序的暂停次数。或者是在感兴趣的暂停次数中，暂停的平均时长和最大时长。
• Footprint（足迹？）：当前使用的堆内存大小。
• Promptness（及时性）：不再使用的对象多久能被清除掉并释放其内存。
通用GC算法
Java所使用的所有的GC算法都是通用GC算法概念的变种。
通用GC算法的假设：

• 最近创建的对象很可能很快就不可达了（unreachable，即可被回收了），比如方法内部声明的本地变量，当程序运行出了本地变量的作用范围后，本地变量引用的对象就很快不可达了。
• 一个对象保持可达（reachable）的越久就越不可能被回收。
在Java GC中，对象被划分为generations（代）或spaces（空间）。Java把对象分为young（年轻代），tenured（年老代）和perm（永久代）。在GC过程中，对象从一个space（空间）移动到另一个space。
Object Spaces（对象空间）

• Young：年轻代中保存着刚创建的对象，这个代中的对象能够“minor” or “major” 收集中被回收。
• Tenured：年老代中保存着从年轻代中幸存下来的对象，只能够在“major”中被回收。
• Perm：永久代中保存着JVM所需的对象，比如Class对象和Method对象，以及他们的字节码和内部字符串等。对Perm中的对象GC意味着所有的Class都被卸载了。
每块空间的大小由当前的对内存大小决定，并且能够在运行时改变。每个空间之间的关系如下图所示：

Young Spaces（年轻空间）

• Eden space：存储自从上次GC完毕之后新创建的对象，除了属于Perm的对象。当minor collection发生时，Eden space中的对象或者GC清理掉，或者被移到survivor space。
• Survivor spaces：这个空间中存储的是自从上次GC幸存下来的young object。在minor GC中，这些对象或者被GC清理掉，或者被移到另外一个survivor空间中。
Minor collections和Major collections

• Minor collection当young space被占满时执行。它比major collections快，因为minor collection仅仅检查major collection相应的一个子集对象。minor collection比major collection发生的频率高。
• Major collection当tenured space被占满时执行。他会清理tenured和young。
GC运行的三种方式
在java5和java6中有4中垃圾回收的算法，有一种算法将不再支持，剩余的三种垃圾回收算法是：serial,throughput and concurrent low pause。

• Stop the world（停止所有程序的方式）：在这种方式运行的GC，在GC完成前，JVM中的所有程序都不允许运行。Serial collector此时做minor和major收集。Throughput collector此时做major collector。
• Incremental（增量运行方式）：目前没要Java GC算法支持这种运行方式。GC以这种方式运行时，GC允许程序做一小段时间的工作，然后做垃圾回收工作。
• Concurrent（并行运行）：Throughput collector此时做minor collect，Concurrent low pause collector此时做minor和major收集。在这种运行方式下，GC和程序并行的运行，因此程序仅仅被短暂的暂停。
GC算法

• Serial算法: 使用-XX:+UseSerialGC开启此算法的GC。GC使用和应用程序相同的线程去做minor collection和major collection。
• Throughput：使用-XX:+UseParallelGC开启此算法GC。GC使用多线程去做minor collection以减少程序停止的时间。但是对于major collection，还是使用同程序相同的线程去做。当具有多核cpu时，并且程序有大量的短生命周期的对象时，并且对程序停顿时间不限制时较好。
• Concurrent Low Pause: 使用-XX:+UseConcMarkSweepGC开启此算法GC。使用多线程去做minor和major collection。当具有多核cpu，并且程序有大量的长生命周期的对象，并且对程序停顿时间有限制时，效果较好。
什么时候发生GC
GC发生的时刻受堆内存大小的影响。如果堆内存小，GC会执行的很快，但是又会很快的被填满，因此GC比频繁；如果堆内存很大，GC会执行的较慢，而且不会很快被填满，因此执行的比较频率比较低。

基本的GC调试
throughput goal -XX:GCTimeRatio=n： 表示花费总时间百分之多少的CPU时间去运行程序。
maximum pause time goal -XX:MaxGCPauseMillis=n：每次GC时程序暂停最多多少毫秒。
footprint goal：如果其他目标都达到了，那么首先减少heap size，直到前两个goal不再满足，然后再慢慢增加。直到满足前面两个goal。
-Xms=n (starting) and -Xmx=n (maximum) heap size，这两个参数应该都很熟悉，就是JVM使用的最小堆内存数和最大堆内存数。
-XX:MinHeapFreeRatio=n, -XX:MaxHeapFreeRatio=n：最小和最大的空闲堆内存和被使用堆内存的比例。当空闲堆内存比例小于MinHeapFreeRatio时，内存空间开始扩展。当空闲堆内存比例大于MaxHeapFreeRatio时，内存空间开始减小。
-XX:NewSize=n, -XX:MaxNewSize=n：默认的young space的大小（包括eden + survivor 1 + survivor 2）。
-XX:NewRatio=n：young和tenured的比例。
-XX:SurvivorRatio=n：每个survivor space 和 eden之间的比例。
-XX:MaxPermSize=n：perm的最大size。
-XX:TargetSurvivorRatio=n：每次GC之后幸存下来的空间的目标比例。
-XX:+DisableExplicitGC：当此参数打开时，在程序中调用System.gc()将会不起作用。默认是off。
-XX:+ScavengeBeforeFullGC：当打开此参数时，在每次major collection时先执行一次minor collection。默认打开。
-XX:+UseGCOverheadLimit：当打开此参数时，如果总运行时间的98％的时间都在做GC，则抛出OutOfMemmoryError。默认打开。

参考资料：http://java.ociweb.com/mark/other-presentations/JavaGC.pdf

5. 1）、给你一个网易邮箱的登陆几面如何测试。

2）、给你自己的技术打分，十分满分。
3）、C语言中定义int a和c++中定义int a有什么区别。
4）、C++中public、protect、private属性的问题。
private: 只能由该类中的函数、其友元函数访问
protected: 可以被该类中的函数、子类的函数（public继承下）、以及其友元函数访问
public: 可以被该类中的函数、子类的函数（public继承下）、其友元函数访问，在用户程序中也可以由该类的对象对其进行访问。
一个类友元（包含友元函数或者友元类的所有成员函数）可以访问该类的任何成员（包括成员变量及成员方法）。
C++的访问修饰符的作用是以类为单位，而不是以对象为单位。通俗的讲，同类的对象间可以“互相访问”对方的数据成员，只不过访问途径不是直接访问。
类继承后成员访问属性变化：

1. 使用private继承，父类的所有成员在子类中变为private;

2. 使用protected继承，父类的protected和public成员在子类中变为protected，private成员不变;

3. 使用public继承，父类中的方法属性不发生改变。
   继承类成员函数是不能访问继承过来的基类的私有成员，但可以访问继承过来的公有和保护成员。
   virtual保留字：
   C++的动态多态技术是基于继承机制和虚函数的，多态可以理解成：不同的动作行为可以与同一个记号相关联。通俗的讲：基类类型的指针或引用可以调用基类的函数，也可以执行继承类的函数。这里的函数调用必须有个动态绑定，要实现这种动态绑定必须满足两个条件：
   只有指定为虚函数的成员函数才能进行动态绑定；
   必须 通过基类类型的指针或者引用进行函数调用。
   单纯从virtual关键字出发，考虑两层关系：一个基类一个继承类，使用基类类型引用或者指针进行函数调用，首先在基类中查找一个能与待调用函数实参类型相同的函数，如果找不到，则调用出错；如果找到，看该函数是否是虚函数，如果基类中该函数是虚函数，而且继承类中有相同原型的函数，即使没有用virtual保留字，继承类中的函数自动变成虚函数，然后再运行过程中根据基类指针或引用绑定的对象来调用相应的函数，如果继承类中没有相同原型的函数，即使运行时绑定的是继承类对象，那么还是调用基类中的函数。

4. .项目经验

5. 你了解java反射机制吗，用过没
   JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。。。。。

6. hash的原理及实现

7. .java 多线程
   1）

只要 能使用接口，就不要从Thread类继承
10. .手写快速排序
11. //快速排序
12. void quick_sort(int s[], int l, int r)
13. {
14. if (l < r)
15. {
16. //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
17. int i = l, j = r, x = s[l];
18. while (i < j)
19. {
20. while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
21. j–;
22. if(i < j)
23. s[i++] = s[j];
24.
25. while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
26. i++;
27. if(i < j)
28. s[j–] = s[i];
29. }
30. s[i] = x;
31. quick_sort(s, l, i - 1); // 递归调用
32. quick_sort(s, i + 1, r);
33. }
34. }

另：堆排序：
堆的插入

1. // 新加入i结点 其父结点为(i - 1) / 2

2. void MinHeapFixup(int a[], int i)

3. {

4.  int j, temp;  
   

6.  temp = a[i];  
   

7.  j = (i - 1) / 2;      //父结点  
   

8.  while (j >= 0 && i != 0)  
   

9.  {  
   

10.     if (a[j] <= temp)  
    

11.         break;  
    

13.     a[i] = a[j];     //把较大的子结点往下移动,替换它的子结点  
    

14.     i = j;  
    

15.     j = (i - 1) / 2;  
    

16. }  
    

17. a[i] = temp;  
    

18. }

19. //在最小堆中加入新的数据nNum

20. void MinHeapAddNumber(int a[], int n, int nNum)

21. {

22. a[n] = nNum;  
    

23. MinHeapFixup(a, n);  
    

24. }
    堆的删除

25. // 从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2i+1, 2i+2

26. void MinHeapFixdown(int a[], int i, int n)

27. {

28.  int j, temp;  
    

30.  temp = a[i];  
    

31.  j = 2 * i + 1;  
    

32.  while (j < n)  
    

33.  {  
    

34.     if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的  
    

35.         j++;  
    

37.     if (a[j] >= temp)  
    

38.         break;  
    

40.     a[i] = a[j];     //把较小的子结点往上移动,替换它的父结点  
    

41.     i = j;  
    

42.     j = 2 * i + 1;  
    

43. }  
    

44. a[i] = temp;  
    

45. }

46. //在最小堆中删除数

47. void MinHeapDeleteNumber(int a[], int n)

48. {

49. Swap(a[0], a[n - 1]);  
    

50. MinHeapFixdown(a, 0, n - 1);  
    

51. }
    堆化数组

52. //建立最小堆

53. void MakeMinHeap(int a[], int n)

54. {

55.  for (int i = n / 2 - 1; i >= 0; i--)  
    

56.      MinHeapFixdown(a, i, n);  
    

57. }
    堆排序

58. void MinheapsortTodescendarray(int a[], int n)

59. {

60.  for (int i = n - 1; i >= 1; i--)  
    

61.  {  
    

62.      Swap(a[i], a[0]);  
    

63.      MinHeapFixdown(a, 0, i);  
    

64.  }  
    

65. }

66. .hr考验你对测试知识了解的多少，如何测试淘宝的搜索框

淘宝网购物流程测试用例

测试用例如下：
36. .1)一个算法题 类似于kmp算法

2)最后讲讲了阿里的运营和测试 运维之间的关系与区别

37. 有数据结构、编程语言、计算机网络方面的东西：怎么判断一个链表是闭环的；
38. 千万个数中，怎么找出两个数，使他们和等于200；
39. 请讲诉堆和栈的区别；
    主要的区别由以下几点：
    　　1）、管理方式不同；
    　　2）、空间大小不同；
    　　3）、能否产生碎片不同；
    　　4）、生长方向不同；
    　　5）、分配方式不同；
    　　6）、分配效率不同；
    　　管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
    　　空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：
    　　打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
    　　注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
    　　碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。
    　　生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
    　　分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
    　　分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
    　　从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
    　　虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的内存空间，还是用堆好一些。
    无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，那时候debug可是相当困难的：）
40. 讲一下C++中的内存管理；
41. 三次握手的具体过程 P302
42. 基础知识点：linux基本命令、Java的线程基础写法、SQL查询语言等等
43. 早上第一个面试，面试官没有过多的话语，全程都会看你的简历和笔试或者测评的结果，会问一些你没有做对的地方，技术方面，主要考察大数据的分析题，
    和一些算法编程题，网络、操作系统、数据库都有涉及
44. 两个十亿URL中找到相同的部分 回 答：散列、map后再查重
    海量数据面试题整理

1. 给定a、b两个文件，各存放50亿个url，每个url各占64字节，内存限制是4G，让你找出a、b文件共同的url？
　　方案1：可以估计每个文件安的大小为50G×64=320G，远远大于内存限制的4G。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法。
　　s 遍历文件a，对每个url求取 ，然后根据所取得的值将url分别存储到1000个小文件（记为 ）中。这样每个小文件的大约为300M。
　　s 遍历文件b，采取和a相同的方式将url分别存储到1000各小文件（记为 ）。这样处理后，所有可能相同的url都在对应的小文件（ ）中，不对应的小文件不可能有相同的url。然后我们只要求出1000对小文件中相同的url即可。
　　s 求每对小文件中相同的url时，可以把其中一个小文件的url存储到hash_set中。然后遍历另一个小文件的每个url，看其是否在刚才构建的hash_set中，如果是，那么就是共同的url，存到文件里面就可以了。
　　方案2：如果允许有一定的错误率，可以使用Bloom filter，4G内存大概可以表示340亿bit。将其中一个文件中的url使用Bloom filter映射为这340亿bit，然后挨个读取另外一个文件的url，检查是否与Bloom filter，如果是，那么该url应该是共同的url（注意会有一定的错误率）。
　　2. 有10个文件，每个文件1G，每个文件的每一行存放的都是用户的query，每个文件的query都可能重复。要求你按照query的频度排序。
　　方案1：
　　s 顺序读取10个文件，按照hash(query)%10的结果将query写入到另外10个文件（记为 ）中。这样新生成的文件每个的大小大约也1G（假设hash函数是随机的）。
　　s 找一台内存在2G左右的机器，依次对 用hash_map(query, query_count)来统计每个query出现的次数。利用快速/堆/归并排序按照出现次数进行排序。将排序好的query和对应的query_cout输出到文件中。这样得到了10个排好序的文件（记为 ）。
　　s 对 这10个文件进行归并排序（内排序与外排序相结合）。
　　方案2：
　　一般query的总量是有限的，只是重复的次数比较多而已，可能对于所有的query，一次性就可以加入到内存了。这样，我们就可以采用trie树/hash_map等直接来统计每个query出现的次数，然后按出现次数做快速/堆/归并排序就可以了。
　　方案3：
　　与方案1类似，但在做完hash，分成多个文件后，可以交给多个文件来处理，采用分布式的架构来处理（比如MapReduce），最后再进行合并。
　　3. 有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词。
　　方案1：顺序读文件中，对于每个词x，取 ，然后按照该值存到5000个小文件（记为 ）中。这样每个文件大概是200k左右。如果其中的有的文件超过了1M大小，还可以按照类似的方法继续往下分，知道分解得到的小文件的大小都不超过1M。对每个小文件，统计每个文件中出现的词以及相应的频率（可以采用trie树/hash_map等），并取出出现频率最大的100个词（可以用含100个结点的最小堆），并把100词及相应的频率存入文件，这样又得到了5000个文件。下一步就是把这5000个文件进行归并（类似与归并排序）的过程了。
　　4. 海量日志数据，提取出某日访问百度次数最多的那个IP。
　　方案1：首先是这一天，并且是访问百度的日志中的IP取出来，逐个写入到一个大文件中。注意到IP是32位的，最多有 个IP。同样可以采用映射的方法，比如模1000，把整个大文件映射为1000个小文件，再找出每个小文中出现频率最大的IP（可以采用hash_map进行频率统计，然后再找出频率最大的几个）及相应的频率。然后再在这1000个最大的IP中，找出那个频率最大的IP，即为所求。
　　5. 在2.5亿个整数中找出不重复的整数，内存不足以容纳这2.5亿个整数。
　　方案1：采用2-Bitmap（每个数分配2bit，00表示不存在，01表示出现一次，10表示多次，11无意义）进行，共需内存 内存，还可以接受。然后扫描这2.5亿个整数，查看Bitmap中相对应位，如果是00变01，01变10，10保持不变。所描完事后，查看bitmap，把对应位是01的整数输出即可。
　　方案2：也可采用上题类似的方法，进行划分小文件的方法。然后在小文件中找出不重复的整数，并排序。然后再进行归并，注意去除重复的元素。
　　6. 海量数据分布在100台电脑中，想个办法高校统计出这批数据的TOP10。
　　方案1：
　　s 在每台电脑上求出TOP10，可以采用包含10个元素的堆完成（TOP10小，用最大堆，TOP10大，用最小堆）。比如求TOP10大，我们首先取前10个元素调整成最小堆，如果发现，然后扫描后面的数据，并与堆顶元素比较，如果比堆顶元素大，那么用该元素替换堆顶，然后再调整为最小堆。最后堆中的元素就是TOP10大。
　　s 求出每台电脑上的TOP10后，然后把这100台电脑上的TOP10组合起来，共1000个数据，再利用上面类似的方法求出TOP10就可以了。
　　7. 怎么在海量数据中找出重复次数最多的一个？
　　方案1：先做hash，然后求模映射为小文件，求出每个小文件中重复次数最多的一个，并记录重复次数。然后找出上一步求出的数据中重复次数最多的一个就是所求（具体参考前面的题）。
　　8. 上千万或上亿数据（有重复），统计其中出现次数最多的钱N个数据。
　　方案1：上千万或上亿的数据，现在的机器的内存应该能存下。所以考虑采用hash_map/搜索二叉树/红黑树等来进行统计次数。然后就是取出前N个出现次数最多的数据了，可以用第6题提到的堆机制完成。
　　9. 1000万字符串，其中有些是重复的，需要把重复的全部去掉，保留没有重复的字符串。请怎么设计和实现？
　　方案1：这题用trie树比较合适，hash_map也应该能行。
　　10. 一个文本文件，大约有一万行，每行一个词，要求统计出其中最频繁出现的前10个词，请给出思想，给出时间复杂度分析。
　　方案1：这题是考虑时间效率。用trie树统计每个词出现的次数，时间复杂度是O(nle)（le表示单词的平准长度）。然后是找出出现最频繁的前10个词，可以用堆来实现，前面的题中已经讲到了，时间复杂度是O(nlg10)。所以总的时间复杂度，是O(nle)与O(nlg10)中较大的哪一个。
　　11. 一个文本文件，找出前10个经常出现的词，但这次文件比较长，说是上亿行或十亿行，总之无法一次读入内存，问最优解。
　　方案1：首先根据用hash并求模，将文件分解为多个小文件，对于单个文件利用上题的方法求出每个文件件中10个最常出现的词。然后再进行归并处理，找出最终的10个最常出现的词。
　　12. 100w个数中找出最大的100个数。
　　方案1：在前面的题中，我们已经提到了，用一个含100个元素的最小堆完成。复杂度为O(100wlg100)。
　　方案2：采用快速排序的思想，每次分割之后只考虑比轴大的一部分，知道比轴大的一部分在比100多的时候，采用传统排序算法排序，取前100个。复杂度为O(100w100)。
　　方案3：采用局部淘汰法。选取前100个元素，并排序，记为序列L。然后一次扫描剩余的元素x，与排好序的100个元素中最小的元素比，如果比这个最小的要大，那么把这个最小的元素删除，并把x利用插入排序的思想，插入到序列L中。依次循环，知道扫描了所有的元素。复杂度为O(100w*100)。
　　13. 寻找热门查询：
　　搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。假设目前有一千万个记录，这些查询串的重复读比较高，虽然总数是1千万，但是如果去除重复和，不超过3百万个。一个查询串的重复度越高，说明查询它的用户越多，也就越热门。请你统计最热门的10个查询串，要求使用的内存不能超过1G。
　　(1) 请描述你解决这个问题的思路；
　　(2) 请给出主要的处理流程，算法，以及算法的复杂度。
　　方案1：采用trie树，关键字域存该查询串出现的次数，没有出现为0。最后用10个元素的最小推来对出现频率进行排序。
　　14. 一共有N个机器，每个机器上有N个数。每个机器最多存O(N)个数并对它们操作。如何找到 个数中的中数？
　　方案1：先大体估计一下这些数的范围，比如这里假设这些数都是32位无符号整数（共有 个）。我们把0到 的整数划分为N个范围段，每个段包含 个整数。比如，第一个段位0到 ，第二段为 到 ，…，第N个段为 到 。然后，扫描每个机器上的N个数，把属于第一个区段的数放到第一个机器上，属于第二个区段的数放到第二个机器上，…，属于第N个区段的数放到第N个机器上。注意这个过程每个机器上存储的数应该是O(N)的。下面我们依次统计每个机器上数的个数，一次累加，直到找到第k个机器，在该机器上累加的数大于或等于 ，而在第k-1个机器上的累加数小于 ，并把这个数记为x。那么我们要找的中位数在第k个机器中，排在第 位。然后我们对第k个机器的数排序，并找出第 个数，即为所求的中位数。复杂度是 的。
　　方案2：先对每台机器上的数进行排序。排好序后，我们采用归并排序的思想，将这N个机器上的数归并起来得到最终的排序。找到第 个便是所求。复杂度是 的。
　　15. 最大间隙问题
　　给定n个实数 ，求着n个实数在实轴上向量2个数之间的最大差值，要求线性的时间算法。
　　方案1：最先想到的方法就是先对这n个数据进行排序，然后一遍扫描即可确定相邻的最大间隙。但该方法不能满足线性时间的要求。故采取如下方法：
　　s 找到n个数据中最大和最小数据max和min。
　　s 用n-2个点等分区间[min, max]，即将[min, max]等分为n-1个区间（前闭后开区间），将这些区间看作桶，编号为 ，且桶 的上界和桶i+1的下届相同，即每个桶的大小相同。每个桶的大小为： 。实际上，这些桶的边界构成了一个等差数列（首项为min，公差为 ），且认为将min放入第一个桶，将max放入第n-1个桶。
　　s 将n个数放入n-1个桶中：将每个元素 分配到某个桶（编号为index），其中 ，并求出分到每个桶的最大最小数据。
　　s 最大间隙：除最大最小数据max和min以外的n-2个数据放入n-1个桶中，由抽屉原理可知至少有一个桶是空的，又因为每个桶的大小相同，所以最大间隙不会在同一桶中出现，一定是某个桶的上界和气候某个桶的下界之间隙，且该量筒之间的桶（即便好在该连个便好之间的桶）一定是空桶。也就是说，最大间隙在桶i的上界和桶j的下界之间产生 。一遍扫描即可完成。
　　16. 将多个集合合并成没有交集的集合：给定一个字符串的集合，格式如： 。要求将其中交集不为空的集合合并，要求合并完成的集合之间无交集，例如上例应输出 。
　　(1) 请描述你解决这个问题的思路；
　　(2) 给出主要的处理流程，算法，以及算法的复杂度；
　　(3) 请描述可能的改进。
　　方案1：采用并查集。首先所有的字符串都在单独的并查集中。然后依扫描每个集合，顺序合并将两个相邻元素合并。例如，对于 ，首先查看aaa和bbb是否在同一个并查集中，如果不在，那么把它们所在的并查集合并，然后再看bbb和ccc是否在同一个并查集中，如果不在，那么也把它们所在的并查集合并。接下来再扫描其他的集合，当所有的集合都扫描完了，并查集代表的集合便是所求。复杂度应该是O(NlgN)的。改进的话，首先可以记录每个节点的根结点，改进查询。合并的时候，可以把大的和小的进行合，这样也减少复杂度。
　　17. 最大子序列与最大子矩阵问题
　　数组的最大子序列问题：给定一个数组，其中元素有正，也有负，找出其中一个连续子序列，使和最大。
　　方案1：这个问题可以动态规划的思想解决。设 表示以第i个元素 结尾的最大子序列，那么显然 。基于这一点可以很快用代码实现。
　　最大子矩阵问题：给定一个矩阵（二维数组），其中数据有大有小，请找一个子矩阵，使得子矩阵的和最大，并输出这个和。
　　方案1：可以采用与最大子序列类似的思想来解决。如果我们确定了选择第i列和第j列之间的元素，那么在这个范围内，其实就是一个最大子序列问题。如何确定第i列和第j列可以词用暴搜的方法进行。

45. 如何在查询时显示最热门的几个词语，算法

47天猫和淘宝还有什么可改进的地方
物流，安全，评价系统

自我介绍。爱好。介绍一个你参加的活动。
和项目相关的：map和reduce
Java:hashtable,垃圾回收机制，string和stringbuffer的区别。多态和继承的关系，重写和重载，java里面有哪些数据流，java有哪几个区（堆，栈，静态存储区）分别存哪些数据，malloc的区域在哪个里面，空类默认的函数，
数据结构：平衡二叉树，B+数，快速排序，冒泡排序，希尔排序，堆排序
数据库：范式的作用和概念，sql语句的内部实现，
网络：七层模型和五层模型，交换机和路由器属于哪一层，qq视频属于什么协议，tcp和udp的区别，tcp的三次握手协议，回传的时候几次握手以及为什么
操作系统：存储结构，
测试：测试一个灯泡（功能，性能，安全，异常）

一． C++面试常问知识点：（详见：《程序员面试笔试宝典》）

1. static（静态）变量有什么作用（7.1.1）
2. virtual关键字
3. const有哪些作用（7.1.2）或《王道程序员求职宝典》P95
4. new/delete与malloc/free的区别是什么（注：malloc无返回类型，记一下原函数）（7.1.14）
5. 内存分配形式有哪些（7.2.1）（如果简历上写熟悉C/C++，这里会经常问到C和C++内存管理的区别）
6. 什么是内存泄漏（7.2.2）
7. 野指针？空指针（7.4.6）
8. typedef 和 define有什么区别（7.5.14）
9. C++中宏定义与内联函数有什么区别（7.5.15）
10. 定义常量谁更好？ #define还是const（7.5.16）
11. 重载与覆盖有什么区别（7.8.4）
12. 全局变量和静态变量有什么异同（7.10.1）
13. 7.13 面向对象相关（7.13.2~7.13.16都要看）
14. 7.14 虚函数 （7.14.1~7.14.7共7个小结都看，尤其是：多态，如何实现多态）
15. 指针和引用的区别（《王道程序员求职宝典》P133下半页）

二． 手写代码部分（涵盖数据结构考点）：

1. 《剑指offer》（刷leetcode也可以，我身边的看剑指offer较多）
   （我给出的电子书是老版的，新版有新增内容）
   http://www.nowcoder.com/ta/coding-interviews?page=
2. 二叉树的前、中、后序非递归遍历代码实现（详见文档：二叉树和KMP代码）。以及 层次序遍历（见：《剑指offer》）。
3. 一棵二叉树，从左边看去，将看到的节点连接成一个单链表（提示：二叉树前序遍历）
4. 部分公司会考KMP，相对较少。（见文档：二叉树和KMP代码）
5. 快排最常考，以及快排的各种变形。（《王道程序员求职宝典》P252）
6. 折半查找（偶尔考）
7. 图的深度，广度遍历
8. 海量数据
   说明：常考的手写代码：链表部分，二叉树，排序算法等。C语言上课时老师布置的作业，绝大部分是面试官让手写的那种题目。很多大的互联网公司会让写《剑指offer》上面的原题
   数据结构 与 算法问答部分：
9. 堆和栈的区别（见文档：c++内存管理）
10. 红黑树定义
11. 动态规划 与 贪心算法（研发岗，有时会考动态规划的LCS，详见《王道程序员求职宝典》：p189）
12. 背包问题 几种？（自己百度）
    说明：红黑树，动态规划，0-1背包在《算法导论》里，本科生有可能没学过，看自己情况而定

三． 计算机网络：

1. Tcp/Ip五层模型（物理层，数据链路层，网络层，传输层，应用层）以及各层工作的协议有哪些(发散性的问，例如DNS是基于TCP的还是UDP：《王道程序员求职宝典》P300选择题9)。有时候也会让说一下 OSI七层模型。
2. tcp/udp区别
   1） tcp基于连接的，udp基于无连接的
   2） tcp对系统资源要求多，udp要求少
   3） udp程序结构简单
   4） tcp是流模式，udp是数据报模式
   5） tcp保证正确性，udp可能丢包；tcp保证数据顺序，udp不能保证
3. tcp三次握手，四次挥手 过程（《王道程序员求职宝典》P302）
4. http工作过程（也可以自己百度）http://www.cnblogs.com/fakis/archive/2011/02/25/1976568.html
5. http状态码，代表什么含义（有时候会直接给你一个状态码，问代表什么意思，也经常用来考选择题）http://blog.jobbole.com/88450/（仅供参考，可以自己在网上找）
6. 有时候会问ARP和RARP协议是干什么用的

四． 数据库：（《王道程序员求职宝典》，也可自己找更详细的资料看）

1. select语句最常考，一般给定一个表格场景条件，让写语句。（其他语句最好也看看，像删除表，更新表格等等等）
2. 主键外键，给定场景让说出哪个是主键哪个是外键（偶尔考）
3. 左外链接，右外连接，全连接等（自己百度一下）
   五． 操作系统：
4. 进程和线程的区别（《王道程序员求职宝典》P325例5）
5. 进程间通信方式（偶尔考）
6. 死锁，产生死锁的四个条件（《王道程序员求职宝典》P329）有时候 也会给定一个死锁场景，问如何做才能解除死锁。

六． Linux

1. 上课常用的命令，例如：pwd等等。最常问的是：查看进程状态的命令
2. socket编程过程（简历上写的话，会问到，如简历上写：了解Linux操作系统、网络协议及Socket编程）
3. 对shell熟悉吗？

七． 设计模式：
一些互联网公司会问一些简单的模型，例如单例模式，抽象工厂模式等等。简历上不写，一般不问，大的公司会问。。。

八． 常问非知识相关的问题
1． 职业规划（了解部门相关晋升机制）
2． 为什么会应聘X岗位或为什么来应聘我们公司（问岗位的话，要多夸应聘岗位的重要性，问公司的话，要说发展前景等等要提前了解该公司）
3． 你觉得自己哪方面（编码能力，专业能力等）适合这份工作？（说自己的优点）
4． 你有什么问题要问我的？（问一下，岗前培训等表现出自己积极工作的问题）

九． 测试相关的岗位
会额外问测试基础知识（详见：12_软件测试.pdf），以及场景题，常见的是给一部电梯需要从哪些方面测试，或者自动售货机。有时候也会问地铁门（注意地铁每一个门是两层门，并且是有多个门（列车每节车厢都有门），例如如果其中有一个门有人被夹，所有的门都会自动打开吗，还是只那一个打开。等等，很多方面都需要考虑）（详见：经典测试用例等文档）

十． 附加部分公司面试：（有我自己的 也有我搜集身边同学的）
找对应公司的面试经验，可以去看准网http://www.kanzhun.com/（不过里面有很多水军，应该也有其他的面试经验网站，可以自己找找）
阿里的实习生招聘（广州站），报的是研发工程师C/C++
第一面：
1、 C++的static问题；
2、 C++的virtual问题；
3、 实现一个非递归中序遍历二树算法；
4、 讲解自己做的项目！我的项目中用到了较多的机器学习方法，所以给他推了下SVM的公式，讲了下LBP的原理!
………

第二面：
1、 说说自己印象最深的一个项目；
2、 写个快速排序算法；
3、 大数据问题：一次性不能读入内存，查找出现次数最多的10个字符串；
4、 如何能快速更新推荐到你手机上的信息，当你所处的位置发生变化时！
5、 自己的职业规划!
…….
6、 有什么要问我的？
百度的校园招聘（哈尔滨站），报的是测试开发工程师（这里并不是一个人的一面二面三面，集合起来几个人的，所以每一面问题看着多了一些）
第一面：
1、 自我介绍以及项目
2、 堆、栈的区别
3、 排序算法时间复杂度和实现
4、 进程和线程
5、 系统设计：设计处理海量数据的系统（秒抢系统）
6、 网络和数据库相关的，数据库几个select语句；索引的作用；左外链接，右外连接，全连接（有时候笔试也会考，写出语句，以及说出他们间区别）
7、 手写代码：
a) 二分查找（注意 mid赋值时，尽量写mid=L+(R-L)/2取代mid=(L+R)/2，因为（L+R）计算时有可能产生溢出）
b) 链表的环（《王道程序员求职宝典》P200）
c) 二叉树广度遍历
d) 海量数据找出一条

第二面：
1、 http协议怎么实现的
2、 tcp三次握手
3、 数据挖掘的方法
4、 数据库相关的
5、 atoi函数实现（注意测试相关的问题，例如：边界值及错误的判断：《剑指offer》面试题49）
6、 KMP代码
7、 最大的k个数（类似于《剑指offer》面试题30，注意求最大不是最小，最大k个用小根堆，使用less而不是greater）
第三面：
1、 项目
2、 百度产品的测试（例如搜索引擎从哪几方面测试，百度有很多产品，说出一个熟悉的让测）
3、 写一个字符翻转的代码
百度其他岗位面试：
写代码部分：
e) 找字符中的回文串
f) 最长公共子序列
g) double型数字的p次方（注意正负，是否为0）
h) 之字打印二叉树（见：剑指offer新增内容部分）
i) 二叉树序列化（见：剑指offer新增内容部分）
j) 实现Ｎ！至少两种方式
滴滴出行：（北京站） 测试开发岗位（问的特别多，是第几面问的分不清了）
1、 自我介绍->介绍项目
2、 手写代码：
a) X=3,Y=7不借助第三个变量 交换两个数
b) KMP
c) 实现字符串转换成int类型（《剑指offer》面试题49，P244）
d) 实现输出字符串第一个出现的字符（《剑指offer》面试题35，P186）
e) 将一个字符串中的单词分别逆置（《剑指offer》面试题42，P218）
f) 求连续子数组的最大和（《剑指offer》面试题31，P171）
g) 替换空格（《剑指offer》面试题4，P44，写出代码后，面试官又扩展了一下）
h) 调整数组顺序使奇数位于偶数前面（《剑指offer》面试题14，P102）
i) 合并两个排序的链表（《剑指offer》面试题17，P114）
j) 链表中倒数第k个节点（《剑指offer》面试题15，P107）
k) 数组中超过一半的数字（《剑指offer》面试题29，P163）
l) 给出一串单词，判断他们能否首尾相连 形成一个环，例如：good，doctor，read，dug（具体例子忘了，感觉有点难）（提示：图的深度遍历）
3、 C/C++
a) Static 变量的作用
b) malloc函数
c) C语言分配内存的方式
4、 系统设计会不会
5、 网络：
a) TCP/IP 协议
b) TCP和UDP的区别
c) 访问一个网址，http协议工作的全过程
6、 操作系统：
a) 进程与线程；
b) 死锁（三个进程循环等待，如何解除死锁）
7、 数据库：表A，3个字段 name，class，score，请用一条select语句求出每个班级分数及格人数 及 每个班级分数不及格人数
8、 Linux说自己了解的命令
9、 智力题：
a) 全家过河问题（具体可以百度一下）
b) 烧一根不均匀的绳子,从头烧到尾是要1个小时.现在有若干条材质相同的绳子
问如何用烧绳的方法来计时一个小时15分钟.
c) 给几瓶药，一瓶有毒，需要用几个人测？（《王道程序员求职宝典》P358 第2小题）
10、 测试部分：
k) 测试电梯调度
l) 测试自动售货机
m) 测试地铁门
11、 职业规划
12、 看好滴滴出行公司的哪一方面：中国互联网专车，开创了一个出行新模式的新局面。。。
CVTE面试：（广州站）C++研发岗位
第一面：
1、 自我介绍->项目介绍
2、 const 关键字作用
3、 TCP三次握手、四次挥手 过程，为什么？
4、 内存区域分为哪几块？
5、 内联函数的作用？内联函数里面可以写for循环吗？
6、 C++中多态如何实现的？
7、 写代码：二分查找
说明：问题2_{7，都是《程序员面试笔试宝典》7.13}7.14章节内的原题。
1、 虚构函数有返回值吗？（答：没有）为什么？
2、 初始化序列和构造函数初始化有什么区别？
3、 什么时候必须使用初始化列表初始化？
4、 空类中自带哪些函数？
5、 构造函数可以为virtual吗？（答：不可以）为什么？
6、 。。。。
7、 排序算法中哪一个不是基于比较的？
8、 写代码：给定行数，打印出杨辉三角
9、 写代码：判断两个链表是否有公共节点
10、 Linux：长连接，短连接；select的使用
11、 四叉树应用场景
12、 dequeue和queque的区别？dequeque(双端队列)应用场景是什么？

1、 写代码：
d) 单链表中间节点
e) 链表排序（具体忘了）
f) 删除链表的指定节点
g) 二分查找
h) 找两个无序数组的相同的数（三个有序数组，找共同的数）
i) 合并两个有序数组到一个中
2、 问答：const引用和非const引用