前言
前面的几篇文章分别给大家介绍了数据库、计算机网络、操作系统在面试中的一些常见的问题。今天我们给大家介绍在面试中，数据结构常见的面试题。数据结构与算法在面试中占有很大的比重，在本科的时候，我们也学过数据结构与算法，内容比较多，还比较难，尤其是到了树的那三种深度优先遍历和层次遍历，是核心也是难点，还有图的最短路径以及两种最小生成树，以及最后的十大排序算法和常用的查找，这些都是重点也是核心。在最近的笔试、面试中，数据结构在面试中占很大的比重，我们在刷那68道剑指offer中也不难发现，数据结构在笔试中的实际应用，因此，整理一些常见的笔试/面试的数据结构常用的点是很有必要的，方便大家查阅。
面试题及参考答案
一、树
1、请你来说一说红黑树和AVL树的定义，特点，以及二者区别，另外说明为什么map底层为什么用红黑树实现？
1、平衡二叉树（AVL树）：
平衡二叉树又称为AVL树，是一种特殊的二叉排序树。其左右子树都是平衡二叉树，且左右子树高度之差的绝对值不超过1。一句话表述为：以树中所有结点为根的树的左右子树高度之差的绝对值不超过1。将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF，那么平衡二叉树上的所有结点的平衡因子只可能是-1、0和1。只要二叉树上有一个结点的平衡因子的绝对值大于1，则该二叉树就是不平衡的。
2、红黑树：
红黑树是一种二叉查找树，但在每个节点增加一个存储位表示节点的颜色，可以是红或黑（非红即黑）。通过对任何一条从根到叶子的路径上各个节点着色的方式的限制，红黑树确保没有一条路径会比其它路径长出两倍，因此，红黑树是一种弱平衡二叉树，相对于要求严格的AVL树来说，它的旋转次数少，所以对于搜索，插入，删除操作较多的情况下，通常使用红黑树。
- 性质：
- 每个节点非红即黑
- 根节点是黑的;
- 每个叶节点（叶节点即树尾端NULL指针或NULL节点）都是黑的;
- 如果一个节点是红色的，则它的子节点必须是黑色的。
- 对于任意节点而言，其到叶子点树NULL指针的每条路径都包含相同数目的黑节点;
- 区别：
AVL 树是高度平衡的，频繁的插入和删除，会引起频繁的rebalance，导致效率下降；红黑树不是高度平衡的，算是一种折中，插入最多两次旋转，删除最多三次旋转。所以红黑树在查找，插入删除的性能都是O(logn)，且性能稳定，所以STL里面很多结构包括map底层实现都是使用的红黑树。
2、请你说一说map和unordered_map的底层实现，另外说明map和unordered_map优点和缺点？
map底层是基于红黑树实现的，因此map内部元素排列是有序的。而unordered_map底层则是基于哈希表实现的，因此其元素的排列顺序是杂乱无序的。
- 对于map，其底层是基于红黑树实现的，优点如下：
1)有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作
2)map的查找、删除、增加等一系列操作时间复杂度稳定，都为logn
缺点如下：
1）查找、删除、增加等操作平均时间复杂度较慢，与n相关- 对于unordered_map来说，其底层是一个哈希表，优点如下：
查找、删除、添加的速度快，时间复杂度为常数级O( c )
缺点如下：
1、因为unordered_map内部基于哈希表，以（key,value）对的形式存储，因此空间占用率高
2、Unordered_map的查找、删除、添加的时间复杂度不稳定，平均为O( c )，取决于哈希函数。极端情况下可能为O(n)
3、请你说一下哈夫曼编码
哈夫曼编码是哈夫曼树的一种应用，广泛用于数据文件压缩。哈夫曼编码算法用字符在文件中出现的频率来建立使用0，1表示个字符的最优表示方式，其具体算法如下：
(1)哈夫曼算法以自底向上的方式构造表示最优前缀码的二叉树T。
(2)算法以|C|个叶结点开始，执行|C|－1次的“合并”运算后产生最终所要求的树T。
(3)假设编码字符集中每一字符c的频率是f©。以f为键值的优先队列Q用在贪心选择时有效地确定算法当前要合并的2棵具有最小频率的树。一旦2棵具有最小频率的树合并后，产生一棵新的树，其频率为合并的2棵树的频率之和，并将新树插入优先队列Q。经过n－1次的合并后，优先队列中只剩下一棵树，即所要求的树T。
4、请你介绍一下B+树
B+是一种多路搜索树，主要为磁盘或其他直接存取辅助设备而设计的一种平衡查找树，在B+树中，每个节点的可以有多个孩子，并且按照关键字大小有序排列。所有记录节点都是按照键值的大小顺序存放在同一层的叶节点中。相比B树，其具有以下几个特点：
- 每个节点上的指针上限为2d而不是2d+1（d为节点的出度）
- 内节点不存储data,只存储key
- 叶子节点不存储指针
5、请你回答一下epoll怎么实现的
Linux epoll机制是通过红黑树和双向链表实现的。 首先通过epoll_create()系统调用在内核中创建一个eventpoll类型的句柄，其中包括红黑树根节点和双向链表头节点。然后通过epoll_ctl()系统调用，向epoll对象的红黑树结构中添加、删除、修改感兴趣的事件，返回0标识成功，返回-1表示失败。最后通过epoll_wait()系统调用判断双向链表是否为空，如果为空则阻塞。当文件描述符状态改变，fd上的回调函数被调用，该函数将fd加入到双向链表中，此时epoll_wait函数被唤醒，返回就绪好的事件。
6、 请你说一说Top(K)问题
1、直接全部排序（只适用于内存够的情况）
当数据量较小的情况下，内存中可以容纳所有数据。则最简单也是最容易想到的方法是将数据全部排序，然后取排序后的数据中的前K个。
这种方法对数据量比较敏感，当数据量较大的情况下，内存不能完全容纳全部数据，这种方法便不适应了。即使内存能够满足要求，该方法将全部数据都排序了，而题目只要求找出top K个数据，所以该方法并不十分高效，不建议使用。
2、快速排序的变形 （只使用于内存够的情况）
这是一个基于快速排序的变形，因为第一种方法中说到将所有元素都排序并不十分高效，只需要找出前K个最大的就行。
这种方法类似于快速排序，首先选择一个划分元，将比这个划分元大的元素放到它的前面，比划分元小的元素放到它的后面，此时完成了一趟排序。如果此时这个划分元的序号index刚好等于K，那么这个划分元以及它左边的数，刚好就是前K个最大的元素；如果index > K，那么前K大的数据在index的左边，那么就继续递归的从index-1个数中进行一趟排序；如果index < K，那么再从划分元的右边继续进行排序，直到找到序号index刚好等于K为止。再将前K个数进行排序后，返回Top K个元素。这种方法就避免了对除了Top K个元素以外的数据进行排序所带来的不必要的开销。
3、最小堆法
这是一种局部淘汰法。先读取前K个数，建立一个最小堆。然后将剩余的所有数字依次与最小堆的堆顶进行比较，如果小于或等于堆顶数据，则继续比较下一个；否则，删除堆顶元素，并将新数据插入堆中，重新调整最小堆。当遍历完全部数据后，最小堆中的数据即为最大的K个数。
4、分治法
将全部数据分成N份，前提是每份的数据都可以读到内存中进行处理，找到每份数据中最大的K个数。此时剩下NK个数据，如果内存不能容纳NK个数据，则再继续分治处理，分成M份，找出每份数据中最大的K个数，如果M*K个数仍然不能读到内存中，则继续分治处理。直到剩余的数可以读入内存中，那么可以对这些数使用快速排序的变形或者归并排序进行处理。
5、Hash法
如果这些数据中有很多重复的数据，可以先通过hash法，把重复的数去掉。这样如果重复率很高的话，会减少很大的内存用量，从而缩小运算空间。处理后的数据如果能够读入内存，则可以直接排序；否则可以使用分治法或者最小堆法来处理数据。
7、请你说说红黑树的旋转
旋转：红黑树的旋转是一种能保持二叉搜索树性质的搜索树局部操作。有左旋和右旋两种旋转，通过改变树中某些结点的颜色以及指针结构来保持对红黑树进行插入和删除操作后的红黑性质。
左旋：对某个结点x做左旋操作时，假设其右孩子为y而不是T.nil：以x到y的链为“支轴”进行。使y成为该子树新的根结点，x成为y的左孩子，y的左孩子成为x的右孩子。
右旋：对某个结点x做右旋操作时，假设其左孩子为y而不是T.nil：以x到y的链为“支轴”进行。使y成为该子树新的根结点，x成为y的右孩子，y的右孩子成为x的左孩子。
8、请你分别用递归和迭代实现二叉树的三种遍历以及层次遍历
1、先序遍历的实现
(1)、递归
import java.util.Stack;
public class Test
{
public static void main(String[] args)
{
TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
for(int i = 0; i < 10; i++)
{
node[i] = new TreeNode(i);
}
for(int i = 0; i < 10; i++)
{
if(i*2+1 < 10)
node[i].left = node[i*2+1];
if(i*2+2 < 10)
node[i].right = node[i*2+2];
}
preOrderRe(node[0]);
}
public static void preOrderRe(TreeNode biTree)
{
//递归实现
System.out.println(biTree.value);
TreeNode leftTree = biTree.left;
if(leftTree != null)
{
preOrderRe(leftTree);
}
TreeNode rightTree = biTree.right;
if(rightTree != null)
{
preOrderRe(rightTree);
}
}
}
class TreeNode//节点结构
{
int value;
TreeNode left;
TreeNode right;
TreeNode(int value)
{
this.value = value;
}
}
实现结果如下：
(2)、迭代
import java.util.Stack;
public class Test
{
public static void main(String[] args)
{
TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
for(int i = 0; i < 10; i++)
{
node[i] = new TreeNode(i);
}
for(int i = 0; i < 10; i++)
{
if(i*2+1 < 10)
node[i].left = node[i*2+1];
if(i*2+2 < 10)
node[i].right = node[i*2+2];
}
preOrder(node[0]);
}
public static void preOrder(TreeNode biTree)
{
//非递归实现
Stack<TreeNode> stack = new Stack<TreeNode>();
while(biTree != null || !stack.isEmpty())
{
while(biTree != null)
{
System.out.println(biTree.value);
stack.push(biTree);
biTree = biTree.left;
}
if(!stack.isEmpty())
{
biTree = stack.pop();
biTree = biTree.right;
}
}
}
}
class TreeNode//节点结构
{
int value;
TreeNode left;
TreeNode right;
TreeNode(int value)
{
this.value = value;
}
}
实现结果如下：
2、中序遍历
(1)、迭代
import java.util.Stack;
public class Test
{
public static void main(String[] args)
{
TreeNode[] node = new TreeNode[10];
for(int i = 0; i < 10; i++)
{
node[i] = new TreeNode(i);
}
for(int i = 0; i < 10; i++)
{
if(i*2+1 < 10)
node[i].left = node[i*2+1];
if(i*2+2 < 10)
node[i].right = node[i*2+2];
}
midOrder(node[0]);
System.out.println();
}
public static void midOrder(TreeNode biTree)
{
Stack<TreeNode> stack = new Stack<TreeNode>();
while(biTree != null || !stack.isEmpty())
{
while(biTree != null)
{
stack.push(biTree);
biTree = biTree.left;
}
if(!stack.isEmpty())
{
biTree = stack.pop();
System.out.println(biTree.value);
biTree = biTree.right;
}
}
}
}
class TreeNode//节点结构
{
int value;
TreeNode left;
TreeNode right;
TreeNode(int value)
{
this.value = value;
}
}
实现结果如下：
(2)、递归
import java.util.Stack;
public class Test
{
public static void main(String[] args)
{
TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
for(int i = 0; i < 10; i++)
{
node[i] = new TreeNode(i);
}
for(int i = 0; i < 10; i++)
{
if(i*2+1 < 10)
node[i].left = node[i*2+1];
if(i*2+2 < 10)
node[i].right = node[i*2+2];
}
midOrderRe(node[0]);
System.out.println();
}
public static void midOrderRe(TreeNode biTree)
{
//中序遍历递归实现
if(biTree == null)
return;
else
{
midOrderRe(biTree.left);
System.out.println(biTree.value);
midOrderRe(biTree.right);
}
}
}
class TreeNode//节点结构
{
int value;
TreeNode left;
TreeNode right;
TreeNode(int value)
{
this.value = value;
}
}
实现结果如下：
3、后序遍历
(1)、迭代
import java.util.Stack;
public class Test
{
public static void main(String[] args)
{
TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
for(int i = 0; i < 10; i++)
{
node[i] = new TreeNode(i);
}
for(int i = 0; i < 10; i++)
{
if(i*2+1 < 10)
node[i].left = node[i*2+1];
if(i*2+2 < 10)
node[i].right = node[i*2+2];
}
postOrder(node[0]);
}
public static void postOrder(TreeNode biTree)
{
//后序遍历非递归实现
int left = 1;//在辅助栈里表示左节点
int right = 2;//在辅助栈里表示右节点
Stack<TreeNode> stack = new Stack<TreeNode>();
Stack<Integer> stack2 = new Stack<Integer>();//辅助栈，用来判断子节点返回父节点时处于左节点还是右节点。
while(biTree != null || !stack.empty())
{
while(biTree != null)
{
//将节点压入栈1，并在栈2将节点标记为左节点
stack.push(biTree);
stack2.push(left);
biTree = biTree.left;
}
while(!stack.empty() && stack2.peek() == right)
{
//如果是从右子节点返回父节点，则任务完成，将两个栈的栈顶弹出
stack2.pop();
System.out.println(stack.pop().value);
}
if(!stack.empty() && stack2.peek() == left)
{
//如果是从左子节点返回父节点，则将标记改为右子节点
stack2.pop();
stack2.push(right);
biTree = stack.peek().right;
}
}
}
}
class TreeNode//节点结构
{
int value;
TreeNode left;
TreeNode right;
TreeNode(int value)
{
this.value = value;
}
}
实现结果如下：
(2)、递归
import java.util.Stack;
public class Test
{
public static void main(String[] args)
{
TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
for(int i = 0; i < 10; i++)
{
node[i] = new TreeNode(i);
}
for(int i = 0; i < 10; i++)
{
if(i*2+1 < 10)
node[i].left = node[i*2+1];
if(i*2+2 < 10)
node[i].right = node[i*2+2];
}
postOrderRe(node[0]);
}
public static void postOrderRe(TreeNode biTree)
{
//后序遍历递归实现
if(biTree == null)
return;
else
{
postOrderRe(biTree.left);
postOrderRe(biTree.right);
System.out.println(biTree.value);
}
}
}
class TreeNode//节点结构
{
int value;
TreeNode left;
TreeNode right;
TreeNode(int value)
{
this.value = value;
}
}
结果实现如下：
4、层次遍历
(1)、迭代
import java.util.LinkedList;
import java.util.Stack;
public class Test
{
public static void main(String[] args)
{
TreeNode[] node = new TreeNode[10];//以数组形式生成一棵完全二叉树
for(int i = 0; i < 10; i++)
{
node[i] = new TreeNode(i);
}
for(int i = 0; i < 10; i++)
{
if(i*2+1 < 10)
node[i].left = node[i*2+1];
if(i*2+2 < 10)
node[i].right = node[i*2+2];
}
levelOrder(node[0]);
}
public static void levelOrder(TreeNode biTree)
{
//层次遍历
if(biTree == null)
return;
LinkedList<TreeNode> list = new LinkedList<TreeNode>();
list.add(biTree);
TreeNode currentNode;
while(!list.isEmpty())
{
currentNode = list.poll();
System.out.println(currentNode.value);
if(currentNode.left != null)
list.add(currentNode.left);
if(currentNode.right != null)
list.add(currentNode.right);
}
}
}
class TreeNode//节点结构
{
int value;
TreeNode left;
TreeNode right;
TreeNode(int value)
{
this.value = value;
}
}
结果实现如下：
接下来我们用python实现上面四种遍历，为了篇幅，为了简便，我们可以写在一个程序里。实现如下：
class NodeTree:
def __init__(self, root=None, lchild=None, rchild=None):
self.root = root
self.lchild = lchild
self.rchild = rchild
class BinTree:
# -----------前序遍历 ------------
# 递归算法
def pre_order_recursive(self, T):
if T == None:
return
print(T.root, end=' ')
self.pre_order_recursive(T.lchild)
self.pre_order_recursive(T.rchild)
# 非递归算法
def pre_order_non_recursive(self, T):
"""借助栈实现前驱遍历
"""
if T == None:
return
stack = []
while T or len(stack) > 0:
if T:
stack.append(T)
print(T.root, end=' ')
T = T.lchild
else:
T = stack[-1]
stack.pop()
T = T.rchild
# -----------中序遍历 ------------
# 递归算法
def mid_order_recursive(self, T):
if T == None:
return
self.mid_order_recursive(T.lchild)
print(T.root, end=' ')
self.mid_order_recursive(T.rchild)
# 非递归算法
def mid_order_non_recursive(self, T):
"""借助栈实现中序遍历
"""
if T == None:
return
stack = []
while T or len(stack) > 0:
if T:
stack.append(T)
T = T.lchild
else:
T = stack.pop()
print(T.root, end=' ')
T = T.rchild
# -----------后序遍历 ------------
# 递归算法
def post_order_recursive(self, T):
if T == None:
return
self.post_order_recursive(T.lchild)
self.post_order_recursive(T.rchild)
print(T.root, end=' ')
# 非递归算法
def post_order_non_recursive(self, T):
"""借助两个栈实现后序遍历
"""
if T == None:
return
stack1 = []
stack2 = []
stack1.append(T)
while stack1:
node = stack1.pop()
if node.lchild:
stack1.append(node.lchild)
if node.rchild:
stack1.append(node.rchild)
stack2.append(node)
while stack2:
print(stack2.pop().root, end=' ')
return
# -----------层次遍历 ------------
def level_order(self, T):
"""借助队列（其实还是一个栈）实现层次遍历
"""
if T == None:
return
stack = []
stack.append(T)
while stack:
node = stack.pop(0) # 实现先进先出
print(node.root, end=' ')
if node.lchild:
stack.append(node.lchild)
if node.rchild:
stack.append(node.rchild)
# ----------- 前序遍历序列、中序遍历序列 —> 重构二叉树 ------------
def tree_by_pre_mid(self, pre, mid):
if len(pre) != len(mid) or len(pre) == 0 or len(mid) == 0:
return
T = NodeTree(pre[0])
index = mid.index(pre[0])
T.lchild = self.tree_by_pre_mid(pre[1:index + 1], mid[:index])
T.rchild = self.tree_by_pre_mid(pre[index + 1:], mid[index + 1:])
return T
# ----------- 后序遍历序列、中序遍历序列 —> 重构二叉树 ------------
def tree_by_post_mid(self, post, mid):
if len(post) != len(mid) or len(post) == 0 or len(mid) == 0:
return
T = NodeTree(post[-1])
index = mid.index(post[-1])
T.lchild = self.tree_by_post_mid(post[:index], mid[:index])
T.rchild = self.tree_by_post_mid(post[index:-1], mid[index + 1:])
return T
if __name__ == '__main__':
# ----------- 测试：前序、中序、后序、层次遍历 -----------
# 创建二叉树
nodeTree = NodeTree(1,
lchild=NodeTree(2,
lchild=NodeTree(4,
rchild=NodeTree(7))),
rchild=NodeTree(3,
lchild=NodeTree(5),
rchild=NodeTree(6)))
T = BinTree()
print('前序遍历递归\t')
T.pre_order_recursive(nodeTree) # 前序遍历-递归
print('\n')
print('前序遍历非递归\t')
T.pre_order_non_recursive(nodeTree) # 前序遍历-非递归
print('\n')
print('中序遍历递归\t')
T.mid_order_recursive(nodeTree) # 中序遍历-递归
print('\n')
print('中序遍历非递归\t')
T.mid_order_non_recursive(nodeTree) # 中序遍历-非递归
print('\n')
print('后序遍历递归\t')
T.post_order_recursive(nodeTree) # 后序遍历-递归
print('\n')
print('后序遍历非递归\t')
T.post_order_non_recursive(nodeTree) # 后序遍历-非递归
print('\n')
print('层次遍历\t')
T.level_order(nodeTree) # 层次遍历
print('\n')
print('==========================================================================')
# ----------- 测试：由遍历序列构造二叉树 -----------
T = BinTree()
pre = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']
mid = ['B', 'C', 'A', 'E', 'D', 'G', 'H', 'F', 'I']
post = ['C', 'B', 'E', 'H', 'G', 'I', 'F', 'D', 'A']
newT_pre_mid = T.tree_by_pre_mid(pre, mid) # 由前序序列、中序序列构造二叉树
T.post_order_recursive(newT_pre_mid) # 获取后序序列
print('\n')
newT_post_mid = T.tree_by_post_mid(post, mid) # 由后序序列、中序序列构造二叉树
T.pre_order_recursive(newT_post_mid) # 获取前序序列
9、TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort()方法如何比较元素？
TreeSet要求存放的对象所属的类必须实现Comparable接口，该接口提供了比较元素的compareTo()方法，当插入元素时会回调该方法比较元素的大小。TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。Collections工具类的sort方法有两种重载的形式，第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比较；第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator接口的子类型（需要重写compare方法实现元素的比较），相当于一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法，也是对回调模式的应用（Java中对函数式编程的支持）。
10、 B树的特性，B树和B+树的区别
- 一个m 阶的B树满足以下条件：
1、每个结点至多拥有m棵子树；
2、根结点至少拥有两颗子树（存在子树的情况下）；
3、除了根结点以外，其余每个分支结点至少拥有m/2 棵子树；
4、所有的叶结点都在同一层上；
5、有k 棵子树的分支结点则存在 k-1 个关键码，关键码按照递增次序进行排列；
6、关键字数量需要满足ceil(m/2)-1 <= n <= m-1；- B树和B+树的区别：
以一个m阶树为例。
1、关键字的数量不同；B+树中分支结点有m个关键字，其叶子结点也有m个，其关键字只是起到了一个索引的作用，但是B树虽然也有m个子结点，但是其只拥有m-1个关键字。
2、存储的位置不同；B+树中的数据都存储在叶子结点上，也就是其所有叶子结点的数据组合起来就是完整的数据，但是B树的数据存储在每一个结点中，并不仅仅存储在叶子结点上。
3、分支结点的构造不同；B+树的分支结点仅仅存储着关键字信息和儿子的指针（这里的指针指的是磁盘块的偏移量），也就是说内部结点仅仅包含着索引信息。
4、查询不同；B树在找到具体的数值以后，则结束，而B+树则需要通过索引找到叶子结点中的数据才结束，也就是说B+树的搜索过程中走了一条从根结点到叶子结点的路径。
11、请你说一下BST的特点
1、每个结点都有一个作为搜索依据的关键码，所有结点的关键码不同
2、左子树上所有结点的关键码小于根节点的关键码
3、右子树所有结点的关键码大于根节点的关键码
4、左子树和右子树也是BST
总结
由于数据结构面试的内容较多，因此本文以及接下来的两篇文章的对面试中常见的数据结构问题进行了简单的总结，一方面是为了方便自己以后面试的复习，另外也是给大家再次面试相关岗位的时候提供复习方向以及思路解答。这里就需要我们对操作系统有一个较为深层次的理解。于是，我们在准备的时候，首先就应该夯实基础，只有这样才能在众多的面试者中脱颖而出。另外，作为在计算机行业工作的从事者，掌握数据结构与算法知识是很有必要的，也是我们的基本素养。最后希望大家不断进步，都能尽早拿到自己比较满意的offer！！！！继续加油，未来可期！！！！