二叉树

定义

二叉树是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。

如图:

二叉树特点

• 每个结点最多有两颗子树，所以二叉树中不存在度大于2的结点。
• 左子树和右子树是有顺序的，次序不能任意颠倒。
• 即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。

二叉树实现遍历,查找,删除功能

/**
 * 数的节点
 */
public class TreeNode {

    /**
     * 左边节点
     */
    private TreeNode left;

    /**
     * 右边节点
     */
    private TreeNode right;

    public int id;

    public String value;

    public TreeNode(int id, String value) {
        this.id = id;
        this.value = value;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "TreeNode{" +
                "id=" + id +
                ", value='" + value + '\'' +
                '}';
    }
}




/**
 * 二叉树的操作
 * <p>
 * 遍历: 前序,中序,后序遍历
 * <p>
 * 查找: 前序,中序,后续查找
 * <p>
 * 删除: 如果是叶子节点,就删除叶子节点,如果是子树,就删除子树
 * 如果是跟节点,那么就删除树
 **/
public class BinaryTree {

    /**
     * 根节点
     */
    private TreeNode root;


    /**
     * 构造方法,传入
     *
     * @param root
     */
    public BinaryTree(TreeNode root) {
        this.root = root;
    }

    /**
     * 前序二叉树
     */
    public void preShow() {
        if (null == root) {
            return;
        }
        preList(root);
    }


    /**
     * 前序遍历
     *
     * @param node
     */
    private void preList(TreeNode node) {
        System.out.println(node);
        if (node.getLeft() != null) {
            preList(node.getLeft());
        }
        if (node.getRight() != null) {
            preList(node.getRight());
        }
    }


    /**
     * 中序排序
     */
    public void mideShow() {
        if (null == root) {
            return;
        }
        mideShow(root);
    }


    /**
     * 中序
     */
    private void mideShow(TreeNode node) {
        if (node.getLeft() != null) {
            mideShow(node.getLeft());
        }
        System.out.println(node);
        if (node.getRight() != null) {
            mideShow(node.getRight());
        }
    }


    /**
     * 后序
     */
    public void lastShow() {
        if (null == root) {
            return;
        }
        lastList(root);
    }

    /**
     * 后序
     */
    public void lastList(TreeNode node) {
        if (node.getLeft() != null) {
            lastList(node.getLeft());
        }
        if (node.getRight() != null) {
            lastList(node.getRight());
        }
        System.out.println(node);
    }


    /**
     * 通过前序遍历的方式查找
     *
     * @return
     */
    public TreeNode preSearch(int key) {
        if (null == root) {
            return null;
        }
        return preQuery(root, key);
    }


    /**
     * 前序查找
     *
     * @param node
     */
    private TreeNode preQuery(TreeNode node, int key) {
        if (key == node.getId()) {
            return node;
        }
        TreeNode result = null;
        if (node.getLeft() != null) {
            result = preQuery(node.getLeft(), key);
            if (result != null) {
                return result;
            }
        }
        if (node.getRight() != null) {
            result = preQuery(node.getRight(), key);
        }
        return result;
    }


    /**
     * 中序查找
     *
     * @return
     */
    public TreeNode midSearch(int key) {
        if (null == root) {
            return null;
        }
        return midQuery(root, key);
    }


    /**
     * 中序
     *
     * @param node
     */
    private TreeNode midQuery(TreeNode node, int key) {
        TreeNode result = null;
        if (node.getLeft() != null) {
            result = midQuery(node.getLeft(), key);
            if (result != null) {
                return result;
            }
        }
        if (key == node.getId()) {
            return node;
        }
        if (node.getRight() != null) {
            result = preQuery(node.getRight(), key);
        }
        return result;
    }


    /**
     * 后序查找
     *
     * @return
     */
    public TreeNode lastSearch(int key) {
        if (null == root) {
            return null;
        }
        return lastSearch(root, key);
    }

    /**
     * 后序查询
     *
     * @param node
     */
    private TreeNode lastSearch(TreeNode node, int key) {
        TreeNode result = null;
        if (node.getLeft() != null) {
            result = midQuery(node.getLeft(), key);
            if (result != null) {
                return result;
            }
        }

        if (node.getRight() != null) {
            result = preQuery(node.getRight(), key);
            if (result != null) {
                return result;
            }
        }
        if (key == node.getId()) {
            return node;
        }
        return result;
    }


    /**
     * 删除
     * 节点不能自我删除,需要找到上一级的节点
     *
     * @return
     */
    public boolean delete(int key) {
        if (null == root) {
            return false;
        }

        //删除跟节点
        if (root.id == key) {
            root = null;
            return true;
        }

        return deleteNode(root, key);
    }

    /**
     * 后序查询
     *
     * @param node
     */
    private boolean deleteNode(TreeNode node, int key) {
        boolean result = false;
        //判断左节点或者右节点是否要删除
        TreeNode left = node.getLeft();
        TreeNode right = node.getRight();
        //找左节点
        if (null != left && left.getId() == key) {
            node.setLeft(null);
            return true;
        }
        if (null != left) {
            result = deleteNode(left, key);
            if (result) {
                return result;
            }
        }

        //找右节点
        if (null != right && right.getId() == key) {
            node.setRight(null);
            return true;
        }
        if (null != right) {
            result = deleteNode(right, key);
            if (result) {
                return result;
            }
        }
        return result;
    }
}