二叉树的顺序存储实现及遍历

女爷i 2022-06-06 11:42 323阅读 0赞

关于二叉树的实现，常见的大概有三种实现方法：

  • 顺序存储：采用数组来记录二叉树的所有节点
  • 二叉链表存储： 每个节点保留一个left，right域，指向左右孩子
  • 三叉链表存储： 每个节点保留一个left, right, parent域，指向左右孩子和父亲

根据满二叉树的特性，第i层的节点数量为2^(i-1)，对于一个深度为n的二叉树，节点数最多为2^n - 1。因此，只需要定义一个长度为2^n-1的数组即可定义出深度为n的二叉树。

注意：对于非完全二叉树，数组中必然会存在空元素的情况，这样情况下空间浪费比较严重。因此仅建议满二叉树使用顺序存储来实现，以便实现紧凑存储和高效访问。

顺序存储的实现

  • 使用一个数组来存储所有节点
  • 按数组下标进行存储，根节点存储在下标0处，其左孩子存储于下标2*0+1，右孩子存储于下标2*0+2 …依次类型。
  • 下标为i的节点，左右孩子存储于下标2*i+1与2*i+2

简易代码：

  1. public class OrderBinaryTree<T> {
  3.    // 二叉树所有节点的顺序存储的数组
  4.     public Object[] datas;
  5.     // 二叉树的规模最大值为2的deep次方-1
  6.     public int arraySize;
  7.     // 树的深度
  8.     public int deep;
  9.     // 默认深度
  10.     public static int DEFAULT_DEEP = 8;
  12.     public OrderBinaryTree() {
  13.         this.deep = DEFAULT_DEEP;
  14.         this.arraySize = (int) Math.pow(2, deep) - 1;
  15.         this.datas = new Object[arraySize];
  16.     }
  18.     public OrderBinaryTree(int deep) {
  19.         this.deep = deep;
  20.         this.arraySize = (int) Math.pow(2, deep) - 1;
  21.         this.datas = new Object[arraySize];
  22.     }
  24.     public OrderBinaryTree(int deep, T root) {
  25.         this(deep);
  26.         this.datas[0] = root;
  27.     }
  29.    /**
  30.      * 为指定的节点添加子节点
  31.      * 
  32.      * @param index
  33.      *            该节点的索引
  34.      * @param data
  35.      *            被添加为子节点的索引
  36.      * @param left
  37.      *            是否为左孩子
  38.      * @throws Exception
  39.      **/
  41.     public void add(int index, T data, Boolean left) throws Exception {
  43.         int needSize = left? 2 * index + 1: 2 * index + 2;
  45.         if (needSize >= datas.length) {
  46.             throw new Exception("数组越界");
  47.         }
  49.         if (left) {
  50.             datas[2 * index + 1] = data;
  51.         } else {
  52.             datas[2 * index + 2] = data;
  53.         }
  55.     }
  57.    /**
  58.      * 为指定的节点添加子节点
  59.      * 
  60.      * @param index
  61.      *            该节点的索引
  62.      * @return 子节点的索引
  63.      **/
  65.     public int getLeft(int index) throws Exception {
  67.         if (index >= 0 && datas.length > 2 * index + 1) {
  68.             return 2 * index + 1;
  69.         }
  70.         return -1;
  72.     }
  74.    /**
  75.      * 为指定的节点添加子节点
  76.      * 
  77.      * @param index
  78.      *            该节点的索引
  79.      * @return 子节点的索引
  80.      **/
  82.     public int getRight(int index) throws Exception {
  84.         if (index >= 0 && datas.length > 2 * index + 2) {
  85.             return 2 * index + 2;
  86.         }
  87.         return -1;
  89.     }
  90. }

上述代码实现了一个非常简易的二叉树，当然二叉树还有很多操作上述没有列出来。现在使用上述定义的数据结构来实现一个二叉树实例：

  1. OrderBinaryTree<String> orderBinaryTree = new OrderBinaryTree<String>(3, "a");
  2.   orderBinaryTree.add(0, "b", true);
  3.   orderBinaryTree.add(0, "c", false);
  4.   orderBinaryTree.add(1, "d", true);
  5.   orderBinaryTree.add(1, "e", false);
  6.   orderBinaryTree.add(2, "f", true);
  7.   orderBinaryTree.add(2, "g", false);

上述定义来一个如下面所示的满二叉树：

二叉树遍历

遍历二叉树指的是按某种规律依次访问二叉树的每个节点，对于二叉树的遍历就是将一个非线性结构的二叉树中节点排列在一个线性序列上的过程。

遍历方法：

  • 深度优先遍历
  • 广度优先遍历

其中广度优先遍历非常简单，就按层遍历，访问第一层，第二层，..对于我们的顺序实现的二叉树来说，底层数组就是其广度优先遍历的结果。现在我们重点介绍深度优先遍历。

深度优先遍历

深度优先遍历分3种(假设L，D，R分别表示左，根，右子树)：

  • 先序遍历： DLR
  • 中序遍历： LDR
  • 后序遍历： LRD

一·先序遍历
对于先序遍历，或许你经常会看到如下的递归代码：

  1. public void travPreRecursion() {
  2.         return this.preRecursion(0);
  3.     }
  5.     private List preRecursion(int index) {
  6.         List list = new ArrayList();
  7.         list.add(datas[index]);
  9.         if (2 * index + 1 < arraySize) {
  10.             list.addAll(preRecursion(2 * index + 1));// 左儿子
  11.         }
  13.         if (2 * index + 2 < arraySize) {
  14.             list.addAll(preRecursion(2 * index + 2));// 右儿子
  15.         }
  17.         return list;
  18.     }

笔者认为递归算法不仅效率低而且不利于阅读者理解，因此笔者将其修改为循环版

先沿着最左侧通路自顶而下访问沿路节点，再底而上依次遍历这些节点的右节点

  1. public List travPreCirculate() {
  2.         int index = 0;
  3.         //定义一个辅助栈来完成最左侧通路自顶而下的节点的右节点
  4.         Stack<Integer> stack = new Stack<Integer>();
  5.         List list = new ArrayList();
  7.         try {
  8.             while (true) {
  9.                 //从index开始最左侧通路自顶而下的访问节点，直到底
  10.                 //并把每个访问到的节点存储在stack
  11.                 setRightStack(index, stack, list);
  12.                 //如果一条左子数链路中没有任何一个右子数，则遍历结束
  13.                 if (stack.empty()) {
  14.                     break;
  15.                 }
  16.                 // 从来临时栈中依次pop出节点，并继续取其右节点
  17.                 index = stack.pop();
  18.             }
  20.         } catch (Exception e) {
  21.             // TODO Auto-generated catch block
  22.             e.printStackTrace();
  23.         }
  24.         return list;
  25.     }
  27.     public void setRightStack(int index, Stack<Integer> stack, List list) {
  28.         try {
  29.             // 从index开始访问其左子数，并将其所有的右子树全部push到临时栈中
  30.             while (index >= 0) {
  31.                 list.add(datas[index]);
  32.                 int right = getRight(index);
  33.                 if (right > 0) {
  34.                     stack.push(right);
  35.                 }
  36.                 index = this.getLeft(index);
  37.             }
  38.         } catch (Exception e) {
  39.             // TODO Auto-generated catch block
  40.             e.printStackTrace();
  41.         }
  42.     }

二·中序遍历

对于中序遍历，与先序遍历类似，你经常会看到如下的递归代码：

  1. public void travPreRecursion() {
  2.         return this.preRecursion(0);
  3.     }
  5.     private List preRecursion(int index) {
  6.         List list = new ArrayList();
  8.         if (2 * index + 1 < arraySize) {
  9.             list.addAll(preRecursion(2 * index + 1));// 左儿子
  10.         }
  12.         list.add(datas[index]);
  14.         if (2 * index + 2 < arraySize) {
  15.             list.addAll(preRecursion(2 * index + 2));// 右儿子
  16.         }
  18.         return list;
  19.     }

当然，笔者还是要将其修改为循环模式

沿着最左侧链路，自底而上依次访问每个节点的右子树

  1. public void travInCirculate() {
  3.   int index = 0;
  4.   Stack<Integer> stack = new Stack<Integer>();
  5.   List list = new ArrayList();
  7.   while (true) {
  8.     //将index节点的左子树全部push到stack中
  9.     setLeftStack(index, stack);
  10.     if (stack.isEmpty()) {
  11.         break;
  12.     }
  13.     //pop出左子树
  14.     index = stack.pop();
  15.     list.add(datas[index]);
  16.     try {
  17.         //取该节点的右孩子，并继续push其所有左子树到栈中
  18.         index = this.getRight(index);
  19.     } catch (Exception e) { // TODO Auto-generated catch
  20.         block e.printStackTrace();
  21.     }
  22.   }
  24.  }
  26.     public void setLeftStack(int index, Stack<Integer> stack) {
  27.         try {
  28.             // 将root开始的所有右子树全部push到临时栈中
  29.             while (index >= 0) {
  30.                 stack.push(index);
  31.                 index = getLeft(index);
  32.             }
  33.         } catch (Exception e) {
  34.             // TODO Auto-generated catch block
  35.             e.printStackTrace();
  36.         }
  37.     }

三.后序遍历

后序遍历的递归代码：

  1. // 后序遍历(递归)
  2.     public void travPostRecursion() {
  3.         postRecursion(0);
  4.     }
  6.     public void postRecursion(int index) {
  8.         if (2 * index + 1 < arraySize) {
  9.             postRecursion(2 * index + 1);// 左儿子
  10.         }
  12.         if (2 * index + 2 < arraySize) {
  13.             postRecursion(2 * index + 2);// 右儿子
  14.         }
  16.         System.out.println(datas[index]);
  18.     }

与上述一致，改造为循环

先序，中序遍历中，第一位元素一定是某个节点的左孩子。
当后序遍历不一定，后序遍历的首位原型应该是左子树中度最高的一个元素，可能是左孩子也有可能是右孩子

  1. // 后序遍历(循环)
  2.     public void travPostCirculate() {
  3.         int index = 0;
  4.         Stack<Integer> stack = new Stack<Integer>();
  5.         List list = new ArrayList();
  6.         while (true) {
  7.             //从index开始将其左孩子push到栈中
  8.             //如果到了最后一个左孩子，该节点存在右孩子，则继续push
  9.             setStackForPost(index, stack);
  11.             if (stack.empty()) {
  12.                 break;
  13.             }
  15.             index = stack.pop();
  16.             list.add(datas[index]);
  17.             // 获取其右兄弟
  18.             int parent;
  19.             try {
  20.                 parent = this.parent(index);
  21.                 int right = this.getRight(parent);
  22.                 index = index == right ? -1 : right;
  24.             } catch (Exception e) {
  25.                 // TODO Auto-generated catch block
  26.                 e.printStackTrace();
  27.             }
  28.         }
  29.     }
  31.     public void setStackForPost(int index, Stack stack) {
  32.         try {
  33.             // 将root开始的所有右子树全部push到临时栈中
  34.             while (index >= 0) {
  35.                 stack.push(index);
  36.                 int pre = index;
  37.                 index = getLeft(index);
  38.                 if (index < 0) {
  39.                     // 当到达最左子树时，如果该最左子树存在右子树，则遍历从该右子树开始
  40.                     index = this.getRight(pre);
  41.                 }
  42.             }
  43.         } catch (Exception e) {
  44.             // TODO Auto-generated catch block
  45.             e.printStackTrace();
  46.         }
  47.     }

补充

对于中序编译，也会看到如下写法，思路是一样

  1. // 中序遍历(循环)
  2.     public void travInCirculate() {
  4.         int index = 0;
  5.         Stack<Integer> stack = new Stack<Integer>();
  6.         try {
  7.             while (true) {
  8.                 if(index>=0) {
  9.                   stack.push(index);
  10.                   index = this.getLeft(index);
  11.                 }else if(!stack.empty()) {
  12.                     index = stack.pop();
  13.                     System.out.println(datas[index]);
  14.                     index = this.getRight(index);
  15.                 }else {
  16.                     break;
  17.                 }
  18.             }
  19.         } catch (Exception e) {
  20.             e.printStackTrace();
  21.         }
  22.     }

笔者认为中序遍历是最重要的，一项最基本的操作将是定位中序遍历中某个节点的直接后继节点，在平衡二叉树的等场景中会使用

发表评论

表情：
评论列表 （有 0 条评论，323人围观）

还没有评论，来说两句吧...

相关阅读

    相关 二叉树的存储和遍历

    一、二叉树的存储结构 1. 顺序存储 用一组连续的存储单元依次自上而下、自左至右存储完全二叉树上的结点元素。 > 注意，存放的是是完全二叉树的结点元素。 例如：

    小咪咪小咪咪/ 0 赞/ 268 阅读