devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java“树结构TreeNode”用法详解，二叉树用法实现代码！！！_java treenode

作者：凡人多烦事01 | 2024-04-30 08:12:20

赞

踩

java treenode

一、TreeNode用法

在Java中，TreeNode通常用于表示树结构中的节点。在树结构中，每个节点可以有零个或多个子节点，而TreeNode就是这个树结构中的一个节点。通常，树结构是通过链式结构实现的，每个节点有指向其子节点的引用。

下面是一个简单的示例，展示了如何定义一个简单的TreeNode类以及如何使用它：

  1. // TreeNode 类表示二叉树中的一个节点
  2. class TreeNode {
  3.     int val;            // 节点的值
  4.     TreeNode left;      // 左子节点
  5.     TreeNode right;     // 右子节点
  6.  
  7.     // 构造函数
  8.     TreeNode(int x) {
  9.         val = x;
  10.     }
  11. }
  12.  
  13. public class BinaryTreeExample {
  14.     // 二叉树的根节点
  15.     private TreeNode root;
  16.  
  17.     // 构造函数
  18.     public BinaryTreeExample() {
  19.         root = null;
  20.     }
  21.  
  22.     // 插入节点
  23.     public void insert(int value) {
  24.         root = insertRec(root, value);
  25.     }
  26.  
  27.     // 递归方法插入节点
  28.     private TreeNode insertRec(TreeNode root, int value) {
  29.         // 如果树为空，则创建一个新节点作为根节点
  30.         if (root == null) {
  31.             root = new TreeNode(value);
  32.             return root;
  33.         }
  34.  
  35.         // 否则，向左或向右递归地插入节点
  36.         if (value < root.val) {
  37.             root.left = insertRec(root.left, value);
  38.         } else if (value > root.val) {
  39.             root.right = insertRec(root.right, value);
  40.         }
  41.  
  42.         // 返回根节点
  43.         return root;
  44.     }
  45.  
  46.     public static void main(String[] args) {
  47.         BinaryTreeExample tree = new BinaryTreeExample();
  48.  
  49.         // 插入节点
  50.         tree.insert(50);
  51.         tree.insert(30);
  52.         tree.insert(20);
  53.         tree.insert(40);
  54.         tree.insert(70);
  55.         tree.insert(60);
  56.         tree.insert(80);
  57.  
  58.     }
  59. }

在这个示例中，我们定义了一个 BinaryTreeExample 类来表示一个二叉排序树，其中包含了 TreeNode 类来表示二叉树的节点。我们实现了插入节点的方法 insert()。然后，在 main 方法中创建了一个二叉树实例，并插入了一些节点。

向二叉搜索树中插入节点的递归方法 insertRec()理解过程

首先，让我们假设有一个空树，然后开始向树中插入节点。我们将以插入值为50、30、20、40、70、60、80的顺序进行演示。

  1. 插入节点 50：由于树为空，因此将节点 50 插入为根节点。

    50

  2. 插入节点 30：因为根节点的值为 50，且 30 小于 50，所以我们将节点 30 插入根节点的左子树。

    1.     50
    2.    /
    3.   30

  3. 插入节点 20：因为根节点的值为 50，且 20 小于 50，所以我们继续向左子树插入节点 20小于30，则在30的左子树插入节点20。

    1.     50
    2.    /
    3.   30
    4.  /
    5. 20

  4. 插入节点 40：因为根节点的值为 50，且 40 小于 50，所以我们向50的左子树插入，40>30故在30的右子树插入节点 40。

    1.     50
    2.    /
    3.   30
    4.  / \
    5. 20  40

  5. 插入节点 70：因为根节点的值为 50，且 70 大于 50，所以我们将节点 70 插入根节点的右子树。

    1.     50
    2.    / \
    3.   30  70
    4.  / \
    5. 20  40

  6. 插入节点 60：因为根节点的值为 50，且 60 大于50小于 70，所以我们向右子树的左子树插入节点 60。

    1.     50
    2.    / \
    3.   30  70
    4.  / \ /
    5. 20 40 60

  7. 插入节点 80：因为根节点的值为 50，且 80 大于 70，所以我们继续向右子树插入节点 80。

    1.     50
    2.    / \
    3.   30  70
    4.  / \ / \
    5. 20 40 60 80

注意啊！！！树结构基本都要用到递归 ，所以一定要好好理解递归算法。

二、二叉树的先，中，后序遍历

  1. // TreeNode 类表示二叉树中的一个节点
  2. class TreeNode {
  3.     int val;            // 节点的值
  4.     TreeNode left;      // 左子节点
  5.     TreeNode right;     // 右子节点
  6.  
  7.     // 构造函数
  8.     TreeNode(int x) {
  9.         val = x;
  10.     }
  11. }
  12.  
  13. public class BinaryTreeExample {
  14.     // 二叉树的根节点
  15.     private TreeNode root;
  16.  
  17.     // 构造函数
  18.     public BinaryTreeExample() {
  19.         root = null;
  20.     }
  21.  
  22.     // 插入节点
  23.     public void insert(int value) {
  24.         root = insertRec(root, value);
  25.     }
  26.  
  27.     // 递归方法插入节点
  28.     private TreeNode insertRec(TreeNode root, int value) {
  29.         // 如果树为空，则创建一个新节点作为根节点
  30.         if (root == null) {
  31.             root = new TreeNode(value);
  32.             return root;
  33.         }
  34.  
  35.         // 否则，向左或向右递归地插入节点
  36.         if (value < root.val) {
  37.             root.left = insertRec(root.left, value);
  38.         } else if (value > root.val) {
  39.             root.right = insertRec(root.right, value);
  40.         }
  41.  
  42.         // 返回根节点
  43.         return root;
  44.     }
  45.  
  46.     // 先序遍历二叉树
  47.     public void firstorderTraversal(TreeNode root) {
  48.         if (root != null) {
  49.             System.out.print(root.val + " ");
  50.             inorderTraversal(root.left);
  51.             inorderTraversal(root.right);
  52.         }
  53.     }
  54.     // 中序遍历二叉树
  55.     public void inorderTraversal(TreeNode root) {
  56.         if (root != null) {
  57.             inorderTraversal(root.left);
  58.             System.out.print(root.val + " ");
  59.             inorderTraversal(root.right);
  60.         }
  61.     }
  62.     // 后序遍历二叉树
  63.     public void postorderTraversal(TreeNode root) {
  64.         if (root != null) {
  65.             inorderTraversal(root.left);
  66.             inorderTraversal(root.right);
  67.             System.out.print(root.val + " ");
  68.         }
  69.     }
  70.  
  71.     public static void main(String[] args) {
  72.         BinaryTreeExample tree = new BinaryTreeExample();
  73.  
  74.         // 插入节点
  75.         tree.insert(50);
  76.         tree.insert(30);
  77.         tree.insert(20);
  78.         tree.insert(40);
  79.         tree.insert(70);
  80.         tree.insert(60);
  81.         tree.insert(80);
  82.  
  83.         // 先序遍历二叉树
  84.         System.out.print("二叉树的先序遍历结果：");
  85.         tree.firstorderTraversal(tree.root);
  86.         System.out.println();
  87.         // 中序遍历二叉树
  88.         System.out.print("二叉树的中序遍历结果：");
  89.         tree.inorderTraversal(tree.root);
  90.         System.out.println();
  91.         // 后序遍历二叉树
  92.         System.out.print("二叉树的后序遍历结果：");
  93.         tree.postorderTraversal(tree.root);
  94.         System.out.println();
  95.     }
  96. }

三、二叉树层序遍历

层序遍历是一种广度优先搜索（BFS）的方法，它从根节点开始逐层遍历二叉树，先遍历完一层节点，再遍历下一层节点，直到遍历完整棵树。在层序遍历中，我们通常使用队列来辅助实现。

关于在Java中如何使用队列，待我更新一篇…… （可关注我主页，如果我忘了踢踢我~）

  1. import java.util.LinkedList;
  2. import java.util.Queue;
  3.  
  4. class TreeNode {
  5.     int val;
  6.     TreeNode left;
  7.     TreeNode right;
  8.  
  9.     // 构造函数
  10.     public TreeNode(int val) {
  11.         this.val = val;
  12.     }
  13. }
  14.  
  15. public class BinaryTreeExample {
  16.     // 二叉树的根节点
  17.     private TreeNode root;
  18.  
  19.     // 构造函数
  20.     public BinaryTreeExample() {
  21.         root = null;
  22.     }
  23.  
  24.     // 插入节点
  25.     public void insert(int value) {
  26.         root = insertRec(root, value);
  27.     }
  28.  
  29.     // 递归方法插入节点
  30.     private TreeNode insertRec(TreeNode root, int value) {
  31.         // 如果树为空，则创建一个新节点作为根节点
  32.         if (root == null) {
  33.             root = new TreeNode(value);
  34.             return root;
  35.         }
  36.  
  37.         // 否则，向左或向右递归地插入节点
  38.         if (value < root.val) {
  39.             root.left = insertRec(root.left, value);
  40.         } else if (value > root.val) {
  41.             root.right = insertRec(root.right, value);
  42.         }
  43.  
  44.         // 返回根节点
  45.         return root;
  46.     }
  47.  
  48.     // 层序遍历二叉树
  49.     public void levelOrderTraversal(TreeNode root) {
  50.         if (root == null)
  51.             return;
  52.  
  53.         // 创建一个队列用于辅助层序遍历
  54.         Queue<TreeNode> queue = new LinkedList<>();
  55.         queue.offer(root);
  56.  
  57.         while (!queue.isEmpty()) {
  58.             TreeNode node = queue.poll();
  59.             System.out.print(node.val + " ");
  60.  
  61.             if (node.left != null)
  62.                 queue.offer(node.left);
  63.             if (node.right != null)
  64.                 queue.offer(node.right);
  65.         }
  66.     }
  67.  
  68.     public static void main(String[] args) {
  69.         BinaryTreeExample tree = new BinaryTreeExample();
  70.  
  71.         // 插入节点
  72.         tree.insert(50);
  73.         tree.insert(30);
  74.         tree.insert(20);
  75.         tree.insert(40);
  76.         tree.insert(70);
  77.         tree.insert(60);
  78.         tree.insert(80);
  79.  
  80.         // 层序遍历二叉树
  81.         System.out.println("二叉树的层序遍历结果：");
  82.         tree.levelOrderTraversal(tree.root);
  83.     }
  84. }

四、根据所给遍历顺序构造二叉树

如果给出二叉树的先序遍历和中序遍历或者给出二叉树的后序遍历和中序遍历都能唯一的确定一颗二叉树，但是若是给出先序遍历和后序遍历则无法唯一的确定一颗二叉树。

以下示例是根据先序遍历和中序遍历构造的二叉树：

  1. import java.util.HashMap;
  2.  
  3. class TreeNode {
  4.     int val;
  5.     TreeNode left;
  6.     TreeNode right;
  7.  
  8.     // 构造函数
  9.     public TreeNode(int val) {
  10.         this.val = val;
  11.     }
  12. }
  13.  
  14. public class BinaryTreeBuilder {
  15.     // 构建二叉树
  16.     public TreeNode buildTree(int[] preorder, int[] inorder) {
  17.         // 使用 HashMap 存储中序遍历结果中每个节点的索引
  18.         HashMap<Integer, Integer> map = new HashMap<>();
  19.         for (int i = 0; i < inorder.length; i++) {
  20.             map.put(inorder[i], i);
  21.         }
  22.  
  23.         // 调用递归函数构建二叉树
  24.         return buildTreeHelper(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1, map);
  25.     }
  26.  
  27.     // 递归函数构建二叉树
  28.     private TreeNode buildTreeHelper(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd, HashMap<Integer, Integer> map) {
  29.         // 如果先序遍历的起始索引大于结束索引，则表示子树为空，返回 null
  30.         if (preStart > preEnd) {
  31.             return null;
  32.         }
  33.  
  34.         // 获取根节点的值
  35.         int rootVal = preorder[preStart];
  36.         TreeNode root = new TreeNode(rootVal);
  37.  
  38.         // 获取根节点在中序遍历结果中的位置
  39.         int index = map.get(rootVal);
  40.  
  41.         // 计算左子树的长度
  42.         int leftTreeSize = index - inStart;
  43.  
  44.         // 递归构建左子树和右子树
  45.         root.left = buildTreeHelper(preorder, preStart + 1, preStart + leftTreeSize, inorder, inStart, index - 1, map);
  46.         root.right = buildTreeHelper(preorder, preStart + leftTreeSize + 1, preEnd, inorder, index + 1, inEnd, map);
  47.  
  48.         return root;
  49.     }
  50.  
  51.     // 中序遍历二叉树（用于验证结果）
  52.     public void inorderTraversal(TreeNode root) {
  53.         if (root != null) {
  54.             inorderTraversal(root.left);
  55.             System.out.print(root.val + " ");
  56.             inorderTraversal(root.right);
  57.         }
  58.     }
  59.  
  60.     public static void main(String[] args) {
  61.         int[] preorder = {3, 9, 20, 15, 7};
  62.         int[] inorder = {9, 3, 15, 20, 7};
  63.  
  64.         BinaryTreeBuilder builder = new BinaryTreeBuilder();
  65.         TreeNode root = builder.buildTree(preorder, inorder);
  66.  
  67.         System.out.println("构建的二叉树中序遍历结果：");
  68.         builder.inorderTraversal(root);
  69.     }
  70. }

 以下示例是根据后序遍历和中序遍历构造的二叉树：

  1. import java.util.HashMap;
  2.  
  3. class TreeNode {
  4.     int val;
  5.     TreeNode left;
  6.     TreeNode right;
  7.  
  8.     // 构造函数
  9.     public TreeNode(int val) {
  10.         this.val = val;
  11.     }
  12. }
  13.  
  14. public class ConstructBinaryTree {
  15.     // 构造二叉树
  16.     public TreeNode buildTree(int[] inorder, int[] postorder) {
  17.         // 使用HashMap存储中序遍历结果中每个节点的索引
  18.         HashMap<Integer, Integer> map = new HashMap<>();
  19.         for (int i = 0; i < inorder.length; i++) {
  20.             map.put(inorder[i], i);
  21.         }
  22.  
  23.         // 调用递归函数构建二叉树
  24.         return buildTreeHelper(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1, map);
  25.     }
  26.  
  27.     // 递归函数构建二叉树
  28.     private TreeNode buildTreeHelper(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd, HashMap<Integer, Integer> map) {
  29.         // 如果中序遍历的起始索引大于结束索引，则表示子树为空，返回 null
  30.         if (inStart > inEnd || postStart > postEnd) {
  31.             return null;
  32.         }
  33.  
  34.         // 获取根节点的值
  35.         int rootVal = postorder[postEnd];
  36.         TreeNode root = new TreeNode(rootVal);
  37.  
  38.         // 获取根节点在中序遍历结果中的位置
  39.         int index = map.get(rootVal);
  40.  
  41.         // 递归构建左子树和右子树
  42.         root.left = buildTreeHelper(inorder, inStart, index - 1, postorder, postStart, postStart + index - inStart - 1, map);
  43.         root.right = buildTreeHelper(inorder, index + 1, inEnd, postorder, postStart + index - inStart, postEnd - 1, map);
  44.  
  45.         return root;
  46.     }
  47.  
  48.     // 中序遍历二叉树（用于验证）
  49.     public void inorderTraversal(TreeNode root) {
  50.         if (root != null) {
  51.             inorderTraversal(root.left);
  52.             System.out.print(root.val + " ");
  53.             inorderTraversal(root.right);
  54.         }
  55.     }
  56.  
  57.     public static void main(String[] args) {
  58.         ConstructBinaryTree solution = new ConstructBinaryTree();
  59.  
  60.         int[] inorder = {4, 2, 5, 1, 3};
  61.         int[] postorder = {4, 5, 2, 3, 1};
  62.  
  63.         // 构建二叉树
  64.         TreeNode root = solution.buildTree(inorder, postorder);
  65.  
  66.         // 验证中序遍历结果
  67.         System.out.println("中序遍历结果：");
  68.         solution.inorderTraversal(root);
  69.     }
  70. }

五、二叉树找某一节点的父节点

在二叉树中，要找到一个节点的父节点，需要从根节点开始向下遍历，直到找到该节点。具体方法如下：

  1. 从根节点开始，递归地向下遍历二叉树。
  2. 如果当前节点的左子节点或右子节点等于目标节点，则当前节点就是目标节点的父节点。
  3. 如果目标节点不是根节点，并且当前节点不是叶子节点，则继续递归地向下遍历左子树和右子树，直到找到目标节点。

以下是一个示例的 Java 代码，演示了如何找到二叉树中某个节点的父节点：

  1. class TreeNode {
  2.     int val;
  3.     TreeNode left;
  4.     TreeNode right;
  5.  
  6.     // 构造函数
  7.     public TreeNode(int val) {
  8.         this.val = val;
  9.     }
  10. }
  11.  
  12. public class BinaryTree {
  13.     // 找到节点的父节点
  14.     public TreeNode findParent(TreeNode root, TreeNode target) {
  15.         // 如果根节点为空或者目标节点为根节点，则返回 null
  16.         if (root == null || root == target) {
  17.             return null;
  18.         }
  19.  
  20.         // 如果目标节点是当前节点的左子节点或右子节点，则返回当前节点
  21.         if (root.left == target || root.right == target) {
  22.             return root;
  23.         }
  24.  
  25.         // 递归在左子树中寻找目标节点的父节点
  26.         TreeNode leftParent = findParent(root.left, target);
  27.         // 如果在左子树中找到了，则直接返回结果
  28.         if (leftParent != null) {
  29.             return leftParent;
  30.         }
  31.  
  32.         // 递归在右子树中寻找目标节点的父节点
  33.         TreeNode rightParent = findParent(root.right, target);
  34.         // 如果在右子树中找到了，则直接返回结果
  35.         if (rightParent != null) {
  36.             return rightParent;
  37.         }
  38.  
  39.         // 如果左右子树都没有找到，则返回 null
  40.         return null;
  41.     }
  42.  
  43.     public static void main(String[] args) {
  44.         BinaryTree tree = new BinaryTree();
  45.  
  46.         // 构建二叉树
  47.         TreeNode root = new TreeNode(1);
  48.         root.left = new TreeNode(2);
  49.         root.right = new TreeNode(3);
  50.         root.left.left = new TreeNode(4);
  51.         root.left.right = new TreeNode(5);
  52.         root.right.left = new TreeNode(6);
  53.         root.right.right = new TreeNode(7);
  54.  
  55.         // 找到目标节点
  56.         TreeNode target = root.left.right;
  57.  
  58.         // 找到目标节点的父节点
  59.         TreeNode parent = tree.findParent(root, target);
  60.  
  61.         if (parent != null) {
  62.             System.out.println("节点 " + target.val + " 的父节点是 " + parent.val);
  63.         } else {
  64.             System.out.println("节点 " + target.val + " 没有父节点");
  65.         }
  66.     }
  67. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/512335?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号