阿里第二轮面试：手写Java二叉树

阿里面试

如今不少公司在招聘开发岗位的时候，都会事先在招聘信息中注明面试者应当具有的知识技能，并且在面试的过程当中，有部分对于技能掌握程度有严格要求的公司还会要求面试者手写代码，这个环节很考验面试者的基础功底和实力！

这不，前些天一个朋友去阿里面试的时候，在二面过程当中就被要求使用Java实现二叉树，王二Dog因为没有准备这方面的知识，没有答上来，而后就让回家等通知了。

因此有利用给王二Dog讲解二叉树的机会，我总体梳理了下二叉树常见的面试点，发出来供你们一块儿交流学习。但愿对你的面试有所帮助。

二叉树

二叉树是递归数据结构，其中每一个节点最多能够有2个子节点。

常见类型的二叉树是二叉搜索树，其中每一个节点的值大于或等于左子节点值，而且小于或等于右子节点中的节点值。

这是这种二叉树的直观表示：

对于实现，咱们将使用 Node 类来存储 int 值并保存对每一个子节点的引用：

class Node {
    int value;//本节点的值
    Node left;//左边的子节点
    Node right;//右边的子节点

    Node(int value) {
        this.  value = value;
        right = null;
        left = null;
    }
}

而后，让咱们添加树的根节点，一般称为 根：

public class BinaryTree {
    Node root;
    // ...}

让咱们一块儿来实现下

如今，让咱们看看能够在二叉树上执行的最多见操做有哪些？

插入元素

咱们要介绍的第一个操做是插入新节点。

首先，咱们必须找到咱们想要添加新节点的位置，以便对树进行排序。咱们将从根节点开始遵循这些规则：

• 若是新节点的值低于当前节点的值，咱们转到左子节点
• 若是新节点的值大于当前节点的值，咱们将转到右子节点
• 节点当前为null时，咱们已到达叶节点，咱们能够在该位置插入新节点

首先，咱们将建立一个递归方法来进行插入：

private Node addRecursive(Node current, int value) {
    if (current == null) {
        return new Node(value);
    }
    if (value < current.value) {
        current.left = addRecursive(current.left, value);
    } else if (value > current.value) {
        current.right = addRecursive(current.right, value);
    } else {
        // value already exists
        return current;    
    }    
    return current;
}

接下来，咱们将建立一个递归方法来建立根节点：

public void add(int value) {
    root = addRecursive(root, value);
}

如今让咱们看看如何使用此方法从咱们的示例中建立树：

private BinaryTree createBinaryTree() {
    BinaryTree bt = new BinaryTree();

    bt.add(6);
    bt.add(4);
    bt.add(8);
    bt.add(3);
    bt.add(5);
    bt.add(7);
    bt.add(9);

    return bt;
}

查找元素

如今让咱们添加一个方法来检查树是否包含特定值。

和之前同样，咱们首先建立一个遍历树的递归方法：

private boolean containsNodeRecursive(Node current, int value) {
    if (current == null) {
        return false;
    }
    if (value == current.value) {
        return true;
    }
    return value < current.value
      ? containsNodeRecursive(current.left, value)
      : containsNodeRecursive(current.right, value);
}

在这里，咱们经过将其与当前节点中的值进行比较来搜索该值，而后根据该值继续在左或右子节点中继续查找。

接下来，咱们让建立一个公共方法来查找：

public boolean containsNode(int value) {
    return containsNodeRecursive(root, value);
}

如今，让咱们建立一个简单的测试来验证树真的包含插入的元素：

@Test
public void givenABinaryTree_WhenAddingElements_ThenTreeContainsThoseElements() {
    BinaryTree bt = createBinaryTree();

    assertTrue(bt.containsNode(6));
    assertTrue(bt.containsNode(4));
    assertFalse(bt.containsNode(1));
}

删除元素

另外一种常见操做是从树中删除节点。

首先，咱们必须以与以前相似的方式找到要删除的节点：

private Node deleteRecursive(Node current, int value) {
    if (current == null) {
        return null;
    }
    if (value == current.value) {
        // Node to delete found
        // ... code to delete the node will go here
    }
    if (value < current.value) {
        current.left = deleteRecursive(current.left, value);
        return current;
    }
    current.right = deleteRecursive(current.right, value);
    return current;
}

一旦咱们找到要删除的节点，就有3种主要的不一样状况：

• 节点没有子节点 -这是最简单的状况; 咱们只须要在其父节点中用 null 替换此节点
• 节点只有一个子节点 -在父节点中，咱们用它惟一的子节点替换该节点。
• 节点有两个子节点 - 这是最复杂的状况，由于它须要树重组

让咱们看看当节点是叶节点时咱们如何实现第一种状况：

if (current.left == null && current.right == null) {
    return null;
}

如今让咱们继续讨论节点有一个子节点的状况：

if (current.right == null) {
    return current.left;
}
if (current.left == null) {
    return current.right;
}

在这里，咱们返回 非null 子节点，以便将其分配给父节点。

最后，咱们必须处理节点有两个子节点的状况。

首先，咱们须要找到将替换已删除节点的节点。咱们将使用节点的最小节点删除右侧子树：

private int findSmallestValue(Node root) {
    return root.left == null ? root.value : findSmallestValue(root.left);
}

而后，咱们将最小值分配给要删除的节点，以后，咱们将从右侧子树中删除它：

int smallestValue = findSmallestValue(current.right);
current.value = smallestValue;
current.right = deleteRecursive(current.right, smallestValue);
return current;

最后，咱们让建立删除的公共方法：

public void delete(int value) {
    root = deleteRecursive(root, value);
}

如今，让咱们检查删除是否按预期工做：

@Test
public void givenABinaryTree  () {
    BinaryTree bt = createBinaryTree();

    assertTrue(bt.containsNode(9));
    bt.delete(9);
    assertFalse(bt.containsNode(9));
}

转换树

在此，咱们将看到遍历树的不一样方式，详细介绍深度优先和广度优先搜索。

咱们将使用以前使用的相同树，而且咱们将显示每一个案例的遍历顺序。

深度优先搜索

深度优先搜索是一种在每一个子节点探索下一个兄弟以前尽量深刻的遍历。

有几种方法能够执行深度优先搜索：in-order, pre-order 和 post-order。

in-order：首先访问左子树，而后访问根节点，最后访问右子树：

public void traverseInOrder(Node node) {
    if (node != null) {
        traverseInOrder(node.left);
        System.out.print(" " + node.value);
        traverseInOrder(node.right);
    }
}

若是咱们调用此方法，控制台输出：

3 4 5 6 7 8 9

pre-order：首先访问根节点，而后是左子树，最后是右子树：

public void traversePreOrder(Node node) {
    if (node != null) {
        System.out.print(" " + node.value);
        traversePreOrder(node.left);
        traversePreOrder(node.right);
    }
}

若是咱们调用此方法，控制台输出：

6 4 3 5 8 7 9

post-order：访问左子树，右子树，最后访问根节点：

public void traversePostOrder(Node node) {
    if (node != null) {
        traversePostOrder(node.left);
        traversePostOrder(node.right);
        System.out.print(" " + node.value);
    }
}

若是咱们调用此方法，控制台输出：

3 5 4 7 9 8 6

广度优先搜索

这是另外一种常见的遍历类型，它在展现进入下一级别以前访问级别的全部节点。

这种遍历也称为按级别顺序，并从根开始，从左到右访问树的全部级别。

对于实现，将咱们使用 队列 按顺序保存每一个级别的节点。咱们将从列表中提取每一个节点，打印其值，而后将其子节点添加到队列中：

public void traverseLevelOrder() {
    if (root == null) {
        return;
    }
    Queue<Node> nodes = new LinkedList<>();
    nodes.add(root);
    while (!nodes.isEmpty()) {
        Node node = nodes.remove();
        System.out.print(" " + node.value);
        if (node.left != null) {
            nodes.add(node.left);
        }
        if (node.right!= null) {
            nodes.add(node.right);
        }
    }
}

在这种状况下，节点的顺序将是：

6 4 8 3 5 7 9

最后

在本文中，咱们已经了解了如何在Java中实现已排序的二叉树及其最多见的操做。你是否从中有所收获呢？哪怕你能收获一点点心得，我在此也欣慰了！

“不积跬步，无以致千里”，但愿将来的你能成为：有梦为马 随处可栖！加油，少年！