java二叉树操作_在一棵二叉链表表示的二叉树中,实现以下操作,并说明采用哪种遍历算法,其他遍历算-优快云博客

文章描述了在二叉链表表示的二叉树中执行一系列操作，包括输入叶子结点、计算叶节点数、交换子树、验证性质、遍历方式（先根、中根、后根）、构造二叉树、层次查找、复制树、判断完全二叉树及非递归后根遍历，同时涉及线索二叉树的插入和删除操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在一棵二叉链表表示的二叉树中，实现以下操作，并说明采用哪种遍历算法，其他遍历算法是否可行.
1输入叶子结点。
2求二叉树中叶子结点个数。
3将每个结点的左子树与右子树交换。
4验证二叉树的性质3：N0=N2+1。
5输出值大于k的结点.
6已知先根和中根次序遍历序列构造二叉树。
7以广义表表示构造二叉树。
8判断两颗二叉树是否相等。
9求结点所在的层次。
10 向求一颗二叉树在后根次序遍历下第一个访问的结点。
11复制一颗二叉树。
12判断一颗二叉树是否为完全二叉树。
13 实现二叉树后根次序遍历的非递归算法。
在这里插入图片描述
Q1.java

import java.util.*;

/**
 * 在一棵二叉链表表示的二叉树中，实现以下操作，并说明采用哪种遍历算法，其他遍历算法是否可行.
 * 1输入叶子结点。
 * 2求二叉树中叶子结点个数。
 * 3将每个结点的左子树与右子树交换。
 * 4验证二叉树的性质：N0=N2+1。
 * 5输出值大于k的结点.
 * 6已知先根和中根次序遍历序列构造二叉树。
 * 7以广义表表示构造二叉树。
 * 8判断两颗二叉树是否相等。
 * 9求结点所在的层次。
 * 10求一颗二叉树在后根次序遍历下第一个访问的结点。
 * 11复制一颗二叉树。
 * 12判断一颗二叉树是否为完全二叉树。
 * 13实现二叉树后根次序遍历的非递归算法 。
 */

public class Q1 {
    public static void main(String[] args) {
        BinaryTreeNode root = new BinaryTreeNode(1);
        BinaryTreeNode node2 = new BinaryTreeNode(2);
        BinaryTreeNode node3 = new BinaryTreeNode(3);
        BinaryTreeNode node4 = new BinaryTreeNode(4);
        BinaryTreeNode node5 = new BinaryTreeNode(5);

        // 1 输入叶子结点。
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);

        System.out.println(root);

        // 2 求二叉树中叶子结点个数
        System.out.println("2 求二叉树中叶子结点个数");
        int leafCount = root.countLeaves();
        System.out.println("叶子节点个数：" + leafCount);

        // 3 将每个结点的左子树与右子树交换
        System.out.println("3 将每个结点的左子树与右子树交换");
        System.out.println("交换前的二叉树：");
        System.out.println(root);

        root.swapLeftAndRight();

        System.out.println("交换后的二叉树：");
        System.out.println(root);

        // 4 验证二叉树的性质：N0=N2+1 节点总数等于叶子节点数加一 使用递归方法遍历, 可以使用其他方法遍历
        System.out.println("4 验证二叉树的性质");
        System.out.println(root);
        boolean isValid = root.validateProperty();
        System.out.println("二叉树的性质是否成立：" + isValid);

        // 5 输出值大于k的结点
        System.out.println("5 输出值大于k的结点");
        int k = 3;
        List<Integer> nodesGreaterThanK = root.findNodesGreaterThanK(k);
        System.out.println("值大于 " + k + " 的节点：");
        for (int value : nodesGreaterThanK) {
            System.out.println(value);
        }

        // 6 已知先根和中根次序遍历序列构造二叉树
        System.out.println("\n6 已知先根和中根次序遍历序列构造二叉树");
        BinaryTreeNode binaryTree = new BinaryTreeNode();

        int[] preOrder = {1, 2, 4, 5, 3};
        int[] inOrder = {4, 2, 5, 1, 3};

        BinaryTreeNode.Node root_new = binaryTree.buildTreeFromTraversal(preOrder, inOrder);
        System.out.println("preOrder: "+ Arrays.toString(preOrder));
        System.out.println("inOrder: "+ Arrays.toString(inOrder));
        binaryTree.root = root_new;
        System.out.println(binaryTree.toString2());

        // 7 以广义表表示构造二叉树
        System.out.println("7 以广义表表示构造二叉树");
        BinaryTreeNode binaryTree1 = new BinaryTreeNode();

        List<Object> generalizedList = new ArrayList<>();
        generalizedList.add(1);
        generalizedList.add("(");
        generalizedList.add(2);
        generalizedList.add(4);
        generalizedList.add("(");
        generalizedList.add(5);
        generalizedList.add(")");
        generalizedList.add(")");
        generalizedList.add(3);

        BinaryTreeNode.Node root_new2 = binaryTree1.constructTreeFromGeneralizedList(generalizedList);
        System.out.println("广义表为: " + generalizedList.toString());
        binaryTree1.root = root_new2;
        System.out.println(binaryTree1.toString2());

        // 9 求结点所在的层次
        System.out.println("9 求结点所在的层次");
        int level = binaryTree1.getLevel(5);
        System.out.println("二叉树如下:\n" + binaryTree1.toString2());
        System.out.println("Node 5 is at level: " + level);

        // 10 求一颗二叉树在后根次序遍历下第一个访问的结点
        // 在后根次序遍历（也称为后序遍历）中，第一个被访问的节点是树的根节点的左右子树都被遍历完毕后，即最后一个被访问的节点。
        System.out.println("10 求一颗二叉树在后根次序遍历下第一个访问的结点");
        System.out.println("二叉树如下:\n" + binaryTree1.toString2());
        int firstVisitedNode = binaryTree1.firstVisitedNode();
        System.out.println("First visited node in postorder traversal: " + firstVisitedNode);


        // 11 复制一颗二叉树
        System.out.println("11 复制一颗二叉树");
        BinaryTreeNode binaryTree11 = new BinaryTreeNode();
        binaryTree11.insert(1);
        binaryTree11.insert(2);
        binaryTree11.insert(3);
        binaryTree11.insert(4);
        binaryTree11.insert(5);

        BinaryTreeNode copiedTree = binaryTree11.copy();

        // 在原始二叉树上进行修改
        System.out.println("在原始二叉树上insert 6");
        binaryTree11.insert(6);

        System.out.println("Original Tree:");
        System.out.println(binaryTree11.toString2());

        System.out.println("Copied Tree:");
        System.out.println(copiedTree.toString2());
        System.out.println("可以看到，修改原始二叉树不会影响复制的二叉树");

        // 12 判断一颗二叉树是否为完全二叉树 层次遍历
        System.out.println("12 判断一颗二叉树是否为完全二叉树");
        System.out.println("Original Tree:");
        System.out.println(binaryTree11.toString2());
        boolean isComplete = binaryTree11.isCompleteBinaryTree();
        System.out.println("Is complete binary tree? " + isComplete);

        System.out.println("\n\nCopied Tree:");
        System.out.println(copiedTree.toString2());
        boolean isComplete2 = copiedTree.isCompleteBinaryTree();
        System.out.println("Is complete binary tree? " + isComplete2);


        // 13 实现二叉树后根次序遍历的非递归算法
        System.out.println("\n13 实现二叉树后根次序遍历的非递归算法");
        System.out.println("Original Tree:");
        System.out.println(binaryTree11.toString2());
        System.out.println("Postorder Traversal:");
        binaryTree11.postorderTraversal();
    }

}

Q2.java

import java.util.List;

/**
 * 声明三叉链表表示的二叉树类，实现二叉树的基本操作以及以下操作。
 * 1构造1颗三叉链表表示的二叉树。
 * 2返回指定结点的父母结点。
 * 3返回指定结点的所有祖先结点。
 * 4返回两结点最近的共同祖先结点。
 */
public class Q2 {
    public static void main(String[] args) {
        // 1 构造一颗三叉链表表示的二叉树
        System.out.println("1 构造一颗三叉链表表示的二叉树");
        TernaryTree ternaryTree = new TernaryTree();
        int[] values = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        ternaryTree.construct(values);
        System.out.println(ternaryTree);


        TernaryTree.Node node1 = ternaryTree.root.left.left;   // 节点4
        TernaryTree.Node node2 = ternaryTree.root.right.right; // 节点9

        // 2 返回指定结点的父母结点
        System.out.println("2 返回指定结点的父母结点");
        TernaryTree.Node parent = ternaryTree.getParent(node1);
        System.out.println("Parent of node 4: " + (parent != null ? parent.data : "null"));

        // 3 返回指定结点的所有祖先结点
        System.out.println("3 返回指定结点的所有祖先结点");
        List<TernaryTree.Node> ancestors = ternaryTree.getAncestors(node2);
        System.out.print("Ancestors of node 9: ");
        for (TernaryTree.Node ancestor : ancestors) {
            System.out.print(ancestor.data + " ");
        }
        System.out.println();

        // 4 返回两结点最近的共同祖先结点
        System.out.println("4 返回两结点最近的共同祖先结点");
        TernaryTree.Node lowestCommonAncestor = ternaryTree.getLowestCommonAncestor(node1, node2);
        System.out.println("Lowest common ancestor of node 4 and node 9: " + (lowestCommonAncestor != null ? lowestCommonAncestor.data : "null"));

    }
}

Q3.java


/**
 * 在一颗中序线索二叉树中，实现以下操作。
 * 1调用求结点的前驱结点算法，按中根次序遍历中序线索二叉树
 * 2按后根次序遍历中序线索二叉树。
 * 3在构造二叉树时进行线索化。
 * 4插入、删除操作。
 */
public class Q3 {
    public static void main(String[] args) {
        ThreadedBinaryTree tree1 = new ThreadedBinaryTree();
        int[] values = {4, 2, 6, 1, 3, 5, 7};
        tree1.constructThreadedBinaryTree(values);

        System.out.println("1 调用求结点的前驱结点算法，按中根次序遍历中序线索二叉树");
        System.out.print("遍历结果如下: ");
        tree1.threadedInorderTraversal();
        System.out.println("\n");
        // 2 按后根次序遍历中序线索二叉树
        ThreadedBinaryTree tree = new ThreadedBinaryTree();
        // 构建二叉树
        tree.insert(1);
        tree.insert(2);
        tree.insert(3);
        tree.insert(4);
        tree.insert(5);
        // 后根次序遍历输出
        System.out.println("2 按后根次序遍历中序线索二叉树");
        System.out.print("遍历结果如下: ");
        tree.threadedPostorderTraversal();
        System.out.println("");


        // 4 插入
        tree.threadedInorderTraversal();
        System.out.println("\n4 树插入 9");
        tree.insert(9);
        System.out.print("遍历结果如下: ");
        tree.threadedPostorderTraversal();
        System.out.println("\n4 树删除 9");
        tree.delete(9);
        System.out.print("遍历结果如下: ");
        tree.threadedPostorderTraversal();

    }
}