二叉树Java实现

定义

二叉树的定义是每个节点最多两个子节点，左子节点始终小于根节点，右子节点始终大于根节点。

相关概念

遍历

先序遍历

先访问根节点，再访问左子叶节点，最后访问右子叶节点

中序遍历

先访问左子节点，再访问根节点，最后访问右子节点，对每个节点访问时都执行以上规则，从而输出从小到大的排序

后序遍历

先访问左子叶节点，再访问右子叶节点，最后访问根节点

搜索

搜索过程模拟了就是一个二分搜索法

前继节点

小于当前节点值的最大节点

后继节点

大于当前节点值的最小节点

源码

package com.company;


public class BinaryTree<T extends Comparable> {
    private Node root;

    class Node {
        private Node left, right, parent;
        private T value;

        public Node(T value) {
            this.value = value;
        }
    }

    //先序遍历
    public void traversePreOrder(Node node) {
        if (node != null) {
            System.out.println(node.value);
            traversePreOrder(node.left);
            traversePreOrder(node.right);
        }
    }

    //中序遍历
    public void traverseInOrder(Node node) {
        if (node != null) {
            traverseInOrder(node.left);
            System.out.println(node.value);
            traverseInOrder(node.right);
        }
    }

    //后序遍历
    public void traversePostOrder(Node node) {
        if (node != null) {
            traversePostOrder(node.left);
            traversePostOrder(node.right);
            System.out.println(node.value);
        }
    }

    //搜索
    public Node search(T value) {
        return search(root, value);
    }

    //搜索
    public Node search(Node node, T value) {
        if (value != null && node != null && node.value != null) {
            while (node != null && !value.equals(node.value)) {
                int diff = value.compareTo(node.value);
                if (diff < 0) {
                    node = node.left;
                } else {
                    node = node.right;
                }
            }
            return node;
        }
        return null;
    }

    //最小值
    public Node min(Node node) {
        if (node != null) {
            while (node.left != null) {
                node = node.left;
            }
        }
        return node;
    }

    //最大值
    public Node max(Node node) {
        if (node != null) {
            while (node.right != null) {
                node = node.right;
            }
        }
        return node;
    }

    //插入
    public void insert(T key) {
        insert(new Node(key));
    }

    //插入
    public void insert(Node node) {
        if (node != null && node.value != null) {
            Node start = root;
            Node parent = null;
            int diff = 0;
            while (start != null) {
                parent = start;
                diff = node.value.compareTo(start.value);
                if (diff < 0) {
                    start = start.left;
                } else if (diff > 0) {
                    start = start.right;
                } else {
                    return;
                }
            }
            if (parent == null) {
                root = node;
            } else {
                node.parent = parent;
                if (diff < 0) {
                    parent.left = node;
                } else {
                    parent.right = node;
                }
            }
        }
    }

    //前驱节点
    public Node predecessor(Node node) {
        if (node != null && node.left != null) {
            return max(node.left);
        }
        Node parent = node.parent;
        Node sub = node;
        while (parent != null) {
            if (parent.right == sub) {
                return parent;
            }
            sub = parent;
            parent = parent.parent;
        }
        return null;
    }

    //后驱节点
    public Node successor(Node node) {
        if (node != null && node.right != null) {
            return min(node.right);
        }
        Node parent = node.parent;
        Node sub = node;
        while (parent != null) {
            if (parent.left == sub) {
                return parent;
            }
            sub = parent;
            parent = parent.parent;
        }
        return null;
    }

    //删除,返回被删除节点
    public Node delete(T key) {
        Node aimNode = search(key);
        delete(aimNode);
        return aimNode;
    }

    //删除，返回被删除节点
    public Node delete(Node node) {
        if (node != null) {
            Node deleteIndex = null;
            if (node.left == null || node.right == null) {
                deleteIndex = node;
            } else {
                deleteIndex = successor(node);
            }
            Node sub;
            if (deleteIndex.left != null) {
                sub = deleteIndex.left;
            } else {
                sub = deleteIndex.right;
            }
            if (sub != null) {
                sub.parent = deleteIndex.parent;
            }
            if (deleteIndex.parent == null) {
                root = sub;
            } else if (deleteIndex == deleteIndex.parent.left) {
                deleteIndex.parent.left = sub;
            } else {
                deleteIndex.parent.right = sub;
            }
            if (deleteIndex != node) {
                node.value = deleteIndex.value;
            }
        }
        return node;
    }
}