二叉树系列（一）------基本二叉树实现+3种遍历方式代码

概念

• 二叉树是树的一种，其中每个节点都不能有多于两个儿子；
• 平均深度为 $O(\sqrt{N})$;最坏深度 $N-1$

可以看到，上面都是二叉树，最坏的深度达到了 $N-1$

3种遍历方法

定义一个二叉树

• 前序遍历：根节点–>左子节点–>右子节点
• 中序遍历：左子节点–>根节点–>右子节点
• 后序遍历：左子节点–>右子节点–>根节点
  期望的到到结果：
• 前序遍历：ABDHIECFG
• 中序遍历：HDIBEAFCG
• 后序遍历：HIDEBFGCA

代码实现

1 构建实现节点的方式

package 树.二叉树;

public class BinaryNode {
    Object binaryNode;
    BinaryNode left;
    BinaryNode right;

    public BinaryNode(Object binaryNode) {
        this.binaryNode = binaryNode;
    }

    /**
     * 构造一个节点
     * @param binaryNode  节点数据
     * @param left   左子节点
     * @param right  右子节点
     */
    public BinaryNode(Object binaryNode, BinaryNode left, BinaryNode right) {
        this.binaryNode = binaryNode;
        this.left = left;
        this.right = right;
    }
}

2 构建二叉树

package 树.二叉树;

import java.util.ArrayList;
import java.util.List;

public class BinaryTree <T> {
    BinaryNode root; //表示根节点

    public BinaryTree(Object root) {
        this.root = new BinaryNode(root);
    }

    /**
     * 添加节点,先确定插入的位置，再判断是能插入
     * @return
     */
    public BinaryNode add(BinaryNode parentNode,Object data,boolean isLeft){
        if(parentNode==null)
            throw new RuntimeException("父节点为空，无法添加子节点");
        if(isLeft && parentNode.left != null)
            throw new RuntimeException("左子节点已经存在，添加失败");
        if(!isLeft && parentNode.right != null)
            throw new RuntimeException("右子节点已经存在，添加失败");
        BinaryNode binaryNode = new BinaryNode(data); // 定义一个新节点
        if(isLeft){
            parentNode.left = binaryNode;
        }else{
            parentNode.right = binaryNode;
        }
        return binaryNode;
    }

    /**
     * 前序遍历 ： 父节点-->左子节点-->右子节点
     * @return
     */
    public List<BinaryNode> beforeAll(){
        return beforeQuery(root);
    }
    public List<BinaryNode> beforeQuery(BinaryNode binaryNode){
        List <BinaryNode> binaryNodeList = new ArrayList<>();
        binaryNodeList.add(binaryNode);
        if(binaryNode.left!=null)
            binaryNodeList.addAll(beforeQuery(binaryNode.left)); // 递归调用
        if(binaryNode.right!=null)
            binaryNodeList.addAll(beforeQuery(binaryNode.right)); // 递归调用
        return binaryNodeList;
    }
    /**
     * 中序遍历 ： 左子节点-->父节点-->右子节点
     * @return
     */
    public List<BinaryNode> middleAll(){
        return middleQuery(root);
    }
    public List<BinaryNode> middleQuery(BinaryNode binaryNode){
        List <BinaryNode> binaryNodeList = new ArrayList<>();
        if(binaryNode.left!=null)
            binaryNodeList.addAll(middleQuery(binaryNode.left)); // 递归调用
        binaryNodeList.add(binaryNode);
        if(binaryNode.right!=null)
            binaryNodeList.addAll(middleQuery(binaryNode.right)); // 递归调用
        return binaryNodeList;
    }

    /**
     * 后序遍历 ： 左子节点-->右子节点-->父节点
     * @return
     */
    public List<BinaryNode> afterAll(){
        return afterQuery(root);
    }
    public List<BinaryNode> afterQuery(BinaryNode binaryNode){
        List <BinaryNode> binaryNodeList = new ArrayList<>();
        if(binaryNode.left!=null)
            binaryNodeList.addAll(afterQuery(binaryNode.left)); // 递归调用
        if(binaryNode.right!=null)
            binaryNodeList.addAll(afterQuery(binaryNode.right)); // 递归调用
        binaryNodeList.add(binaryNode);
        return binaryNodeList;
    }

}

3 添加节点实现测试

package 树.二叉树;

import java.util.List;

public class Test {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree("A");
        BinaryNode node11 = binaryTree.add(binaryTree.root,"B",true);
        BinaryNode node12 = binaryTree.add(binaryTree.root,"C",false);
        BinaryNode node21 = binaryTree.add(node11,"D",true);
        BinaryNode node22 = binaryTree.add(node11,"E",false);
        BinaryNode node23 = binaryTree.add(node12,"F",true);
        BinaryNode node24 = binaryTree.add(node12,"G",false);
        BinaryNode node31 = binaryTree.add(node21,"H",true);
        BinaryNode node32 = binaryTree.add(node21,"I",false);
        // 前序遍历
        System.out.println("前序遍历结构为：");
        List<BinaryNode> list1 = binaryTree.beforeAll();
        for(BinaryNode binaryNode:list1){
            System.out.print(binaryNode.binaryNode);
        }
        // 中序遍历
        System.out.println("\n中序遍历结构为：");
        List<BinaryNode> list2 = binaryTree.middleAll();
        for(BinaryNode binaryNode:list2){
            System.out.print(binaryNode.binaryNode);
        }
        // 后序遍历
        System.out.println("\n后序遍历结构为：");
        List<BinaryNode> list3 = binaryTree.afterAll();
        for(BinaryNode binaryNode:list3){
            System.out.print(binaryNode.binaryNode);
        }
    }
}

测试结果

前序遍历结构为：
ABDHIECFG
中序遍历结构为：
HDIBEAFCG
后序遍历结构为：
HIDEBFGCA

done成功！！！