用JAVA面向对象的思维的来定义一个二叉树类，通过键盘输入生成二叉树，并编写方法实现对二叉树节点的遍历输出。（迭代2.0版，可以添加树的节点和删除树的节点）

想养一个月亮，

于 2021-10-19 10:11:39 发布

阅读量276

点赞数

文章标签： java 数据结构算法

本文链接：https://blog.csdn.net/qq_51746339/article/details/120839864

版权

与第一代一致，先是构建二叉树以及实现三种遍历的函数，采用左小右大的方法。（这里默认大家比较了解有序二叉树了哈）

 class BinaryTree {
    Node root;    //根节点
    public void addNode(double value){
        Node newNode = new Node(value);
        if(root == null){
        root = newNode;
        }
        else{
            Node temp = root;
            while(temp!=null){
                if(value<=temp.data){
                    if(temp.left==null){
                        temp.left = newNode;
                        return;
                    }else
                        temp = temp.left;
                }else{
                    if(temp.right==null){
                        temp.right = newNode;
                        return;
                    }else
                        temp = temp.right;
                }
            }
        }
    }
    /**
     *
     * @param root
     */
    //中序遍历
    public void midprint(Node root){
        if(root!=null){
        midprint(root.left);
        System.out.print(root.data + " ");
        midprint(root.right);
        }
    }
    //后序遍历
    public void posprint(Node root){
        if(root!=null){
        posprint(root.left);
        posprint(root.right);
        System.out.print(root.data + " ");
        }
    }  
    //前序遍历
    public void preprint(Node root){
        if(root!=null){
        System.out.print(root.data + " ");
        preprint(root.left);
        preprint(root.right);
        }
    }    
}

然后是创建一个节点的结构。

class Node{
    double data;      //当前节点数值
    Node left;        //左孩子
    Node right;       //右孩子
    
    public Node(double data){  //一个有参构造器
    this.left = null;
    this.right = null;
    this.data = data;
    }
}

我的这个构建树思路是通过数组来构建二叉树，所以对树相应节点增删可以转变为对数组对应数据的增删。那么接下来我们进行一些准备工作：

1.对数组进行增加；

    //增添数组
    public double[] arradd(double arr[],double m){
        double arr2[] = new double[arr.length + 1];
        System.arraycopy(arr, 0, arr2, 0, arr.length);
        arr2[arr2.length - 1] = m;
        arr = arr2; 
        return arr;
    }

2.对数组进行删除；（这里面的tt.OOA是我提前准备小工具，主要判断数组里是否还有所要删减的数）

   //减少数组
    public double[] arrcut(double arr[],double m){
        TT tt = new TT();
        while(tt.OOA(arr, m)){
            double arr2[] = new double[arr.length - 1];
            int t = -1;
                for(int i=0;i<arr.length;i++){
                    if(arr[i]==m){
                    t = i;
                    }
                }
            System.arraycopy(arr, 0, arr2, 0, t);
                for(int i=t+1;i<arr.length;i++){
                    arr2[i-1]=arr[i];
                }
                arr = arr2;
        }
        return arr;
    }

小工具代码如下。

class TT{
    //判断数组中是否有与输入数相等的
    public boolean OOA(double arr[],double m){
     for(int i=0;i<arr.length;i++){
         if(arr[i]==m){
             return true;
         }
     }
     return false;
    }
}

3.由于我打算每插入一个数都想要输出一下新的数组和构成的二叉树以及三种遍历。所以把这两个写成两个类直接调用就可以，提高代码的复用性。

    //把数组生成为二叉树，并实现三种遍历
    public void print_1(double c[]){
        BinaryTree bb = new BinaryTree();
        for(int j = 0; j<c.length;j++) {
            bb.addNode(c[j]);  
        }
        System.out.print("前序遍历：");
        bb.preprint(bb.root);
        System.out.println();
        System.out.print("中序遍历：");
        bb.midprint(bb.root);
        System.out.println();
        System.out.print("后序遍历：");
        bb.posprint(bb.root);
    }
    //打印数组
    public void print_2(double c[]){
    for(int i =0; i<c.length;i++){
        System.out.print(c[i] + "\t");
    }       System.out.println("\n");
    }

这里把这两个打印分成两个类，主要想着我们第一次手动键入一个数组时，不需要打印，如果合并了，打印二叉树时，必须打印下数组不是太合适，当然咯，这是个人想法，大家合并也可以。

最终就是主函数了！

    public static void main(String[] args) {
        // TODO code application logic here
        BinaryTree b = new BinaryTree();
        arrchange  mm = new arrchange();
        System.out.println("请输入几个数并用逗号隔开（英文输入法的逗号哦！ 形如：5，3，6，...）：");
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        String[] arr  = str.split(",");
        double[] c = new double[arr.length];
        for(int j = 0; j<c.length;j++) {
         c[j] = Integer.parseInt(arr[j]);
        }
        //生成二叉树并实现三种遍历
        mm.print_1(c);
        
        for(;;){
            Scanner myScanner = new Scanner(System.in);	
            System.out.println("\n"+"是否添加或删减二叉树内容 (增添请按:a  删除请按：c  退出请按任意键)");
            char c1 = myScanner.next().charAt(0);
            switch (c1) {
                case 'a':
                    {
                        System.out.println("请输入需要增加的数(只能是一个数字哦)");
                        double temp = myScanner.nextDouble();
                        c=mm.arradd(c, temp);
                        System.out.println("增加后最新数组如下哦");
                        mm.print_2(c);
                        mm.print_1(c);
                        break;
                    }
                case 'c':
                    {
                        System.out.println("请输入需要减少的数(只能是一个数字哦)");
                        double temp = myScanner.nextDouble();
                        c=mm.arrcut(c, temp);
                        System.out.println("减少后最新数组如下哦");
                        mm.print_2(c);
                        mm.print_1(c);
                        break;
                    }
                default:
                    System.out.println("最终数组如下哦");
                    mm.print_2(c);
                    mm.print_1(c);
                    return;
            }
        }  
    }

以上就是添加了删除和增加二叉树节点功能的2.0版代码辣。对了还有哈，比起1.0版，2.0版把输入的数字由int型改成了double型。

觉得看着麻烦，下面是完整合好的，复制粘贴用就行。

第一个类

package twotree;
import java.util.Scanner;
/**
 *
 * @author xyc
 */
public class Twotree {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        BinaryTree b = new BinaryTree();
        arrchange  mm = new arrchange();
        System.out.println("请输入几个数并用逗号隔开（英文输入法的逗号哦！ 形如：5，3，6，...）：");
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        String[] arr  = str.split(",");
        double[] c = new double[arr.length];
        for(int j = 0; j<c.length;j++) {
         c[j] = Integer.parseInt(arr[j]);
        }
        //生成二叉树并实现三种遍历
        mm.print_1(c);
        
        for(;;){
            Scanner myScanner = new Scanner(System.in);	
            System.out.println("\n"+"是否添加或删减二叉树内容 (增添请按:a  删除请按：c  退出请按任意键)");
            char c1 = myScanner.next().charAt(0);
            switch (c1) {
                case 'a':
                    {
                        System.out.println("请输入需要增加的数(只能是一个数字哦)");
                        double temp = myScanner.nextDouble();
                        c=mm.arradd(c, temp);
                        System.out.println("增加后最新数组如下哦");
                        mm.print_2(c);
                        mm.print_1(c);
                        break;
                    }
                case 'c':
                    {
                        System.out.println("请输入需要减少的数(只能是一个数字哦)");
                        double temp = myScanner.nextDouble();
                        c=mm.arrcut(c, temp);
                        System.out.println("减少后最新数组如下哦");
                        mm.print_2(c);
                        mm.print_1(c);
                        break;
                    }
                default:
                    System.out.println("最终数组如下哦");
                    mm.print_2(c);
                    mm.print_1(c);
                    return;
            }
        }  
    }
}
 class BinaryTree {
    Node root;    //根节点
    public void addNode(double value){
        Node newNode = new Node(value);
        if(root == null){
        root = newNode;
        }
        else{
            Node temp = root;
            while(temp!=null){
                if(value<=temp.data){
                    if(temp.left==null){
                        temp.left = newNode;
                        return;
                    }else
                        temp = temp.left;
                }else{
                    if(temp.right==null){
                        temp.right = newNode;
                        return;
                    }else
                        temp = temp.right;
                }
            }
        }
    }
    /**
     *
     * @param root
     */
    //中序遍历
    public void midprint(Node root){
        if(root!=null){
        midprint(root.left);
        System.out.print(root.data + " ");
        midprint(root.right);
        }
    }
    //后序遍历
    public void posprint(Node root){
        if(root!=null){
        posprint(root.left);
        posprint(root.right);
        System.out.print(root.data + " ");
        }
    }  
    //前序遍历
    public void preprint(Node root){
        if(root!=null){
        System.out.print(root.data + " ");
        preprint(root.left);
        preprint(root.right);
        }
    }    
}
class Node{
    double data;      //当前节点数值
    Node left;        //左孩子
    Node right;       //右孩子
    
    public Node(double data){  //一个有参构造器
    this.left = null;
    this.right = null;
    this.data = data;
    }
}

第二个类

public class arrchange {
    //增添数组
    public double[] arradd(double arr[],double m){
        double arr2[] = new double[arr.length + 1];
        System.arraycopy(arr, 0, arr2, 0, arr.length);
        arr2[arr2.length - 1] = m;
        arr = arr2; 
        return arr;
    }
   //减少数组
    public double[] arrcut(double arr[],double m){
        TT tt = new TT();
        while(tt.OOA(arr, m)){
            double arr2[] = new double[arr.length - 1];
            int t = -1;
                for(int i=0;i<arr.length;i++){
                    if(arr[i]==m){
                    t = i;
                    }
                }
            System.arraycopy(arr, 0, arr2, 0, t);
                for(int i=t+1;i<arr.length;i++){
                    arr2[i-1]=arr[i];
                }
                arr = arr2;
        }
        return arr;
    } 
    //把数组生成为二叉树，并实现三种遍历
    public void print_1(double c[]){
        BinaryTree bb = new BinaryTree();
        for(int j = 0; j<c.length;j++) {
            bb.addNode(c[j]);  
        }
        System.out.print("前序遍历：");
        bb.preprint(bb.root);
        System.out.println();
        System.out.print("中序遍历：");
        bb.midprint(bb.root);
        System.out.println();
        System.out.print("后序遍历：");
        bb.posprint(bb.root);
    }
    //打印数组
    public void print_2(double c[]){
    for(int i =0; i<c.length;i++){
        System.out.print(c[i] + "\t");
    }
    }
}
class TT{
    //判断数组中是否有与输入数相等的
    public boolean OOA(double arr[],double m){
     for(int i=0;i<arr.length;i++){
         if(arr[i]==m){
             return true;
         }
     }
     return false;
    }
}

运行的结果如下：

最后想说，笔者也是刚学java，对于一些知识也不太懂，讲的不对或不准确的地方欢迎大家指正哈。