数据结构——顺序存储二叉树

因为从数据存储的角度来看，数组存储方式和树的存储方式是可以互相转换的，即数组可以转换为树，而树也可以转换成数组。

八大排序算法中的堆排序，就会使用到顺序存储二叉树，后面在堆排序算法中会体现出来。

1. 什么叫作顺序存储二叉树

当一颗二叉树满足如下两个条件时，就是顺序存储二叉树：

1. 二叉树是以数组的方式存放数据的。如下图所示：

   

2. 在遍历数组时，仍然可以按照前序遍历、中序遍历和后序遍历的方式来完成节点的遍历

2. 顺序存储二叉树的特点

1. 顺序二叉树通常只考虑完全二叉树

2. 第n个元素的左子节点在数组中对应的下标是2*n + 1

3. 第n个元素的右子节点在数组中对应的下标是2*n + 2

4. 第n个元素的父节点在数组中对应的下标是(n - 1)/2

其中n表示二叉树中的第几个元素(按照数组中的下标0开始)。

结合顺序二叉树的示意图说明：

例如上面二叉树中的2这个节点：

• 节点2—>在数组中对应的下标是1—>那么它的左子节点的下标为2*1 + 1 = 3，就是节点4这个对象，它的右子节点的下标为2x1+2 = 4，就是节点5这个对象。

• 节点3—>在数组中对应的下标是2—>那么它的左子节点的下标为2*2 + 1 = 5，就是节点6这个对象，它的右子节点的下标为2x2+2 = 6，就是节点7这个对象。

• 节点5—>在数组中对应的下标是4—>那么他的父节点的下标为(4-1)/2 = 1，即它的父节点在数组中的下标为1

3. 顺序存储二叉树前序、中序、后序遍历

1. 代码实现

   //编写一个ArrayBinaryTree，实现顺序存储二叉树遍历
   class ArrayBinaryTree {
       private int[] arr;
   
       public ArrayBinaryTree(int[] arr) {
           this.arr = arr;
       }
   
       //重载preOrder方法
       public void preOrder() {
           this.preOrder(0);
       }
   
       /**
        * 顺序存储二叉树的前序遍历
        * @param index 数组的下标
        */
       public void preOrder(int index) {
           if (arr == null || arr.length == 0) {
               System.out.println("数组为空，不能按照二叉树的前序遍历");
               return;
           }
           //1. 输出当前这个元素
           System.out.print(arr[index] + "\t");
           //2. 向左递归遍历
           if ((index * 2 + 1) < arr.length) {
               preOrder(index * 2 + 1);
           }
           //3. 向右递归遍历
           if ((index * 2 + 2) < arr.length) {
               preOrder(index * 2 + 2);
           }
       }
   
       /**
        * 顺序存储二叉树的中序遍历
        * @param index 数组的下标
        */
       public void infixOrder(int index) {
           if (arr == null || arr.length == 0) {
               System.out.println("数组为空，不能按照二叉树的中序遍历");
               return;
           }
           //1. 向左递归遍历
           if ((index * 2 + 1) < arr.length) {
               infixOrder(index * 2 + 1);
           }
           //2. 输出当前这个元素
           System.out.print(arr[index] + "\t");
           //3. 向右递归遍历
           if ((index * 2 + 2) < arr.length) {
               infixOrder(index * 2 + 2);
           }
       }
   
       /**
        * 顺序存储二叉树的后序遍历
        * @param index 数组的下标
        */
       public void postOrder(int index) {
           if (arr == null || arr.length == 0) {
               System.out.println("数组为空，不能按照二叉树的后序遍历");
               return;
           }
           //1. 向左递归遍历
           if ((index * 2 + 1) < arr.length) {
               postOrder(index * 2 + 1);
           }
           //2. 向右递归遍历
           if ((index * 2 + 2) < arr.length) {
               postOrder(index * 2 + 2);
           }
           //3. 输出当前这个元素
           System.out.print(arr[index] + "\t");
       }
   }
   

2. 测试代码

   public class ArrayBinaryTreeDemo {
       public static void main(String[] args) {
           int[] arr = {1, 2, 3, 4, 5, 6, 7};
           //创建一个ArrayBinaryTree
           ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);
           System.out.println("顺序存储二叉树前序遍历");
           arrayBinaryTree.preOrder();
           System.out.println("\n顺序存储二叉树中序遍历");
           arrayBinaryTree.infixOrder(0);
           System.out.println("\n顺序存储二叉树后序遍历");
           arrayBinaryTree.postOrder(0);
       }
   }
   

3. 运行结果

非常感谢您的耐心阅读，希望我的文章对您有帮助。欢迎点评、转发或分享给您的朋友或技术群。