5.1_二叉树

【树的基本概念】

 

【二叉树】

任何一个节点的子节点的数量不超过2。

二叉树的子节点分为左节点和右节点。

【满二叉树】

所有的叶子节点在最后一层。

而且节点的总数为2^n-1。

【完全二叉树】

所有叶子节点都在最后一层或者倒数第二层，且最后一层的叶子节点在左边连续，倒数第二节的叶子节点在右边连续。

 

【链式存储的二叉树】

【树的遍历】

[ 前序遍历 ]

根——左——右

[ 中序遍历 ]

左——根——右

[ 后序遍历 ]

左——右——根

【节点类TreeNode】

package com.tree.demo1;

/**
 * 二叉树节点
 */
public class TreeNode {

    //节点的权
    private int value;

    //左儿子
    private TreeNode leftNode;

    //右儿子
    private TreeNode rightNode;


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

    /**
     * 前序遍历
     */
    public void frontShow(){
        //1.先遍历当前节点的内容
        System.out.println(value);
        //2.再遍历左节点
        if(null!=leftNode){
            leftNode.frontShow();
        }
        //3.再遍历右节点
        if(null!=rightNode){
            rightNode.frontShow();
        }
    }

    /**
     * 中序遍历
     */
    public void midShow(){
        //左子节点
        if(null!=leftNode){
            leftNode.midShow();
        }
        //当前节点
        System.out.println(value);
        //右节点
        if(null!=rightNode){
            rightNode.midShow();
        }
    }

    /**
     * 后序遍历
     */
    public void afterShow(){
        //左子节点
        if(null!=leftNode){
            leftNode.afterShow();
        }
        //右节点
        if(null!=rightNode){
            rightNode.afterShow();
        }
        //当前节点
        System.out.println(value);
    }

    /**
     * 前序查找
     */
    public TreeNode frontSearch(int num){
        TreeNode target =null;
        if(this.value==num){
            return this;
        }else{
            if(null!=leftNode){
                target = leftNode.frontSearch(num);
            }
            if(null!=target){
                return target;
            }
            if(null!=rightNode){
                target = rightNode.frontSearch(num);
            }
            if(null!=target){
                return target;
            }
        }
        return target;
    }

    /**
     * 删除某个节点
     */
    public void delete(int num){
        TreeNode parent =this;
        //判断左儿子
        if(null!=parent.leftNode && num==parent.leftNode.getValue()){
            parent.setLeftNode(null);
            return;
        }
        //判断右儿子
        if(null!=parent.rightNode && num==parent.rightNode.getValue()){
            parent.setRightNode(null);
            return;
        }
        //递归检查并删除左儿子
        if(leftNode!=null){
            parent=leftNode;
            parent.delete(num);
        }
        //递归检查并删除右儿子
        if(rightNode!=null){
            parent=rightNode;
            parent.delete(num);
        }
    }

    public int getValue() {
        return value;
    }

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

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public TreeNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }
}

【二叉树类 BinaryTree】

package com.tree.demo1;

/**
 * 二叉树
 */
public class BinaryTree {

    //根节点
    private TreeNode root;

    /**
     * 前序遍历
     */
    public void frontShow(){
        if (null!=root) {
            root.frontShow();
        }
    }

    /**
     * 中序遍历
     */
    public void midShow(){
        root.midShow();
    }

    /**
     * 后序遍历
     */
    public void afterShow(){
        root.afterShow();
    }

    /**
     * 前序查找
     */
    public TreeNode frontSearch(int num){
        return root.frontSearch(num);
    }

    /**
     * 删除一个子树
     */
    public void delete(int num){
        root.delete(num);
    }

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }
}

【测试类】

package com.tree.demo1;

/**
 * 二叉树测试类
 */
public class BinaryTreeTest {

    public static void main(String[] args) {
        //创建一棵树
        BinaryTree tree = new BinaryTree();
        //创建一个根节点
        TreeNode rootNode = new TreeNode(1);

        //把根节点赋给树
        tree.setRoot(rootNode);
        //创建一个左节点
        TreeNode rootL = new TreeNode(2);
        rootNode.setLeftNode(rootL);
        //创建一个右节点
        TreeNode rootR = new TreeNode(3);
        rootNode.setRightNode(rootR);

        //为第二层的左节点创建两个子节点
        rootL.setLeftNode(new TreeNode(4));
        rootL.setRightNode(new TreeNode(5));
        //为第二层的右节点创建两个子节点
        rootR.setLeftNode(new TreeNode(6));
        rootR.setRightNode(new TreeNode(7));

        //遍历树-前序遍历
        tree.frontShow();
        System.out.println("==============================");

        //遍历树-中序遍历
        tree.midShow();
        System.out.println("==============================");

        //遍历树-后序遍历
        tree.afterShow();
        System.out.println("==============================");

        System.out.println(tree.frontSearch(5).getValue());

        System.out.println("==============================");
        tree.delete(2);
        tree.frontShow();

    }
}