前端面试常见的几个问题

内容简介：
1、二叉树
2、最优二叉树
3、最短路径
4、三次握手
5、JS垃圾回收机制

1、二叉树

二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。
(1)空二叉树——如图(a)；
(2)只有一个根结点的二叉树——如图(b)；
(3)只有左子树——如图©；
(4)只有右子树——如图(d)；
(5)完全二叉树——如图(e)

二叉树常用遍历方式(上图e为例)
先序遍历----首先访问根，再先序遍历左（右）子树，最后先序遍历右（左）子树，C语言代码如下：
void XXBL(tree *root){
if(root->lchild!=NULL)
XXBL(root->lchild);
if(root->rchild!=NULL)
XXBL(root->rchild);
}
中序遍历----首先中序遍历左（右）子树，再访问根，最后中序遍历右（左）子树，C语言代码如下
void ZXBL(tree *root)
{
if(root->lchild!=NULL)
ZXBL(root->lchild);
//Do something with root
if(root->rchild!=NULL)
ZXBL(root->rchild);
}
后序遍历------首先后序遍历左（右）子树，再后序遍历右（左）子树，最后访问根，C语言代码如下
void HXBL(tree *root){
if(root->lchild!=NULL)
HXBL(root->lchild);
if(root->rchild!=NULL)
HXBL(root->rchild);
//Do something with root
}

2、最优二叉树

哈夫曼树(Huffman)树又称最优二叉树,是指对于一组带有确定权值的叶子结点所构造的具有带权路径长度最短的二叉树。
哈夫曼树构建过程：
【0.2,0.7,0.3，0.8,0.4】
构建结果：

3、最短路径

最短路径算法是计算机网络里一个常用的路由算法，该算法可以找出网络中从一个节点到另一个节点的最短路径。
最短路径作用：实现距离最短以及时间最短，从而为你节约行程的成本
假如从节点A出发，要到达节点D，最短路径应该是怎样呢？

对上图来说，从节点A到节点D的最短路径应该是A->B->E->F->H->D。
最短路径算法如下：
void shortest_path(int s, int t, int *path)
{
struct state{
int predecessor;
int length;
enum { permanent, tentative } label;
}state[MAX_NODE];

int i, k, min;
struct state *p;g

for (p = &state[0]; p < &state[n]; p++){
    p->predecessor = -1;
    p->length = INFINITY;
    p->label = tentative;
}
state[t].length = 0; state[t].label = permanent;
k = t;
do{
    for (i = 0; i < n; i++)
    if (dist[k][i] != 0 && state[i].label == tentative){
        if (state[k].length + dist[k][i] < state[i].length){
            state[i].predecessor = k;
            state[i].length = state[k].length + dist[k][i];
        }
    }

    k = 0; min = INFINITY;
    for (i = 0; i < n; i++)
    if (state[i].label == tentative&&state[i].length < min){
        min = state[i].length;
        k = i;
    }
    state[k].label = permanent;
} while (k != s);

i = 0; k = s;
do{ path[i++] = k; k = state[k].predecessor; } while (k >= 0);
}

4、三次握手

是TCP 数据传输的一个过程：

重传：客户端没有收到服务端的回应（两个原因：1、客户端没有传送过去；2、服务端的回应没有被客户端接收到）这时客户端就是重新发送请求也就是重传
去重：在重传过程中，服务端需要收到多次客户端的请求，但是它只需要收到一次，操作系统的网络内核模块会自动去重，只留下一次

5、JS中垃圾回收机制

Js具有自动垃圾回收机制。垃圾收集器会按照固定的时间间隔周期性的执行。
垃圾回收：JavaScript 中的内存管理是自动执行的，而且是不可见的。我们创建基本类型、对象、函数……所有这些都需要内存。
当不再需要某样东西时，JavaScript 引擎是需要去发现并清理它，这就是我们所说的垃圾回收。

JS中垃圾回收方式一：标记清除。

工作原理：是当变量进入环境时，将这个变量标记为“进入环境”。当变量离开环境时，则将其标记为“离开环境”。标记“离开环境”的就回收内存。
工作流程：

1. 垃圾回收器，在运行的时候会给存储在内存中的所有变量都加上标记。
2. 去掉环境中的变量以及被环境中的变量引用的变量的标记。
3. 再被加上标记的会被视为准备删除的变量。
4. 垃圾回收器完成内存清除工作，销毁那些带标记的值并回收他们所占用的内存空间。

JS中垃圾回收方式二：引用计数方式

工作原理：跟踪记录每个值被引用的次数。
工作流程：
1 声明了一个变量并将一个引用类型的值赋值给这个变量，这个引用类型值的引用次数就是1。
2. 同一个值又被赋值给另一个变量，这个引用类型值的引用次数加1.
3. 当包含这个引用类型值的变量又被赋值成另一个值了，那么这个引用类型值的引用次数减1.
4. 当引用次数变成0时，说明没办法访问这个值了。
5. 当垃圾收集器下一次运行时，它就会释放引用次数是0的值所占的内存。

内存泄漏：不再用到的内存，没有及时释放，就叫做内存泄漏。

什么情况会引起内存泄漏？
虽然有垃圾回收机制但是我们编写代码操作不当还是会造成内存泄漏。

1. 意外的全局变量引起的内存泄漏。
   原因：全局变量，不会被回收。
   解决：使用严格模式避免。
2. 闭包引起的内存泄漏
   原因：闭包可以维持函数内局部变量，使其得不到释放。
   解决：将事件处理函数定义在外部，解除闭包,或者在定义事件处理函数的外部函数中，删除对dom的引用。
3. 没有清理的DOM元素引用
   原因：虽然别的地方删除了，但是对象中还存在对dom的引用
   解决：手动删除。
4. 被遗忘的定时器或者回调
   原因：定时器中有dom的引用，即使dom删除了，但是定时器还在，所以内存中还是有这个dom。
   解决：手动删除定时器和dom。
5. 子元素存在引用引起的内存泄漏
   原因：div中的ul li 得到这个div，会间接引用某个得到的li，那么此时因为div间接引用li，即使li被清空，也还是在内存中，并且只要li不被删除，他的父元素都不会被删除。
   解决：手动删除清空。