用java语言实现一个二叉树

最新推荐文章于 2024-04-20 01:51:27 发布

wangdepei

最新推荐文章于 2024-04-20 01:51:27 发布

阅读量1.2k

点赞数 2

分类专栏： java 文章标签： 1.8 二叉树

本文链接：https://blog.csdn.net/wangdepei/article/details/79895515

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

学习自： http://www.baeldung.com/java-binary-tree (可能需要梯子)

我是数据结构的初学者，最近又刚好有时间，就学习了一下用java语言实现二叉树的方法，写出来，留作记录并分享给大家。

先定义这个二叉树的几个基础功能：

1.插入新节点。由于二叉树是有序的，在增加节点时，需要根据一定的规则去插入新的节点。

2.查找元素。查找一个元素是否在这个二叉树中。

3.删除元素。查找某一个值所在的节点，然后删除这个节点的值，并用该节点下右子树中最小的值赋给这个节点。

4.遍历二叉树。包括先序遍历，中序遍历，后序遍历以及层序遍历。

现在开始逐一实现这个功能。

一、先做一些初始化工作

首先要有一个结构来表示二叉树的节点

class Node<E> {
    E value;
    Node<E> leftChild;
    Node<E> rightChild;

    Node(E value) {
        this.value = value;
        leftChild = null;
        rightChild = null;
    }

    @Override
    public String toString() {
        return value.toString();
    }
}

然后添加根节点，由于二叉树是有序的，所以要有一个排序器为树中的节点做比较

public final class BinaryTree<E> {
    private final Comparator<? super E> c;
    private Node<E> root;
}

以及一个必要的构建器

为什么要有这么一个构建器，当时的想法已经未可知了，总之能返回一个新的BinaryTree对象就行，当然，比较器不能为空。

//构建器
    public static class Builder<E> {
        private final Comparator<? super E> c;
        private Queue<E> values = new LinkedList<>();

        public Builder(Comparator<? super E> c) {
            this.c = c;
        }

        public Builder add(E value) {
            values.offer(value);
            return this;
        }

        public Builder add(E[] values) {
            for (E value : values) {
                this.values.offer(value);
            }
            return this;
        }

        public Builder addAll(List<? extends E> values) {
            for (E value : values) {
                this.values.offer(value);
            }
            return this;
        }

        public BinaryTree<E> build() {
            BinaryTree<E> binaryTree = new BinaryTree<>(c);
            while (!values.isEmpty()) {
                binaryTree.add(values.poll());
            }
            return binaryTree;
        }

    }

二、插入新节点

插入新节点从根节点开始。

由于二叉树是有序的，所以插入新节点有几条规则需要遵守：

1.如果新节点的值小于当前节点的值，则新节点与当前节点的左子节点进行比较。

2.如果新节点的值大于当前节点的值，则新节点与当前节点的右子节点进行比较。

3.如果当前节点为空，那说明到达叶子节点，则该位置即为新节点的位置。

首先创建一个递归方法来实现插入节点：

private Node<E> addRecursive(Node<E> current, E value) {
        if (current == null) {
            return new Node<>(value);
        }
        int compare = Objects.compare(value, current.value, c);
        if (compare < 0) {
            current.leftChild = addRecursive(current.leftChild, value);
        } else if (compare > 0) {
            current.rightChild = addRecursive(current.rightChild, value);
        } else {
            return current;
        }
        return current;
    }

然后提供一个公有的，从根节点开始的插入方法

新节点的值不能为空，否则在比较的时候，会抛出空指针异常。

public void add(E value) {
        Objects.requireNonNull(value, "Parameter: value cannot be null.");
        root = addRecursive(root, value);
    }

三、查找元素

判断一个值是否在这个树结构中，返回值为布尔型

依旧是使用递归方法来遍历这个二叉树，来查找元素：

private boolean containNodeRecursive(Node<E> current, E value) {
        if (current == null) {
            return false;
        }
        if (value == null) {
            return current.value == null;
        }
        if (value.equals(current.value)) {
            return true;
        }
        int compare = Objects.compare(value, current.value, c);
        return compare < 0
                ? containNodeRecursive(current.leftChild, value)
                : containNodeRecursive(current.rightChild, value);
    }

提供一个公有的查找方法，由于插入元素时不允许插入空元素，那么空元素自然不会出现在二叉树中，对于空元素，直接返回false即可：

public boolean contains(E value) {
        if (value == null) {
            return false;
        }
        return containNodeRecursive(root, value);
    }

四、删除元素

这是一个大麻烦，情况多，而且逻辑难以理解，很惭愧，本人理解这段代码用了很长时间。

要删除某个节点（元素），首先要找到它，一旦找到了这个节点，就有三种可能出现的情况，需要逐个解决：

1.该节点没有子节点，这个情况最简单，只需将该节点设置为null即可

2.该节点只有一个子节点，这个情况也很简单，只需将它唯一的子节点挪到这个节点位置上即可。

3.该节点的子节点多于一个，这个情况最复杂，需要将该节点右子树的最小值的节点挪到这个节点的位置。

代码如下，依旧用递归方法实现：

private Node<E> removeRecursive(Node<E> current, E value) {
        if (current == null) {
            return null;
        }
        int compare = Objects.compare(value, current.value, c);
        if (compare == 0) {
            if (current.leftChild == null && current.rightChild == null) {
                return null;
            }
            if (current.leftChild == null) {
                return current.rightChild;
            }
            if (current.rightChild == null) {
                return current.leftChild;
            }
            //找到最小值，并将最小值赋值给要删除的值
            E smallestValue = findTheSmallestValue(current.rightChild);
            current.value = smallestValue;
            //删除那个最小值
            current.rightChild = removeRecursive(current.rightChild, smallestValue);
            return current;
        }
        if (compare < 0) {
            current.leftChild = removeRecursive(current.leftChild, value);
            return current;
        }
        current.rightChild = removeRecursive(current.rightChild, value);
        return current;
    }

其中寻找右子树最小值的方法

private E findTheSmallestValue(Node<E> current) {
        return current.leftChild == null ? current.value : findTheSmallestValue(current.leftChild);
    }

给外界提供的公有方法：

 public void remove(E value) {
        if (value == null) return;
        root = removeRecursive(root, value);
    }

五、遍历输出

//中序遍历，排序遍历，先左子树，再根节点，再右子树
    private void traverseInOrder(Node<E> node) {
        if (node != null) {
            traverseInOrder(node.leftChild);
            System.out.print(node.value + " ");
            traverseInOrder(node.rightChild);
        }
    }

    public void traverseInOrder() {
        traverseInOrder(root);
    }

    //先序遍历， 先根节点，再左子树，再右子树
    private void traversePreOrder(Node<E> node) {
        if (node != null) {
            System.out.println(node.value + " ");
            traversePreOrder(node.leftChild);
            traversePreOrder(node.rightChild);
        }
    }

    public void traversePreOrder() {
        traversePreOrder(root);
    }

    //后续遍历，先左子树，再右子树，再根节点
    private void traversePostOrder(Node<E> node) {
        if (node != null) {
            traversePostOrder(node.leftChild);
            traversePostOrder(node.rightChild);
            System.out.println(node.value + " ");
        }
    }

    public void traversePostOrder() {
        traversePostOrder(root);
    }

    //层序遍历
    public void traverseLevelOrder() {
        if (root == null) {
            return;
        }
        Queue<Node<E>> nodes = new LinkedList<>();
        nodes.offer(root);
        while (!nodes.isEmpty()) {
            Node<E> node = nodes.poll();
            if (node != null) {
                System.out.print(node.value + " ");
                if (node.leftChild != null) {
                    nodes.offer(node.leftChild);
                }

                if (node.rightChild != null) {
                    nodes.offer(node.rightChild);
                }
            }
        }
    }

至此，二叉树的结构以及基本常用方法已经完成。以下是源码：

Node.class

class Node<E> {
    E value;
    Node<E> leftChild;
    Node<E> rightChild;

    Node(E value) {
        this.value = value;
        leftChild = null;
        rightChild = null;
    }

    @Override
    public String toString() {
        return value.toString();
    }
}

BinaryTree.class

public final class BinaryTree<E> {
    private final Comparator<? super E> c;
    private Node<E> root;

    private BinaryTree(Comparator<? super E> c) {
        this.c = c;
    }

    private Node<E> addRecursive(Node<E> current, E value) {
        if (current == null) {
            return new Node<>(value);
        }
        int compare = Objects.compare(value, current.value, c);
        if (compare < 0) {
            current.leftChild = addRecursive(current.leftChild, value);
        } else if (compare > 0) {
            current.rightChild = addRecursive(current.rightChild, value);
        } else {
            return current;
        }
        return current;
    }

    public void add(E value) {
        Objects.requireNonNull(value, "Parameter: value cannot be null.");
        root = addRecursive(root, value);
    }

    private boolean containNodeRecursive(Node<E> current, E value) {
        if (current == null) {
            return false;
        }
        if (value == null) {
            return current.value == null;
        }
        if (value.equals(current.value)) {
            return true;
        }
        int compare = Objects.compare(value, current.value, c);
        return compare < 0
                ? containNodeRecursive(current.leftChild, value)
                : containNodeRecursive(current.rightChild, value);
    }

    public boolean contains(E value) {
        if (value == null) {
            return false;
        }
        return containNodeRecursive(root, value);
    }

    private Node<E> removeRecursive(Node<E> current, E value) {
        if (current == null) {
            return null;
        }
        int compare = Objects.compare(value, current.value, c);
        if (compare == 0) {
            if (current.leftChild == null && current.rightChild == null) {
                return null;
            }
            if (current.leftChild == null) {
                return current.rightChild;
            }
            if (current.rightChild == null) {
                return current.leftChild;
            }
            //找到最小值，并将最小值赋值给要删除的值
            E smallestValue = findTheSmallestValue(current.rightChild);
            current.value = smallestValue;

            //删除那个最小值
            current.rightChild = removeRecursive(current.rightChild, smallestValue);
            return current;
        }
        if (compare < 0) {
            current.leftChild = removeRecursive(current.leftChild, value);
            return current;
        }
        current.rightChild = removeRecursive(current.rightChild, value);
        return current;
    }

    public void remove(E value) {
        if (value == null) return;
        root = removeRecursive(root, value);
    }

    private E findTheSmallestValue(Node<E> current) {
        return current.leftChild == null ? current.value : findTheSmallestValue(current.leftChild);
    }

    //中序遍历，排序遍历，先左子树，再根节点，再右子树
    private void traverseInOrder(Node<E> node) {
        if (node != null) {
            traverseInOrder(node.leftChild);
            System.out.print(node.value + " ");
            traverseInOrder(node.rightChild);
        }
    }

    public void traverseInOrder() {
        traverseInOrder(root);
    }

    //先序遍历， 先根节点，再左子树，再右子树
    private void traversePreOrder(Node<E> node) {
        if (node != null) {
            System.out.println(node.value + " ");
            traversePreOrder(node.leftChild);
            traversePreOrder(node.rightChild);
        }
    }

    public void traversePreOrder() {
        traversePreOrder(root);
    }

    //后续遍历，先左子树，再右子树，再根节点
    private void traversePostOrder(Node<E> node) {
        if (node != null) {
            traversePostOrder(node.leftChild);
            traversePostOrder(node.rightChild);
            System.out.println(node.value + " ");
        }
    }

    public void traversePostOrder() {
        traversePostOrder(root);
    }

    //层序遍历
    public void traverseLevelOrder() {
        if (root == null) {
            return;
        }
        Queue<Node<E>> nodes = new LinkedList<>();
        nodes.offer(root);
        while (!nodes.isEmpty()) {
            Node<E> node = nodes.poll();
            if (node != null) {
                System.out.print(node.value + " ");
                if (node.leftChild != null) {
                    nodes.offer(node.leftChild);
                }

                if (node.rightChild != null) {
                    nodes.offer(node.rightChild);
                }
            }
        }
    }

    //构建器
    public static class Builder<E> {
        private final Comparator<? super E> c;
        private Queue<E> values = new LinkedList<>();

        public Builder(Comparator<? super E> c) {
            this.c = c;
        }

        public Builder add(E value) {
            values.offer(value);
            return this;
        }

        public Builder add(E[] values) {
            for (E value : values) {
                this.values.offer(value);
            }
            return this;
        }

        public Builder addAll(List<? extends E> values) {
            for (E value : values) {
                this.values.offer(value);
            }
            return this;
        }

        public BinaryTree<E> build() {
            BinaryTree<E> binaryTree = new BinaryTree<>(c);
            while (!values.isEmpty()) {
                binaryTree.add(values.poll());
            }
            return binaryTree;
        }

    }
}

wangdepei

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
用java语言实现一个二叉树

学习自： http://www.baeldung.com/java-binary-tree (可能需要梯子)我是数据结构的初学者，最近又刚好有时间，就学习了一下用java语言实现二叉树的方法，写出来，留作记录并分享给大家。先定义这个二叉树的几个基础功能：1.插入新节点。由于二叉树是有序的，在增加节点时，需要根据一定的规则去插入新的节点。2.查找元素。查找一个元素是否在这个二叉...
复制链接

扫一扫