java数据结构二叉树（二）

最新推荐文章于 2023-03-01 18:44:42 发布

conquery_java

最新推荐文章于 2023-03-01 18:44:42 发布

阅读量488

点赞数 2

分类专栏：笔记文章标签： java 链表数据结构二叉树队列

本文链接：https://blog.csdn.net/conquery_java/article/details/110184210

版权

本文详细介绍了二叉树的实现，特别是线索二叉树的概念，以及如何进行线索化过程。此外，文章还探讨了树、森林与二叉树之间的转换方法，包括树转换为二叉树、森林转换为二叉树以及二叉树还原为树或森林的步骤。同时，总结了树与森林的先序、中序和后序遍历策略。

摘要由CSDN通过智能技术生成

二叉树的实现

//树的结点类 

public class TreeNode<T> {
    //存储数据
    public T data;
    //指向左孩子和右孩子结点
    public TreeNode<T> left,right;
    public TreeNode(T data, TreeNode<T> left, TreeNode<T> right) {
        super();
        this.data = data;
        this.left = left;
        this.right = right;
    }
    public TreeNode(T data) {
        super();
        this.data = data;
    }
    public TreeNode() {
        this.data = null;
        this.left = null;
        this.right =null;   
    }

    public String toString() {
        return this.data.toString();
    }

}

//二叉树实现
public class BinaryTree<T>  {
   
    // 根结点，结点结构为二叉链表
    public TreeNode<T> root;

    /**
     * 构造空二叉树
     */
    public BinaryTree() {
   
        this.root = null;
    }

    /**
     * 判断二叉树是否为空
     */

    public boolean isEmpty() {
   
        return this.root == null;
    }

    /** 
     * 先序遍历二叉树
     */

    public void preOrder() {
   
        System.out.print("先序遍历二叉树：");
        // 调用先序遍历二叉树的递归方法
        preOrder(root);
        System.out.println();
    }

    /**
     * 先根次序遍历以p结点为根的子二叉树，递归方法
     * 
     * @param p
     */
    private void preOrder(TreeNode<T> p) {
   
        if (p != null) {
   
            // 访问当前结点
            System.out.print(p.data.toString() + " ");
            // 按先序遍历当前结点的左子树，递归调用
            preOrder(p.left);
            // 按先序遍历当前结点的右子树，递归调用
            preOrder(p.right);
        }
    }

    /**
     * 中序遍历二叉树
     */

    public void inOrder() {
   
        System.out.print("中序遍历二叉树： ");
        inOrder(root);
        System.out.println();
    }

    /**
     * 中序遍历以p结点为根的子二叉树，递归方法
     * 
     * @param p
     */
    private void inOrder(TreeNode<T> p) {
   
        if (p != null) {
   
            // 中序遍历左子树
            inOrder(p.left);
            System.out.print(p.data.toString() + " ");
            // 中序遍历右子树
            inOrder(p.right);
        }
    }

    /**
     * 后序遍历二叉树
     */

    public void postOrder() {
   
        System.out.print("后序遍历二叉树： ");
        postOrder(root);
        System.out.println();
    }

    /**
     * 后序遍历以p结点为根的子二叉树，递归方法
     * 
     * @param p
     */
    private void postOrder(TreeNode<T> p) {
   
        if (p != null) {
   
            postOrder(p.left);
            postOrder(p.right);
            System.out.print(p.data.toString() + " ");
        }
    }

    /**
     * 二叉树的层次遍历
     * 
     * 按层次遍历二叉树
     */

    public void levelOrder() {
   
        System.out.print("层次遍历二叉树: ");
        // 创建一个空队列
        Queue<TreeNode<T>> que = new ArrayDeque<TreeNode<T>>();
        TreeNode<T> p = this.root;
        while (p != null) {
   
            // 访问当前结点
            System.out.print(p.data + " ");
            // 如果根节点有左孩子，p的左孩子结点入队
            if (p.left != null)
                que.add(p.left);
            // 如果根节点有右孩子，p的右孩子结点入队
            if (p.right != null)
                que.add(p.right);
            // p指向出队结点，若队列空返回null
            p = que.poll();
        }
        System.out.println();
    }

    /**
     * 返回二叉树的结点个数
     */

    public int count() {
   
        return count(root);
    }

    /**
     * 返回以p结点为根的子树的结点个数
     * 
     * @param p
     * @return
     */
    private int count(TreeNode<T> p) {
   
        if (p == null) {
   
            return 0;
        }
        return 1 + count(p.left) + count(p.right);
    }

    /**
     * 返回二叉树的高度
     */

    public int height() {
   
        return height(root);
    }

    /**
     * 返回以p结点为根的子树高度，后序遍历
     * 
     * @param p
     * @return
     */
    private int height(TreeNode<T> p) {
   
        if (p == null) {
   
            return 0;
        }
        // 返回左子树的高度
        int lh = height(p.left);
        // 返回右子树的高度
        int rh = height(p.right);
        // 当前子树高度为较高子树的高度加1
        return (lh >= rh) ? lh + 1 : rh + 1;
    }

    /**
     * 查找并返回首次出现的关键字key元素
     */

    public T search(T key) {
   
        return searchNode(root, key).data;
    }

    /**
     * 查找并返回首次出现的关键字为key元素结点
     * 
     * @param key
     * @return
     */
    public TreeNode<T> searchNode(T key) {
   
        return searchNode(root, key);
    }

    /**
     * 在以p为根的子树中查找并返回首次出现的关键字为key元素结点，若未找到返回null，先序遍历
     * 
     * @param p
     * @param key
     * @return
     */
    private TreeNode<T> searchNode(TreeNode<T> p, T key) {
   <