• 二叉搜索树的构建以及遍历

    前言

            二叉查找树（Binary Search Tree），又称为二叉搜索树，二叉排序树。它或者是一棵空树，或者是具有下列性质的二叉树：

    • 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
    • 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
    • 它的左、右子树也分别为二叉排序树。

            二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。

            以下面这个二叉搜索树为例，来看一下二叉搜索树的构建以及它的几种遍历方法：

    定义一个树的节点类

    1. class TreeNode{
    2.     public int val;
    3.     public TreeNode left;
    4.     public TreeNode right;
    5.  
    6.  
    7.     public TreeNode(int val) {
    8.         this.val = val;
    9.     }
    10.  
    11.     public TreeNode(int val, TreeNode left, TreeNode right) {
    12.         this.val = val;
    13.         this.left = left;
    14.         this.right = right;
    15.     }
    16. }

    1、二叉搜索树的构建

    1.     public void buildTree(TreeNode node, int data){
    2.         //如果根节点为空，则设置根节点，并设置值
    3.         if(root == null){
    4.             root = new TreeNode(data);
    5.         }else{
    6.             //根节点不为空，判断data是否小于当前节点的值。
    7.             if(data < node.val){
    8.                 //data小于当前节点的值，判断当前节点有没有左子节点。
    9.                 if(node.left == null){
    10.                     //当前节点的左子节点为空，则添加左子节点
    11.                     node.left = new TreeNode(data);
    12.                 }else{
    13.                     //当前节点的左子节点不为空，递归调用buildTree()
    14.                     buildTree(node.left, data);
    15.                 }
    16.             }else{
    17.                 //data大于等于当前节点的值，判断当前节点有没有右子节点。
    18.                 if(node.right == null){
    19.                     //当前节点的右子节点为空，则添加右子节点
    20.                     node.right = new TreeNode(data);
    21.                 }else{
    22.                     //当前节点的右子节点不为空，递归调用buildTree()
    23.                     buildTree(node.right, data);
    24.                 }
    25.             }
    26.         }
    27.     }

    2、二叉搜索树的前序遍历

    1.     public void preOrder(TreeNode root){
    2.         //根节点为空，直接返回
    3.         if(root == null){
    4.             return;
    5.         }
    6.         //辅助栈
    7.         Stack stack = new Stack<>();
    8.         //根节点入栈
    9.         stack.push(root);
    10.         //当栈不为空
    11.         while(!stack.isEmpty()){
    12.             //取出栈顶元素
    13.             TreeNode node = stack.pop();
    14.             //打印根节点
    15.             System.out.print(node.val + "\t");
    16.             //如果使用的是辅助栈，则先将根节点的右子节点入栈；如果是辅助队列，则先将根节点的左子节点入队列。因为栈是先进后出，队列是先进入先出
    17.             if(node.right != null){
    18.                 stack.push(node.right);
    19.             }
    20.             if(node.left != null){
    21.                 stack.push(node.left);
    22.             }
    23.         }
    24.     }

    3、二叉搜索树的中序遍历

    1.     public void inOrder(TreeNode root){
    2.         // 如果根节点为空，直接返回。
    3.         if(root == null){
    4.             return;
    5.         }
    6.         // 辅助栈
    7.         Stack stack = new Stack<>();
    8.         //临时指针
    9.         TreeNode cur = root;
    10.         //当指针不为空或栈不为空
    11.         while(cur != null || !stack.isEmpty()){
    12.             //先将左节点入栈
    13.             while(cur != null){
    14.                 stack.push(cur);
    15.                 cur = cur.left;
    16.             }
    17.             //取出栈顶元素
    18.             TreeNode node = stack.pop();
    19.             //打印
    20.             System.out.print(node.val + "\t");
    21.             //指向右节点
    22.             cur = node.right;
    23.         }
    24.     }

    4、二叉搜索树的后序遍历

    1.     public void postOrder(TreeNode root){
    2.         //根节点为空，直接返回
    3.         if(root == null){
    4.             return;
    5.         }
    6.         //辅助栈
    7.         Stack stack = new Stack<>();
    8.         TreeNode cur = root, pre = null;
    9.         while(cur != null || !stack.isEmpty()){
    10.             //找到最左边节点
    11.             while(cur != null){
    12.                 stack.push(cur);
    13.                 cur = cur.left;
    14.             }
    15.             //栈顶元素出栈
    16.             cur = stack.pop();
    17.             //如果节点的右节点为空或者已经被访问过
    18.             if(cur.right == null || pre == cur.right){
    19.                 System.out.print(cur.val + "\t");
    20.                 //pre表示当前节点被访问过
    21.                 pre = cur;
    22.                 cur = null;
    23.             }else{
    24.                 //节点入栈
    25.                 stack.push(cur);
    26.                 //访问右边
    27.                 cur = cur.right;
    28.             }
    29.         }
    30.     }

    5、二叉搜索树的层序遍历

    1.     public void levelOrder(TreeNode root){
    2.         //根节点为空，直接返回
    3.         if(root == null){
    4.             return;
    5.         }
    6.         //辅助队列
    7.         Queue queue = new LinkedList<>();
    8.         //根节点入队
    9.         queue.offer(root);
    10.         while(!queue.isEmpty()){
    11.             //获取队首元素
    12.             TreeNode node = queue.poll();
    13.             System.out.print(node.val + "\t");
    14.             //左右节点分别入队
    15.             if(node.left != null){
    16.                 queue.offer(node.left);
    17.             }
    18.             if(node.right != null){
    19.                 queue.offer(node.right);
    20.             }
    21.         }
    22.     }

    6、二叉搜索树的之字形遍历 

    1.     public void sweepOrder(TreeNode root){
    2.         //根节点为空，直接返回
    3.         if(root == null){
    4.             return;
    5.         }
    6.         //存储结果
    7.         List> result = new ArrayList<>();
    8.         //辅助队列
    9.         Queue queue = new LinkedList<>();
    10.         //根节点入队
    11.         queue.offer(root);
    12.         //是否转向
    13.         boolean flag = false;
    14.         while(!queue.isEmpty()){
    15.             //获取队列长度
    16.             int size = queue.size();
    17.             //存储每一层的遍历结果
    18.             ArrayList list = new ArrayList<>();
    19.             for(int i=0; i < size; i++){
    20.                 //取出队列元素
    21.                 TreeNode node = queue.poll();
    22.                 if(node == null){
    23.                     continue;
    24.                 }
    25.                 if(!flag){
    26.                     list.add(node.val);
    27.                 }else{
    28.                     list.add(0, node.val);
    29.                 }
    30.                 //左右节点各入队
    31.                 queue.offer(node.left);
    32.                 queue.offer(node.right);
    33.             }
    34.             //如果有值，存入结果集
    35.             if(list.size() > 0){
    36.                 result.add(list);
    37.             }
    38.             //转向
    39.             flag = !flag;
    40.         }
    41.         System.out.println(result);
    42.     }

    完整代码如下：

    1. import java.util.*;
    2.  
    3. class TreeNode{
    4.     public int val;
    5.     public TreeNode left;
    6.     public TreeNode right;
    7.  
    8.  
    9.     public TreeNode(int val) {
    10.         this.val = val;
    11.     }
    12.  
    13.     public TreeNode(int val, TreeNode left, TreeNode right) {
    14.         this.val = val;
    15.         this.left = left;
    16.         this.right = right;
    17.     }
    18. }
    19.  
    20. public class BinaryTree {
    21.     public TreeNode root;
    22.     public void buildTree(TreeNode node, int data){
    23.         //如果根节点为空，则设置根节点，并设置值
    24.         if(root == null){
    25.             root = new TreeNode(data);
    26.         }else{
    27.             //根节点不为空，判断data是否小于当前节点的值。
    28.             if(data < node.val){
    29.                 //data小于当前节点的值，判断当前节点有没有左子节点。
    30.                 if(node.left == null){
    31.                     //当前节点的左子节点为空，则添加左子节点
    32.                     node.left = new TreeNode(data);
    33.                 }else{
    34.                     //当前节点的左子节点不为空，递归调用buildTree()
    35.                     buildTree(node.left, data);
    36.                 }
    37.             }else{
    38.                 //data大于等于当前节点的值，判断当前节点有没有右子节点。
    39.                 if(node.right == null){
    40.                     //当前节点的右子节点为空，则添加右子节点
    41.                     node.right = new TreeNode(data);
    42.                 }else{
    43.                     //当前节点的右子节点不为空，递归调用buildTree()
    44.                     buildTree(node.right, data);
    45.                 }
    46.             }
    47.         }
    48.     }
    49.     public void preOrder(TreeNode root){
    50.         //根节点为空，直接返回
    51.         if(root == null){
    52.             return;
    53.         }
    54.         //辅助栈
    55.         Stack stack = new Stack<>();
    56.         //根节点入栈
    57.         stack.push(root);
    58.         //当栈不为空
    59.         while(!stack.isEmpty()){
    60.             //取出栈顶元素
    61.             TreeNode node = stack.pop();
    62.             //打印根节点
    63.             System.out.print(node.val + "\t");
    64.             //如果使用的是辅助栈，则先将根节点的右子节点入栈；如果是辅助队列，则先将根节点的左子节点入队列。因为栈是先进后出，队列是先进入先出
    65.             if(node.right != null){
    66.                 stack.push(node.right);
    67.             }
    68.             if(node.left != null){
    69.                 stack.push(node.left);
    70.             }
    71.         }
    72.     }
    73.     public void inOrder(TreeNode root){
    74.         // 如果根节点为空，直接返回。
    75.         if(root == null){
    76.             return;
    77.         }
    78.         // 辅助栈
    79.         Stack stack = new Stack<>();
    80.         //临时指针
    81.         TreeNode cur = root;
    82.         //当指针不为空或栈不为空
    83.         while(cur != null || !stack.isEmpty()){
    84.             //先将左节点入栈
    85.             while(cur != null){
    86.                 stack.push(cur);
    87.                 cur = cur.left;
    88.             }
    89.             //取出栈顶元素
    90.             TreeNode node = stack.pop();
    91.             //打印
    92.             System.out.print(node.val + "\t");
    93.             //指向右节点
    94.             cur = node.right;
    95.         }
    96.     }
    97.     public void postOrder(TreeNode root){
    98.         //根节点为空，直接返回
    99.         if(root == null){
    100.             return;
    101.         }
    102.         //辅助栈
    103.         Stack stack = new Stack<>();
    104.         TreeNode cur = root, pre = null;
    105.         while(cur != null || !stack.isEmpty()){
    106.             //找到最左边节点
    107.             while(cur != null){
    108.                 stack.push(cur);
    109.                 cur = cur.left;
    110.             }
    111.             //栈顶元素出栈
    112.             cur = stack.pop();
    113.             //如果节点的右节点为空或者已经被访问过
    114.             if(cur.right == null || pre == cur.right){
    115.                 System.out.print(cur.val + "\t");
    116.                 //pre表示当前节点被访问过
    117.                 pre = cur;
    118.                 cur = null;
    119.             }else{
    120.                 //节点入栈
    121.                 stack.push(cur);
    122.                 //访问右边
    123.                 cur = cur.right;
    124.             }
    125.         }
    126.     }
    127.     public void levelOrder(TreeNode root){
    128.         //根节点为空，直接返回
    129.         if(root == null){
    130.             return;
    131.         }
    132.         //辅助队列
    133.         Queue queue = new LinkedList<>();
    134.         //根节点入队
    135.         queue.offer(root);
    136.         while(!queue.isEmpty()){
    137.             //获取队首元素
    138.             TreeNode node = queue.poll();
    139.             System.out.print(node.val + "\t");
    140.             //左右节点分别入队
    141.             if(node.left != null){
    142.                 queue.offer(node.left);
    143.             }
    144.             if(node.right != null){
    145.                 queue.offer(node.right);
    146.             }
    147.         }
    148.     }
    149.     public void sweepOrder(TreeNode root){
    150.         //根节点为空，直接返回
    151.         if(root == null){
    152.             return;
    153.         }
    154.         //存储结果
    155.         List> result = new ArrayList<>();
    156.         //辅助队列
    157.         Queue queue = new LinkedList<>();
    158.         //根节点入队
    159.         queue.offer(root);
    160.         //是否转向
    161.         boolean flag = false;
    162.         while(!queue.isEmpty()){
    163.             //获取队列长度
    164.             int size = queue.size();
    165.             //存储每一层的遍历结果
    166.             ArrayList list = new ArrayList<>();
    167.             for(int i=0; i < size; i++){
    168.                 //取出队列元素
    169.                 TreeNode node = queue.poll();
    170.                 if(node == null){
    171.                     continue;
    172.                 }
    173.                 if(!flag){
    174.                     list.add(node.val);
    175.                 }else{
    176.                     list.add(0, node.val);
    177.                 }
    178.                 //左右节点各入队
    179.                 queue.offer(node.left);
    180.                 queue.offer(node.right);
    181.             }
    182.             //如果有值，存入结果集
    183.             if(list.size() > 0){
    184.                 result.add(list);
    185.             }
    186.             //转向
    187.             flag = !flag;
    188.         }
    189.         System.out.println(result);
    190.     }
    191.  
    192.     public static void main(String[] args) {
    193.         BinaryTree  binaryTree = new BinaryTree();
    194. //        int[] datas = {72,37,29,55,51,80};
    195.         int[] datas = {12,5,2,9,18,15,17,16,19};
    196.         for(int n : datas){
    197.             binaryTree.buildTree(binaryTree.root, n);
    198.         }
    199.         System.out.println("前序遍历");
    200.         binaryTree.preOrder(binaryTree.root);
    201.         System.out.println();
    202.         System.out.println("中序遍历");
    203.         binaryTree.inOrder(binaryTree.root);
    204.         System.out.println();
    205.         System.out.println("后序遍历");
    206.         binaryTree.postOrder(binaryTree.root);
    207.         System.out.println();
    208.         System.out.println("层序遍历");
    209.         binaryTree.levelOrder(binaryTree.root);
    210.         System.out.println();
    211.         System.out.println("之字形遍历");
    212.         binaryTree.sweepOrder(binaryTree.root);
    213.  
    214.     }
    215. }
    216.

    执行结果如下：

     

  • 相关阅读:
    LVGL-TLSF内存管理算法-TLSF_LOG2_CEIL(n)宏详解：计算内存块所属内存池类别
    【原创】常用元器件(电阻)选型之阻值有多少-cayden20220910
    【代码随想录】算法训练营 第十六天 第六章 二叉树 Part 3
    C++和C#程序语言的区别
    java读取OPC DA数据---Utgard
    【备份】A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS
    [JS真好玩] 掘金创作者必备: 监控每天是谁取关了你？
    SpringBoot中日志的使用log4j2
    Flutter组件--Align和AnimatedAlign
    xshell的下载和安装
  • 原文地址：https://blog.csdn.net/weixin_47382783/article/details/126340100