Android实习面试准备——数据结构与算法（四）

1、已知前序遍历为{1,2,4,7,3,5,6,8}，中序遍历为{4,7,2,1,5,3,8,6}，它的二叉树是怎么样的

        前序遍历是中、左、右，中序遍历是左、中、右，那么前序遍历里的队列第一个一定是中，也就是1，然后在中序遍历队列中找到1，1左边的就是左子树，右边的就是右子树，然后继续这个逻辑进行递归，就能构建出一颗二叉树。（可以看leetcode 105）

public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length == 0 || inorder.length == 0) return null;
        return traversal(preorder, 0, preorder.length, inorder, 0, inorder.length);
    }
    public TreeNode traversal(int[] preorder, int preorderBegin, int preorderEnd, int[] inorder, int inorderBegin, int inorderEnd) {
        if(preorderBegin == preorderEnd) return null;
        int rootValue = preorder[preorderBegin];
        TreeNode root = new TreeNode(rootValue);
        if(preorderEnd - preorderBegin == 1) return root;
        int delimiterIndex = 0;
        for(delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if(inorder[delimiterIndex] == rootValue) break;
        }
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;
        int leftPreorderBegin = preorderBegin + 1;
        int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin;
        int rightPreorderBegin = preorderBegin + 1 + delimiterIndex - inorderBegin;
        int rightPreorderEnd = preorderEnd;
        root.left = traversal(preorder, leftPreorderBegin, leftPreorderEnd, inorder, leftInorderBegin, leftInorderEnd);
        root.right = traversal(preorder, rightPreorderBegin, rightPreorderEnd, inorder, rightInorderBegin, rightInorderEnd);
        return root;
    }

2、输入两棵二叉树 A 和 B，判断 B 是不是 A 的子结构

        这题可以看剑指offer 26，在leetcode上也可以搜剑指 26。

public boolean isSubStructure(TreeNode A, TreeNode B) {
        boolean result = false;
        if(A != null && B != null) {
            if(A.val == B.val)
                result = doesTreeAHasTreeB(A, B);
            if(!result)
                result = isSubStructure(A.left, B);
            if(!result)
                result = isSubStructure(A.right, B);
        }
        return result;
    }

    public boolean doesTreeAHasTreeB(TreeNode A, TreeNode B) {
        if(B == null)
            return true;
        if(A == null)
            return false;
        if(A.val != B.val) 
            return false;
        return doesTreeAHasTreeB(A.left, B.left) && doesTreeAHasTreeB(A.right, B.right);
    }

3、请实现两个函数，分别用来序列化二叉树和反序列化二叉树

        这题在剑指offer 37，leetcode 297。

 public String serialize(TreeNode root) {
        if(root == null) return ""; 
        StringBuilder sb = new StringBuilder();
        doSerialize(root, sb);
        return sb.toString();
    }

    public void doSerialize(TreeNode root, StringBuilder sb) {
        if(root == null) {
            sb.append("null,");
            return;
        } else {
            sb.append(root.val).append(",");
            doSerialize(root.left, sb);
            doSerialize(root.right, sb);
        }
    }


    public TreeNode deserialize(String data) {
        if(data == null || data.isEmpty())
            return null;
        String[] strArray = data.split(",");
        List<String> dataList = new LinkedList<>(Arrays.asList(strArray));
        return doDeserialize(dataList);
    }

    public TreeNode doDeserialize(List<String> dataList) {
        String str = dataList.get(0);
        if(str.equals("null")) {
            dataList.remove(0);
            return null;
        }
        TreeNode root = new TreeNode(Integer.parseInt(str));
        dataList.remove(0);
        root.left = doDeserialize(dataList);
        root.right = doDeserialize(dataList);
        return root;
    }

4、平衡二叉树和红黑树的区别

        平衡二叉树是带有平衡条件的搜索二叉树，平衡二叉树需要满足以下规则：

        （1）每个节点最多只有两个子节点

        （2）每个节点的值都比她左子节点的值要大，比右子节点的值要小

        （3）每个节点左子树和右子树的高度差的绝对值不大于1

        一旦平衡二叉树失去了平衡，则会通过旋转来实现平衡，包括以下几种情况和解决方法：

        （1）左左：右旋

        （2）左右：先左旋，载右旋

        （3）右右：左旋

        （4）右左：先右旋，再左旋

        由于平衡条件必须满足左子树和右子树的高度差的绝对值不大于1，当执行插入和删除操作时，只要不满足上述条件，就会进行旋转来保持平衡，而旋转是非常耗时的，因此平衡二叉树适合进行查找多，添加删除操作少的场景。

        红黑树也是一种二叉搜索树，在每个节点上增加一个存储位表示结点的颜色，可以是红或黑。红黑树需要满足五个规则：

        （1）每个节点不是黑色就是红色

        （2）根节点为黑色

        （3）每个叶结点都是黑色

        （4）如果一个结点是红色，那么其两个子节点都是黑色

        （5）每个结点到叶结点的每个路径黑色结点的个数都相等

        红黑树在不满足上述条件的时候，会通过变色或旋转来维持这些规则。

        红黑树和二叉平衡树的区别：平衡二叉树的左子树和右子树的高度差的绝对值不大于1，但是红黑树没有这么严格，在有些时候可以超过1，只要满足上述五个条件就可以。平衡二叉树只要不满足平衡就会进行旋转，而红黑树在不满足规则时，有些情况下通过变色就可以解决，不需要通过旋转，所以比起二叉搜索树，更适合在添加删除操作多、查找少的场景下。

5、什么是平衡二叉树，它有什么特征

        二叉平衡树是带有平衡条件的二叉搜索树，二叉搜索树首先是一颗二叉树，需要满足：结点的子节点不超过2个这个条件，二叉搜索树还需要满足的一点是：每个节点的值大于其左子节点的值，小于其右子节点的值。二叉平衡树的平衡条件是：左子树和右子树的高度差的绝对值不大于1。当进行添加或删除操作时，有可能会违反这个规则，所以需要通过旋转来重新实现平衡，而旋转耗时间，所以二叉平衡树并不适合添加删除操作多的场景。

6、B 树，B+树

        此处参考B-树详细分析及B树B-树B+树B*树概念_guanyasu的博客-CSDN博客_b+树

B-树是一种平衡的多路搜索树，一颗m阶的B-树满足如下性质：

        （1）树中每个非叶子节点最多有m个孩子（m>=2）

        （2）根节点的孩子数为[2,m]（根节点不是叶子结点）

        （2）除根节点外的非叶子结点的孩子数为[ceil(m/2),m]，ceil是指向上取整

        （3）所以非叶子结点的关键字数量=指向孩子的指针数量-1，关键字的个数的取值范围为 [ceil(m / 2)-1]<= n <= m-1，且关键字按升序排序。

        （4）对于非叶子结点，指向孩子的指针用P[1], P[2], …, P[M]表示，关键字用K[1], K[2], …, K[M-1]表示，其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树

        （5）所以叶子结点出现在同一层

        对于B-数的搜索，从根节点开始，对节点内的关键字进行二分查找，如果命中就结束，否则进入到查询关键字所在范围的孩子结点中；重复，直到对应的儿子指针为空，或已经是叶子结点。

        根据以上搜索的流程可以看出来，B-数的关键字分布在整颗树中，搜索有可能在非叶子结点上就结束了。

B+树是应文件系统所需而出的一种B-树的变型树，一颗m阶的B+树和m阶的B_树的差异在于：

        （1）有n棵子树的结点中含有n个关键字(而B-树是n棵子树有n-1个关键字)

        （2）所有的叶子结点中包含了全部关键字的信息，及指向含这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大顺序链接

        （3）所有的非叶子结点可以看成是索引部分，结点中仅含有其子树根结点中最大（或最小）关键字，也就是指向关键字值属于[K[i], K[i+1])的子树 (而B 树的非叶子节点也包含需要查找的有效信息)

        （4）为所有叶子结点增加一个链指针

        也就是说，B+树的搜索只可能在叶子结点结束，不可能在非叶子结点命中，因为其非叶子结点只是作为索引，那么对于相同的结点空间，B＋树可以设计的阶树比B-树大，相同的索引，B＋树的索引层数比B-树少，因此检索速度比B-树快。此外，B＋树叶子结点包含完整的索引信息，可以较方便地表示文件的稀疏索引。最后，B＋树的检索、插入和删除都在叶子结点进行，比B-树相对简单。