java--二叉树常见操作

二叉树节点定义

public class BinaryNode {

    /**
     * 左节点
     */
    private BinaryNode leftNode;
    /**
     * 右节点
     */
    private BinaryNode rightNode;
    /**
     * 节点数据
     */
    private T data;
    public BinaryNode(T data) {
        this.data = data;
    }
    public BinaryNode getLeftNode() {
        return leftNode;
    }

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

    public BinaryNode getRightNode() {
        return rightNode;
    }

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

    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
}

常见操作

public class Test {

    /**
     * @title 获取二叉树节点数量（递归）
     */
    public static  int getNodes(BinaryNode rootNode){
        if (rootNode == null) {
            return 0;
        }else {
            return 1 + getNodes(rootNode.getLeftNode()) + getNodes(rootNode.getRightNode());
        }
    }
    /**
     * @title 获取二叉树深度（递归）
     */
    public static  int getDepth(BinaryNode rootNode){
        if (rootNode == null) {
            return 0;
        }else {
            int left = getDepth(rootNode.getLeftNode());
            int right = getDepth(rootNode.getRightNode());
            return left > right ? left + 1 : right + 1;
        }
    }
    /**
     * @title 前序遍历二叉树（递归）（遍历顺序：根节点、左节点、右节点）
     */
    public static  void frontTraverse(BinaryNode rootNode){
        if (rootNode == null) {
            return;
        }else {
            System.out.print(rootNode.getData());
            frontTraverse(rootNode.getLeftNode());
            frontTraverse(rootNode.getRightNode());
        }

    }
    /**
     * @title 中序遍历二叉树（递归）（遍历顺序：左节点、根节点、右节点）
     */
    public static  void midTraverse(BinaryNode rootNode){
        if (rootNode == null) {
            return;
        }else {
            midTraverse(rootNode.getLeftNode());
            System.out.print(rootNode.getData());
            midTraverse(rootNode.getRightNode());
        }
    }
    /**
     * @title 后续遍历二叉树（递归）（遍历顺序：左节点、右节点、根节点）
     */
    public static  void afterTraverse(BinaryNode rootNode){
        if (rootNode == null) {
            return;
        }else {
            afterTraverse(rootNode.getLeftNode());
            afterTraverse(rootNode.getRightNode());
            System.out.print(rootNode.getData());
        }
    }
    /**
     * @title 层次遍历二叉树（从上往下，从左往右）
     */
    public static  void levelTraverse(BinaryNode rootNode){
        if (rootNode == null) {
            return;
        }
        Queue> queue = new LinkedBlockingDeque<>();
        queue.offer(rootNode);
        while(!queue.isEmpty()){
            BinaryNode curNode = queue.poll();
            System.out.print(curNode.getData());
            if (curNode.getLeftNode() != null) {
                queue.offer(curNode.getLeftNode());
            }
            if (curNode.getRightNode() != null) {
                queue.offer(curNode.getRightNode());
            }
        }
    }
    public static void main(String[] args) {
        BinaryNode root = new BinaryNode(1);
        BinaryNode left = new BinaryNode(2);
        BinaryNode right = new BinaryNode(3);
        root.setLeftNode(left);
        root.setRightNode(right);
        BinaryNode left1 = new BinaryNode(4);
        BinaryNode right1 = new BinaryNode(5);
        BinaryNode left2 = new BinaryNode(6);
        BinaryNode right2 = new BinaryNode(7);
        left.setLeftNode(left1);
        left.setRightNode(right1);
        right.setLeftNode(left2);
        right.setRightNode(right2);
        BinaryNode left3 = new BinaryNode(8);
        left1.setLeftNode(left3);
        System.out.println("节点数："+getNodes(root));
        System.out.println("深度："+getDepth(root));
        System.out.println("前序遍历结果：");
        frontTraverse(root);
        System.out.println();
        System.out.println("中序遍历结果：");
        midTraverse(root);
        System.out.println();
        System.out.println("后序遍历结果：");
        afterTraverse(root);
        System.out.println();
        System.out.println("层次遍历结果：");
        levelTraverse(root);

    }

}