二叉树的java实现以及基本操作

二叉树的数据结构

这里使用了lombok自动生成属性的set和get方法

import lombok.Data;

/**
 * @author ignohh
 * @date 2020-08-28 8:56
 */
@Data
public class BinaryTreeNode {
    private String data;
    private BinaryTreeNode leftChild;
    private BinaryTreeNode rightChild;
    public BinaryTreeNode(String data) {
        this.data = data;
    }
}

基本操作

二叉树的创建

我首先定义了一个二叉树接口方便操作的查看和管理

/**
 * @author ignohh
 * @date 2020-08-28 14:35
 */
public interface BinaryTree {
}

然后在接口所在目录下创建impl子目录，新建BinaryTreeImpl实现类来实现接口中的功能

import com.example.datastructure.BinaryTree;
import com.example.datastructure.BinaryTreeNode;
import lombok.Data;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

/**
 * @author ignohh
 * @date 2020-08-28 9:15
 */
@Data
public class BinaryTreeImpl implements BinaryTree {
    private BinaryTreeNode root;

    /***
     * 二叉树的初始化
     */
    public BinaryTreeImpl() {
        this.root = new BinaryTreeNode(new Scanner(System.in).nextLine());
    }
    public BinaryTreeImpl(BinaryTreeNode root) {
        this.root = root;
    }

    /***
     * 判断树是否为空
     * @return boolean
     */
    public boolean isEmpty() {
        return root == null;
    }

    @Override
    public void visit(BinaryTreeNode node) {
        System.out.println(node.getData());
    }

    /***
     * 插入节点
     */
    @Override
    public void insertNode(BinaryTreeNode node) {
         node.setLeftChild(root.getLeftChild());
         root.setLeftChild(node);
    }
    @Override
    public void insertNode(String data) {
        BinaryTreeNode node = new BinaryTreeNode(data);
        this.insertNode(node);
    }

    /***
     * 递归实现先序遍历
     * @param root 递归节点
     */
    @Override
    public void preOrderTraverse(BinaryTreeNode root) {
        if(root!=null) {
            visit(root);
            preOrderTraverse(root.getLeftChild());
            preOrderTraverse(root.getRightChild());
        }
    }
    /***
     * 递归实现中序遍历
     * @param root 递归节点
     */
    @Override
    public void inOrderTraverse(BinaryTreeNode root) {
        if(root!=null) {
            inOrderTraverse(root.getLeftChild());
            visit(root);
            inOrderTraverse(root.getRightChild());
        }
    }

    /***
     * 递归实现后序遍历
     * @param root 递归节点
     */
    @Override
    public void postOrderTraverse(BinaryTreeNode root) {
        if(root!=null) {
            postOrderTraverse(root.getLeftChild());
            postOrderTraverse(root.getRightChild());
            visit(root);
        }
    }

    /***
     * 利用队列实现层序遍历
     * @param root 层序遍历的树根节点
     */
    @Override
    public void levelOrderTraverse(BinaryTreeNode root) {
        Queue<BinaryTreeNode> queue = new LinkedList<>();
        queue.offer(root);
        BinaryTreeNode node = queue.poll();
        while(node!=null) {
            visit(node);
            if(node.getLeftChild()!=null) {
                queue.offer(node.getLeftChild());
            }
            if(node.getRightChild()!=null) {
                queue.offer(node.getRightChild());
            }
            node = queue.poll();
        }
    }

}

线索化

测试