[Java知识库] C站万字详解二叉树基本操作演示程序（附图）

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> C站万字详解二叉树基本操作演示程序（附图） -> 正文阅读

[Java知识库]C站万字详解二叉树基本操作演示程序（附图）

文章目录

一、实验环境

IDEA

二、设计需求分析

【问题描述】

设计一个与二叉树基本操作相关的演示操作。

【基本要求】

创建二叉树，按照用户需要的二叉树构建二叉树；

将创建的二叉树，以树形形式输出；

分别以先序、中序、后序、层序四种遍历访问二叉树；

输出二叉树的叶子结点及叶子结点的个数；

输出二叉树的高度；

三、实际设计思路

实现创建字母二叉树和数字二叉树两种二叉树，不同类型的二叉树实现的功能各有不同，充分运用类和对象、继承、多态、抽象类、接口等思想

在这里插入图片描述

四、对象与功能剖析

想要实现这样一个既可以构造字母二叉树也可以构造数字二叉树，并且每种类型的二叉树可以实现不同的功能，通过选择可以显示不同的菜单的二叉树操作程序，首先需要分析大体方面，这里打算分成3大方面

【树结构相关】（BinaryTree包）

二叉树节点类（TreeNode）；二叉树类（Tree）；

字母二叉树类（LetterTree）；数字二叉树类（NumTree）；

（注：二叉树类包含着两种类型的二叉树共同需要实现的方法，后者继承前者）

【功能相关】（Function包，内包含Heap包）

退出类（Exit）；创建二叉树类（ConstructTree）；

打印二叉树类（PrintTree）；二叉树高度类（GetHeight）；

叶子结点个数类（GetLeafSize）；叶子结点打印类（LeafNode）；

前序遍历类（PreorderTraversal）；中序遍历类（InorderTraversal）；

后序遍历类（PostorderTraversal）；层序遍历类（LevelOrderTraversal）；

Heap包：

建大堆（CreateBigHeap）； TopK（堆）类（TopK）；

（注：里面绝大多数功能需要用到构造的二叉树的根节点，因此将各个类通过接口IFunction联系起来，重写该接口中的抽象方法，调用功能时就会发生向上转型，实现多态）

【主函数相关】（Main类）

实现二叉树类型的选择，通过输入字符串，将其变成数组然后进行构造二叉树，通过一个循环选择各个功能，总而言之，Main类将之前的类巧妙的联系在了一起。

五、代码实现及算法思路分析

BinaryTree包

【二叉树节点类（TreeNode）】

为了使该节点可以接收字母类型的数据，也可以接收数字类型的数据，因此加了泛型，在程序运行的时候T就会被擦除成Object类型，该类型是所有类的父类

代码如下：

package BinaryTree;

public class TreeNode<T> {
    public T val;
    public TreeNode<T> left; //左孩子
    public TreeNode<T> right; //右孩子
    public TreeNode (T x) {   //一个参数的构造方法
        this.val=x;
    }
}

【二叉树类（Tree）】

Tree类被NumTree类和LetterTree类继承，是一个抽象类，该类不可以被实例化，其存在的方法就是被继承

代码如下：

package BinaryTree;
import Function.IFunction;

public abstract class Tree {
    protected IFunction[] iFunctions;//该数组可以接受不同类型的二叉树的不同功能
    public abstract void menu();//需要被重写达到多态，从而拿到不同的菜单
    //choice 表示iFunction 数组的下标，其值不同，实现的功能也不会相同
    public void getFunction(int choice,TreeNode root){
        this.iFunctions[choice].work(root);
    }
    public abstract int func(); //功能的选择
}

【字母二叉树类（LetterTree）】

代码如下：

package BinaryTree;
import Function.*;
import java.util.Scanner;

public class LetterTree extends Tree{
    public LetterTree() {
        //初始化父类的iFunction的数组
        iFunctions = new IFunction[] {
                new Exit(),               //退出
                new PreorderTraversal(),  //前序遍历
                new InorderTraversal(),   //中序遍历
                new PostorderTraversal(), //后序遍历
                new LevelOrderTraversal(),//层序遍历
                new LeafNode(),           //叶子节点打印
                new GetLeafSize(),        //叶子结点个数
                new GetHeight(),          //二叉树高度
                new PrintTree()           //打印二叉树
        };
    }
    //重写父类的抽象方法menu
    @Override
    public void menu() {
        System.out.println("============== 字母二叉树 ================");
        System.out.println("====== 0.退出        1.前序遍历     =======");
        System.out.println("====== 2.中序遍历    3.后序遍历      =======");
        System.out.println("====== 4.层序遍历    5.叶子结点打印  =======");
        System.out.println("====== 6.叶子结点个数 7.二叉树高度   =======");
        System.out.println("======          8.打印二叉树        =======");
        System.out.println("请选择你想要进行的操作：");
    }
    //重写父类的抽象方法func，实现功能的选择
    @Override
    public int func() {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            int choice = scanner.nextInt();
            if(choice >= 0 && choice <= 8) {
                return choice;
            }else {
                System.out.println("选择错误，请重新进行选择！");
            }
        }
    }
}

【数字二叉树类（NumTree）】

代码如下：

package BinaryTree;
import Function.*;
import Function.Heap.CreateBigHeap;
import Function.Heap.TopK;
import java.util.Scanner;

public class NumTree extends Tree{
    public NumTree(){
        //初始化父类的iFunction的数组
        iFunctions = new IFunction[]{
                new Exit(),              //退出
                new GetHeight(),         //二叉树高度
                new LeafNode(),          //叶子结点打印
                new GetLeafSize(),       //叶子节点个数
                new PrintTree(),          //二叉树的打印
                new TopK(),              //值最大的K个数
                new CreateBigHeap()      //创建大根堆
        };
    }
    //重写父类的抽象方法menu
    @Override
    public void menu() {
        System.out.println("=============== 数字二叉树 =============");
        System.out.println("====== 0.退出         1.二叉树高度  =====");
        System.out.println("====== 2.叶子结点打印  3.叶子结点个数=====");
        System.out.println("====== 4.二叉树打印    5.TopK(堆)   =====");
        System.out.println("=======        6.  建大堆          =====");
        System.out.println("请选择你想要进行的操作：");
    }
    //重写父类的抽象方法func，实现功能的选择
    @Override
    public int func() {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            int choice = scanner.nextInt();
            if(choice >= 0 && choice <= 6) {
                return choice;
            }else {
                System.out.println("选择错误，请重新进行选择！");
            }
        }
    }
}

Function包

【退出类（Exit）】

代码如下：

package Function;
import BinaryTree.TreeNode;

public class Exit<T> implements IFunction<T>{
    @Override
    public void work(TreeNode<T> root) {
        System.out.println("成功退出！");
        System.exit(0);
    }
}

【创建二叉树类（ConstructTree）】

需要调用类内的方法constructTree(T[] numbs)，输入的参量为一个数组，该数组可能是字符数组也可能是数字字符，但是原理都是一样的。按照层序遍历的方法来将二叉树变成一个二叉树，若某节点的子节点为空，那么就在对应的地方填null。

具体思想：用一个队列nodeQueue来存储该层的所有节点，然后用父节点的数量的两倍来遍历输入的数组（从上一层结束的地方开始），并从队列中取出（位于上一层的）对应的父节点（此时已从队列中删去，因为用的方法为poll()而不是peek()），对于每一个值，创建相应的子节点链接到父节点，并加入到队列中，依次不断循环，直到遍历完整个数组。

代码如下：

package Function;
import BinaryTree.TreeNode;
import java.util.Deque;
import java.util.LinkedList;

public class ConstructTree<T> {
    public TreeNode<T> constructTree(T[] numbs){
        if (numbs.length == 0) return new TreeNode<T>(null);
        Deque<TreeNode<T>> nodeQueue = new LinkedList<>();
        // 创建一个根节点
        TreeNode<T> root = new TreeNode<T>(numbs[0]);
        nodeQueue.offer(root);
        TreeNode<T> cur;
        // 记录当前行节点的数量（注意不一定是2的幂，而是上一行中非空节点的数量乘2）
        int lineNodeNum = 2;
        // 记录当前行中数字在数组中的开始位置
        int startIndex = 1;
        // 记录数组中剩余的元素的数量
        int restLength = numbs.length - 1;
        while(restLength > 0) {
            // 只有最后一行可以不满，其余行必须是满的
            // 若输入的数组的数量是错误的，直接跳出程序
            for (int i = startIndex; i < startIndex + lineNodeNum; i = i + 2) {
                // 说明已经将numbs中的数字用完，此时应停止遍历，并可以直接返回root
                if (i == numbs.length) return root;
                cur = nodeQueue.poll();
                if (numbs[i] != null) {
                    assert cur != null;
                    cur.left = new TreeNode<T>(numbs[i]);
                    nodeQueue.offer(cur.left);
                }
                // 同上，说明已经将numbs中的数字用完，此时应停止遍历，并可以直接返回root
                if (i + 1 == numbs.length) return root;
                if (numbs[i + 1] != null) {
                    assert cur != null;
                    cur.right = new TreeNode<T>(numbs[i + 1]);
                    nodeQueue.offer(cur.right);
                }
            }
            startIndex += lineNodeNum;
            restLength -= lineNodeNum;
            lineNodeNum = nodeQueue.size() * 2;
        }
        return root;
    }
}

【打印二叉树类（PrintTree）】

具体思想：用一个二维的字符串数组来储存每个位置应该打印什么样的输出。

首先，先确定树的形状。设定在最后一行的每个数字之间的间隔为3个空格，而在之上的每一层的间隔，越往上，间隔是越大的，而且是一个简单的线性增加的关系。

为绘制出这样的形状，我们需要获得树的层数，根据树的层数，确定二维数组的大小，即高度和宽度。之后，用先序遍历的方式，遍历树的每个节点，并进行相对应的写入操作。

代码如下：

package Function;
import BinaryTree.TreeNode;
import java.util.Deque;
import java.util.LinkedList;

public class ConstructTree<T> {
    public TreeNode<T> constructTree(T[] numbs){
        if (numbs.length == 0) return new TreeNode<T>(null);
        Deque<TreeNode<T>> nodeQueue = new LinkedList<>();
        // 创建一个根节点
        TreeNode<T> root = new TreeNode<T>(numbs[0]);
        nodeQueue.offer(root);
        TreeNode<T> cur;
        // 记录当前行节点的数量（注意不一定是2的幂，而是上一行中非空节点的数量乘2）
        int lineNodeNum = 2;
        // 记录当前行中数字在数组中的开始位置
        int startIndex = 1;
        // 记录数组中剩余的元素的数量
        int restLength = numbs.length - 1;
        while(restLength > 0) {
            // 只有最后一行可以不满，其余行必须是满的
            // 若输入的数组的数量是错误的，直接跳出程序
            for (int i = startIndex; i < startIndex + lineNodeNum; i = i + 2) {
                // 说明已经将numbs中的数字用完，此时应停止遍历，并可以直接返回root
                if (i == numbs.length) return root;
                cur = nodeQueue.poll();
                if (numbs[i] != null) {
                    assert cur != null;
                    cur.left = new TreeNode<T>(numbs[i]);
                    nodeQueue.offer(cur.left);
                }
                // 同上，说明已经将numbs中的数字用完，此时应停止遍历，并可以直接返回root
                if (i + 1 == numbs.length) return root;
                if (numbs[i + 1] != null) {
                    assert cur != null;
                    cur.right = new TreeNode<T>(numbs[i + 1]);
                    nodeQueue.offer(cur.right);
                }
            }
            startIndex += lineNodeNum;
            restLength -= lineNodeNum;
            lineNodeNum = nodeQueue.size() * 2;
        }
        return root;
    }
}

【二叉树高度类（GetHeight）】

用递归的方法求二叉树的高度

思想：一棵树的高度为左子树和右子树中较高的高度加一，当节点为空，则高度为0

在这里插入图片描述

时间复杂度：O(N)

代码如下：

package Function;
import BinaryTree.TreeNode;

public class GetHeight<T> implements IFunction<T>{
    public int getHeight(TreeNode<T> root) {
        if (root == null) {
            return 0;
        }
        return Math.max(getHeight(root.left),getHeight(root.right))+1;
    }
    @Override
    public void work(TreeNode<T> root) {
        System.out.println("二叉树高度：" + getHeight(root));
    }
}

【叶子点个数类（GetLeafSize）】

用递归的方法求叶子结点个数

思想：一棵树的叶子节点的个数是根节点的左子树的叶子节点的个数和右子树的叶子节点的个数之和(在这里采取的是前序遍历的方法进行叶子结点的寻找，因此遍历的图和前序遍历的差不多，只是在那个基础上顺便判断了一下是否为叶子结点而已,如果是count加一)

时间复杂度：O(N)

代码如下：

package Function;
import BinaryTree.TreeNode;

public class GetLeafSize<T> implements IFunction<T>{
    @Override
    public void work(TreeNode<T> root) {
        GetSize<T> get = new GetSize<>();
        int count = get.size(root);
        System.out.println("叶子结点个数：" + count);
    }
}
class GetSize<T> {
    //具体进行计算的方法
    public static int count;//计算叶子节点的变量
    public int size(TreeNode<T> root) {
        if (root == null) return 0;
        //叶子节点的条件就是左右节点都为空
        if (root.left == null && root.right == null) {
            count++;
        }
        size(root.left);
        size(root.right);
        return count;
    }
}

【叶子结点打印类（LeafNode）】

用递归的方法，用一顺序结构list来存储结果

思想：若节点为空就直接返回，若不为空就判断左右孩子是否都为空，成立说明是叶子节点，将其值放入list中；根节点不为空，就依次遍历左子树和右子树的所有节点进行判断(在这里采取的是前序遍历的方法进行叶子结点的寻找，因此遍历的图和前序遍历的差不多，只是在那个基础上顺便判断了一下是否为叶子结点而已,如果是就将叶子结点的值添加到list中)

时间复杂度：O(N)

代码如下：

package Function;
import BinaryTree.TreeNode;
import java.util.ArrayList;
import java.util.List;

public class LeafNode<T> implements IFunction<T>{
    @Override
    public void work(TreeNode<T> root) {
        List<T> list = new ArrayList<>();
        Leaf<T> leaf = new Leaf<>();
        list = leaf.Node(root,list);
        System.out.println("叶子节点：" + list);
    }
}
class Leaf<T> {
    public List<T> Node(TreeNode<T> root,List<T> list) {
        if (root == null) return null;
        if (root.right == null && root.left == null) {
            list.add(root.val); //符合叶子节点的条件
        }
        Node(root.left,list); //遍历左子树
        Node(root.right,list);//遍历右子树
        return list;
    }
}

【前序遍历类（PreorderTraversal）】

思想：递归的思想，就是将一个大的问题转化为几个小的子问题，直到子问题可以很容易求解，最后将子问题的解组合起来就是大问题的解。用一顺序结构list来存储前序遍历的结果，若节点为空就直接返回(先根结点后左子树最后右子树)

在这里插入图片描述

时间复杂度：O(N)

代码如下：

package Function;
import BinaryTree.TreeNode;
import java.util.ArrayList;
import java.util.List;

public class PreorderTraversal<T> implements IFunction<T>{
    @Override
    public void work(TreeNode<T> root) {
        List<T> list = new ArrayList<>();
        preorder(list,root);
        System.out.println("前序遍历：" + list);
    }
    public void preorder(List<T> list,TreeNode<T> root) {
        if (root == null) {
            return;
        }
        list.add(root.val);       //将根节点的值放入list中
        preorder(list,root.left); //遍历左子树
        preorder(list,root.right);//遍历右子树
    }
}

【中序遍历类（InorderTraversal）】

思想：递归的思想，用一顺序结构list来存储中序遍历的结果，若节点为空就直接返回(先左子树后根结点最后右子树)，遍历的图参考前序遍历，原理相同

时间复杂度：O(N)

代码如下：

package Function;
import BinaryTree.TreeNode;
import java.util.ArrayList;
import java.util.List;

public class InorderTraversal<T> implements IFunction<T>{
    @Override
    public void work(TreeNode<T> root) {
        List<T> list = new ArrayList<>();
        preorder(list,root);
        System.out.println("中序遍历：" + list);
    }
    public void preorder(List<T> list,TreeNode<T> root) {
        if (root == null) {
            return;
        }
        preorder(list,root.left); //遍历左子树
        list.add(root.val);  //将根节点的值放入list中
        preorder(list,root.right); //遍历右子树
    }
}

【后序遍历类（PostorderTraversal）】

思想：递归的思想，用一顺序结构list来存储后序遍历的结果，若节点为空就直接返回(先左子树后右子树最后根结点)，遍历的图参考前序遍历，原理相同

时间复杂度：O(N)

代码如下：

package Function;

import BinaryTree.TreeNode;
import java.util.ArrayList;
import java.util.List;

public class PostorderTraversal<T> implements IFunction<T>{
    @Override
    public void work(TreeNode<T> root) {
        List<T> list = new ArrayList<>();
        preorder(list,root);
        System.out.println("后序遍历：" + list);
    }
    public void preorder(List<T> list,TreeNode<T> root) {
        if (root == null) {
            return;
        }
        preorder(list,root.left); //遍历左子树
        preorder(list,root.right);//遍历右子树
        list.add(root.val);       //将根节点的值放入list中
    }
}

【层序遍历类（LevelOrderTraversal）】

层序遍历是直观的一种遍历方法，将二叉树的每一层分别遍历，直到最后的叶子节点被全部遍历完，这里要用到的辅助数据结构是队列，队列具有先进先出的性质。

思想：将二叉树的每一层的值分别放入各个线性表中，每次放完后将线性表加到总的大线性表中

每一层放线性表的思想：如果该根节点为空的话，就返回空的顺序表，创建一个队列，来暂时的存放某一层的节点

具体实现：创建一个队列，先将根节点（A）入队，此时队列不为空，记录其大小size（只有根结点，大小为1），再将根节点poll出去，返回值给top变量，利用top变量看看根结点有没有左孩子或右孩子，如果有，先左（B）后右（C）入队，size减一，只要队列还不为空，就说明还没有遍历完，就进行下一次循环，这时的队头元素则为刚才入队的左孩子（B），然后用相同的方法用top再把它的左右孩子拉进来（如果有），因为队列的先进先出性质，B的左右孩子DE是排在C后面的，然后输出B，下一次循环将会拉人C的孩子G，最后因为G没有左右孩子，一直出队，没有入队元素，当队列为空时，层序遍历结束。

在这里插入图片描述

时间复杂度：O(N)

代码如下：

package Function;
import BinaryTree.TreeNode;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class LevelOrderTraversal<T> implements IFunction<T>{
    @Override
    public void work(TreeNode<T> root) {
        level<T> level = new level<>();
        List<List<T>> list = level.levelOrder(root);
        System.out.print("层次遍历：" + list);
    }
}
class level<T>{
    public List<List<T>> levelOrder(TreeNode<T> root) {
        List<List<T>> ret = new ArrayList<>();
        if(root == null) return ret;
        Queue<TreeNode<T>> queue = new LinkedList<>();
        queue.offer(root);//先将根节点放入队列中
        //但凡队列中还有元素，就继续执行
        while(!queue.isEmpty()) {
            int size = queue.size(); //记录该队列中元素的数量
            List<T> list = new ArrayList<>();//存放每一层的数据
            //完成队列中的元素都放到list中且将二叉树下一层的元素节点放到队列中的任务
            while(size > 0) {
                TreeNode<T> top = queue.poll(); //将队列最顶端的元素poll给top节点变量
                assert top != null;
                //top节点若有左孩子就将它从队列尾部放进队列中
                if(top.left != null) {
                    queue.offer(top.left);
                }
                //top节点若有右孩子就将它从队列尾部放进队列中
                if(top.right!=null) {
                    queue.offer(top.right);
                }
                size--;//由于之前poll出了队列中最顶端的元素，队列的大小减一
                list.add(top.val); //将之前poll出的元素的值放到list线性表中
            }
            ret.add(list);//将每层形成的顺序表list加到大的总的线性表ret中
        }
        return ret;
    }
}

Function.Heap包

【建大堆（CreateBigHeap）】

根节点索引为0：

a. 最后一个非叶子节点的索引为（usedSize-1-1）/2；

b. 若父节点的索引是i，则它左孩子节点为2i+1，右孩子节点为2i+2；

构建大根堆的思路：

从最后一个非叶子节点为父节点的子树出发，从右往左，从下往上进行调整操作。
即调整函数 :

a.如果该节点比它的两个孩子节点都大，则该节点不用调整了，因为它的孩子节点也是堆有序

b.如果该节点比它的两个子节点中的较大节点小，即elem[i]<max(elem[2i+1],elem[2i+2]）,将max(elem[2i+1],elem[2i+2])赋给elem[i](通过变量tmp进行交换)。接着从max(elem[2i+1],elem[2i+2]) 对应的那个节点出发，继续进行该操作，直到该节点到达了usedSize。当然每次判断边界条件为左子树的索引小于usedSize，则右子树才有值。

在这里插入图片描述

时间复杂度O(N)

代码如下：

package Function.Heap;
import BinaryTree.TreeNode;
import Function.ConstructTree;
import Function.IFunction;
import Function.PrintTree;
import java.util.Arrays;

public class CreateBigHeap implements IFunction{
    public static int[] elem;
    public static int usedSize;
    public static int flag = 1;
    @Override
    public void work(TreeNode root) {
        if(flag == 1) {
            for (int i = (usedSize-1-1)/2; i >= 0; i--) {
                shiftDown(i);//向下调整
            }
            ConstructTree<Integer> integerConstructTree = new ConstructTree<>();
            TreeNode<Integer> root1 = integerConstructTree.constructTree(Arrays.stream(elem).boxed().toArray(Integer[]::new));
            PrintTree printTree = new PrintTree();
            printTree.work(root1);//打印新的二叉树
        }else {
            System.out.println("非完全二叉树！！无法执行相关操作");
        }
    }
    public void isFullTree(Integer[] array) {
        int len = array.length;
        elem = new int[len];//根据原数组的大小进行初始化数组大小
        for(int i = 0;i < len;i ++) {
            if(array[i] != null) {
                elem[i] = array[i]; //初始化elem数组的内容
                usedSize++;
            }else {
                System.out.println("温馨提示：此乃非完全二叉树，不可执行堆相关操作");
                flag = 0;
                break;
            }
        }
    }
    public void shiftDown(int parent) {
        int child = 2*parent+1;
        //进入这个循环 说明最起码你有左孩子
        while (child < usedSize) {
            //执行这个条件语句需要满足有右孩子和左孩子比右孩子小这两个条件，保证最后child的值是俩孩子中的较大值
            if(child+1 < usedSize && elem[child] < elem[child+1]) {
                child++;
            }
            //如果左右孩子中的最大值比父亲节点大，进行交换
            if(elem[child] > elem[parent]) {
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                parent = child; //继续向下调整，保证该子树是大根堆
                child = 2*parent+1;
            }else {
                break;//如果孩子节点比父亲节点小直接结束了
            }
        }
    }
}

【TopK（堆）类（TopK）】

我们时常会有寻找长度为n的数组中，排在前k的元素，对于top k的问题，最暴力的处理方式就是直接对数组进行排序，然后再去截取前k个数字，从而达到自己的目的，这种算法的实现复杂度为O（nlogn）。

其实有O（nlogk）时间复杂度的算法。我们先创建一个大小为k的数组来存储最大的k个数字，接下来我们从输入的n个数中读取一个数，如果容器还没有满则直接插入容器；若容器已经满了，则我们此时需要将容器中最小的数字和待插入的数字做比较，如果待插入的数值大于容器中的最小值，则需要将容器中的最小值删除，将新值插入，否则不做任何处理。

我们通过需求分析可以发现，小根堆可以满足我们的需求，因此我们通过小根堆来实现我们的容器。

TopK问题推荐文章

代码如下：

package Function.Heap;
import BinaryTree.TreeNode;
import Function.IFunction;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;

public class TopK implements IFunction {
    @Override
    public void work(TreeNode root) {
        if(CreateBigHeap.flag == 0) {
            System.out.println("非完全二叉树！！无法执行相关操作");
        }else {
            System.out.println("请输入K值：");
            Scanner scanner = new Scanner(System.in);
            int k = scanner.nextInt(); //输入K的值，需要保证K的值大于0，小于数组的长度
            while (k <= 0 || k > CreateBigHeap.elem.length) {
                System.out.println("k值输入错误，请重新输入");
                k = scanner.nextInt();
            }
            int[] ret = topK(CreateBigHeap.elem,k);
            System.out.println(Arrays.toString(ret));

        }
    }
    public int[] topK(int[] array,int k) {
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(); //优先级队列默认建立小堆
        for (int i = 0; i < array.length; i++) {
            if (minHeap.size() < k) {
                minHeap.offer(array[i]); //先将数组的前K个数放到小堆中
            }else {
                int top = minHeap.peek(); //如果堆顶的元素比array[i]小，就将其出队列，将array[i]入队列，在这些过程中，minHeap会自动调整成小堆
                if (top < array[i]) {
                    minHeap.poll();
                    minHeap.offer(array[i]);
                }
            }
        }
        int[] ret = new int[k];
        for (int i = 0; i < k; i++) {
            ret[i] = minHeap.poll();
        }
        return ret;
    }
}

【IFunction接口】

所有功能共同实现该接口，调用功能时发生向上转型，实现多态

代码如下：

package Function;
import BinaryTree.TreeNode;

public interface IFunction<T> {
    void work(TreeNode<T> root);
}

Main类

import BinaryTree.LetterTree;
import BinaryTree.NumTree;
import BinaryTree.Tree;
import BinaryTree.TreeNode;
import java.util.Scanner;
import Function.*;
import Function.Heap.CreateBigHeap;

public class Main {
    public static int choice; //选择二叉树类型0.字母二叉树 1.数字二叉树
    //选择想要建立的二叉树类型
    //该函数的返回值类型是总的二叉树类型（Tree）
    //如果选择了0，就会返回一个字母二叉树（LetterTree）的类型
    //如果选择了1，就会返回一个数字二叉树（NumTree）的类型
    //因为返回的二叉树类都继承了Tree类，所以发生了向上转型，实现了多态，这样之后的操作就会因为返回的类的类型不一样而拥有不一样的功能
    public static Tree newTree() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请选择你想要创建的二叉树类型：0.字母二叉树 1.数字二叉树");
        while (true) {
            choice = scanner.nextInt();
            if (choice == 0) {
                return new LetterTree();
            } else if (choice == 1) {
                return new NumTree();
            } else {
                System.out.println("选择错误，请重新输入！");
            }
        }
    }
    public static void main(String[] args) {
        Tree tree = newTree(); //实例化一个Tree类型的树
        Scanner scanner = new Scanner(System.in);
        //选择建立字母二叉树
        if (choice == 0) {
            System.out.println("请输入字母：");
            String str = scanner.next(); //输入字符串str
            String[] arr =  str.split(",");//以逗号为标志将字符串分割开来形成字符串类型的数组arr
            Character[] character = new Character[arr.length]; //将字符串数组转变成字符类型（Character）的数组
            for (int i = 0; i < character.length; i++) {
                //如果字符串数组arr中有null字符串，回头用层次遍历的方式创建二叉树的时候该处就是空，无节点
                if (arr[i].equals("null")) {
                    character[i] = null;
                }else {
                    character[i] = arr[i].charAt(0);
                    //此处创建的二叉树每个节点都只有一个字母，因此只取索引为0的字母即字符串的第一个字母
                }
            }
            //通过实例化ConstructTree类创建二叉树，参数为方才形成的character数组
            ConstructTree<Character> characterConstructTree = new ConstructTree<>();
            TreeNode<Character> root = characterConstructTree.constructTree(character);
            tree.menu();//打印字母的菜单
            while (true) {
                int ch = tree.func();//接收想要的功能
                tree.getFunction(ch,root);//实现选择的功能
            }
        }else {//选择建立数字二叉树，方法同上
            System.out.println("请输入数字：");
            String str = scanner.next();
            String[] arr = str.split(",");
            Integer[] b = new Integer[arr.length];
            for (int i = 0; i < b.length; i++) {
                if (arr[i].equals("null")){
                    b[i] = null;
                }else {
                    b[i] = Integer.parseInt(arr[i]);
                }
            }
            CreateBigHeap createBigHeap = new CreateBigHeap();
            createBigHeap.isFullTree(b); //通过该函数对确定该数组是否可以构成完全二叉树
            ConstructTree<Integer> integerConstructTree = new ConstructTree<>();
            TreeNode<Integer> root = integerConstructTree.constructTree(b); //构造一个二叉树，返回二叉树的根节点
            tree.menu();//打印数字的菜单
            while (true) {
                int ch = tree.func();//接收想要的功能
                tree.getFunction(ch,root);//实现选择的功能
            }
        }
    }
}