用java把二叉树界面_用Java实现一个二叉树

介绍

使用Java实现一个int值类型的排序二叉树

二叉树

二叉树是一个递归的数据结构，每个节点最多有两个子节点。

通常二叉树是二分查找树，每个节点它的值大于或者等于在它左子树节点上的值，小于或者等于在它右子树节点上的值，如下图

为了实现二叉树，我们使用一个Node类来表示节点，节点存储int类型的值，还有对子节点的引用。

package com.java.node.BinaryTree;

public class Node {

int data;

Node left;

Node right;

public Node(int data) {

this.data = data;

this.left = null;

this.right = null;

}

}

然后添加树的root节点

package com.java.node.BinaryTree;

public class BinaryTree {

Node root;

}

通常的操作

添加节点

首先我们必须找到新节点的位置，是为了保持树排序。我们必须从root节点开始，必须遵循下面的规则：

如果新节点小于当前的值，我们将会进入左子树

如果新节点大于当前的节点。我们将会进入右子树

当当前的节点是null时，我们已经到达叶子节点，我们可以添加新节点到这个位置。

我们将会创建递归方法做添加节点操作

private Node addNode(Node current, int value) {

if (current == null) {

return new Node(value);

}

if (value < current.data) {

current.left = addNode(current.left, value);

} else if (value > current.data) {

current.right = addNode(current.right, value);

} else {

return current;

}

return current;

}

public void addNode(int value) {

root = addNode(root, value);

}

可以使用方法创建一个二叉树了

public BinaryTree createBinaryTree() {

BinaryTree bt = new BinaryTree();

bt.addNode(6);

bt.addNode(4);

bt.addNode(8);

bt.addNode(10);

return bt;

}

查找一个节点

private boolean containNode(Node current, int value) {

if (current == null) {

return false;

}

if (value == current.data) {

return true;

}

return value < current.data ? containNode(current.left, value) : containNode(current.right, value);

}

public boolean containNode(int value) {

return containNode(root, value);

}

删除一个节点

private Node deleteNode(Node current, int value) {

if (current == null) {

return null;

}

if (value == current.data) {

if (current.left == null && current.right == null) {

return null;

}

if (current.left == null) {

return current.right;

}

if (current.right == null) {

return current.left;

}

int smallestValue = findSmallestValue(current.right);

current.data = smallestValue;

current.right = deleteNode(current.right, smallestValue);

return current;

}

if (value < current.data) {

current.left = deleteNode(current.left, value);

return current;

}

current.right = deleteNode(current.right, value);

return current;

}

private int findSmallestValue(Node root) {

return root.left == null ? root.data : findSmallestValue(root.right);

}

遍历树

我们将以不同的方式遍历树，以depth-first，breadth-first方式遍历树。

以Depth-First遍历树

Depth-first查询是一种在查询兄弟节点之前，尽可能的查询每个子节点。

in-order，pre-order，post-order方式都是以depth-first方式遍历树的。

in-order遍历是首先遍历左子树，然后root节点，最后是右子树。

public void traverseInOrder(Node root) {

if (root != null) {

traverseInOrder(root.left);

System.out.println(root.data);

traverseInOrder(root.right);

}

}

pre-order遍历首先是root节点，然后是左子树，最后是右子树。

public void traversePreOrder(Node root) {

if (root != null) {

System.out.println(root.data);

traversePreOrder(root.left);

traversePreOrder(root.right);

}

}

post-order遍历首先是遍历左子树，然后是右子树，最后是root节点。

public void traversePostOrder(Node root) {

if (root != null) {

traversePostOrder(root.left);

traversePostOrder(root.right);

System.out.println(root.data);

}

}

以Breadth-First遍历

它在遍历下一级的节点之前，会遍历当前级的所有节点。

这种类型的遍历也叫做level-order，遍历树从root节点开始，从左到右。

为了实现，使用队列来存储每个级别的节点。我们将会从列表中获取每个节点。然后添加他的子节点到队列中。

public void traverseLevelOrder(Node root) {

if (root == null) {

return;

}

Queue nodes = new LinkedList();

nodes.add(root);

while(!nodes.isEmpty()) {

Node node = nodes.remove();

System.out.println(node.data);

if (node.left != null) {

nodes.add(node.left);

}

if (node.right != null) {

nodes.add(node.right);

}

}

}