完成二叉树的算法，补充完整，菜单如下： printf("\n 1. 建立二叉树方法1 "); printf("\n 2. 建立二叉树方法2"); printf("\n 3. 中序递归遍历二叉树"); printf("\n 4. 计算树中结点个数"); printf("\n 5. 先序递归遍历二叉树"); printf("\n 6. 后序递归遍历二叉树"); printf("\n 7. 结束程序运行");使用Java语言

以下是完整的二叉树算法代码：

import java.util.Scanner;

class Node {
    int data;
    Node left;
    Node right;

    Node(int data) {
        this.data = data;
        left = null;
        right = null;
    }
}

public class BinaryTree {
    Node root;

    BinaryTree() {
        root = null;
    }

    // 建立二叉树方法1
    void createTree1() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入节点值（-1表示空节点）：");
        int value = scanner.nextInt();
        if (value == -1) {
            root = null;
        } else {
            root = new Node(value);
            createTree1(root);
        }
    }

    // 递归建立二叉树
    void createTree1(Node node) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入" + node.data + "的左子节点值（-1表示空节点）：");
        int value = scanner.nextInt();
        if (value == -1) {
            node.left = null;
        } else {
            node.left = new Node(value);
            createTree1(node.left);
        }

        System.out.print("请输入" + node.data + "的右子节点值（-1表示空节点）：");
        value = scanner.nextInt();
        if (value == -1) {
            node.right = null;
        } else {
            node.right = new Node(value);
            createTree1(node.right);
        }
    }

    // 建立二叉树方法2
    void createTree2() {
        root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);
    }

    // 中序递归遍历二叉树
    void inorderTraversal(Node node) {
        if (node != null) {
            inorderTraversal(node.left);
            System.out.print(node.data + " ");
            inorderTraversal(node.right);
        }
    }

    // 计算树中结点个数
    int countNodes(Node node) {
        if (node == null) {
            return 0;
        } else {
            return countNodes(node.left) + countNodes(node.right) + 1;
        }
    }

    // 先序递归遍历二叉树
    void preorderTraversal(Node node) {
        if (node != null) {
            System.out.print(node.data + " ");
            preorderTraversal(node.left);
            preorderTraversal(node.right);
        }
    }

    // 后序递归遍历二叉树
    void postorderTraversal(Node node) {
        if (node != null) {
            postorderTraversal(node.left);
            postorderTraversal(node.right);
            System.out.print(node.data + " ");
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        BinaryTree binaryTree = new BinaryTree();

        while (true) {
            System.out.println("\n请选择操作：");
            System.out.println("1. 建立二叉树方法1");
            System.out.println("2. 建立二叉树方法2");
            System.out.println("3. 中序递归遍历二叉树");
            System.out.println("4. 计算树中结点个数");
            System.out.println("5. 先序递归遍历二叉树");
            System.out.println("6. 后序递归遍历二叉树");
            System.out.println("7. 结束程序运行");

            int choice = scanner.nextInt();
            switch (choice) {
                case 1:
                    binaryTree.createTree1();
                    break;
                case 2:
                    binaryTree.createTree2();
                    break;
                case 3:
                    System.out.print("中序遍历结果：");
                    binaryTree.inorderTraversal(binaryTree.root);
                    break;
                case 4:
                    int count = binaryTree.countNodes(binaryTree.root);
                    System.out.println("树中结点个数为：" + count);
                    break;
                case 5:
                    System.out.print("先序遍历结果：");
                    binaryTree.preorderTraversal(binaryTree.root);
                    break;
                case 6:
                    System.out.print("后序遍历结果：");
                    binaryTree.postorderTraversal(binaryTree.root);
                    break;
                case 7:
                    System.exit(0);
                default:
                    System.out.println("输入错误，请重新输入");
                    break;
            }
        }
    }
}