顺序存储二叉树(代码实现) [数据结构与算法]

顺序存储二叉树(代码实现)

我们的顺序存储二叉树在堆排序中就会使用到

具体代码如下:

package com.ffyc.tree;

import org.junit.Test;

/**
 * 定义一个ArrayBinaryTree表示顺序存储二叉树类
 */
public class ArrayBinaryTree {
    //我们的顺序存储二叉树底层是使用数组实现的,所以我们先来创建一个数组用于底层存储的实现
    private int[] arr; //存储数据结点的数组(此时我们创建的是一个只用于存储整数的顺序存储二叉树)

    public ArrayBinaryTree(int[] arr){
        this.arr = arr;
    }

    //前序遍历顺序存储二叉树的方法

    /**
     *
     * @param index 表示从哪个索引的位置开始进行遍历
     */
    public void preOrder(int index){
        /*
        这个时候我们输出这个节点之前一定要先进行一个判断,因为第一次进来的时候我们不知道这个参数index是否已经是越界了,这个时候我们就要对这个index进行一个判断
          并且我们还要判断我们的arr数组是否为空,如果数组为空这个时候我们也不遍历, 或者如果这个数组长度为0,那么也就是数组中一个元素都没有,这个时候我们也不执行遍历的操作
         */
        if(arr == null || arr.length == 0){
            System.out.println("数组为空~~~~");
        }

        if(index > arr.length -1 ){
            //此时只有第一次执行此方法的时候才有可能会触发这个条件,递归调用方法的过程中永远都不会满足这个条件,因为我们在每次递归调用之前就已经是判断过,只有是
            //索引合法的情况之下我们才进行的递归
            System.out.println("传入的索引位置不合法~~");
        }

        //输出当前节点
        System.out.print(arr[index]);

        //向左进行遍历
         //我们在向左遍历之前一定要先判断我们的索引是否越界了,因为我们要向左递归,这个时候如果我们的index*2 + 1的位置都已经是索引越界了,这个时候当然就不能继续执行了
        if(index * 2 + 1 < arr.length) {
            preOrder(index * 2 + 1);
        }

        //向右进行遍历
         //对于向右进行遍历我们也会一样的,我们要先判断我们的索引是否是执行右递归的时候就会越界,如果是会越界那么这个时候我们就不能继续递归了

        if(index * 2 + 2 < arr.length) {
            preOrder(index * 2 + 2);
        }
    }

    //中序遍历顺序存储二叉树的方法
    /**
     *
     * @param index 表示从哪个索引的位置开始进行遍历
     */
    public void infixOrder(int index){
        /*
        这个时候我们输出这个节点之前一定要先进行一个判断,因为第一次进来的时候我们不知道这个参数index是否已经是越界了,这个时候我们就要对这个index进行一个判断
          并且我们还要判断我们的arr数组是否为空,如果数组为空这个时候我们也不遍历, 或者如果这个数组长度为0,那么也就是数组中一个元素都没有,这个时候我们也不执行遍历的操作
         */
        if(arr == null || arr.length == 0){
            System.out.println("数组为空~~~~");
        }

        if(index > arr.length -1 ){
            //此时只有第一次执行此方法的时候才有可能会触发这个条件,递归调用方法的过程中永远都不会满足这个条件,因为我们在每次递归调用之前就已经是判断过,只有是
            //索引合法的情况之下我们才进行的递归
            System.out.println("传入的索引位置不合法~~");
        }

        //向左进行遍历
        //我们在向左遍历之前一定要先判断我们的索引是否越界了,因为我们要向左递归,这个时候如果我们的index*2 + 1的位置都已经是索引越界了,这个时候当然就不能继续执行了
        if(index * 2 + 1 < arr.length) {
            infixOrder(index * 2 + 1);
        }

        //输出当前节点
        System.out.print(arr[index]);

        //向右进行遍历
        //对于向右进行遍历我们也会一样的,我们要先判断我们的索引是否是执行右递归的时候就会越界,如果是会越界那么这个时候我们就不能继续递归了

        if(index * 2 + 2 < arr.length) {
            infixOrder(index * 2 + 2);
        }
    }

    //后序遍历顺序存储二叉树的方法
    /**
     *
     * @param index 表示从哪个索引的位置开始进行遍历
     */
    public void postOrder(int index){
        /*
        这个时候我们输出这个节点之前一定要先进行一个判断,因为第一次进来的时候我们不知道这个参数index是否已经是越界了,这个时候我们就要对这个index进行一个判断
          并且我们还要判断我们的arr数组是否为空,如果数组为空这个时候我们也不遍历, 或者如果这个数组长度为0,那么也就是数组中一个元素都没有,这个时候我们也不执行遍历的操作
         */
        if(arr == null || arr.length == 0){
            System.out.println("数组为空~~~~");
        }

        if(index > arr.length -1 ){
            //此时只有第一次执行此方法的时候才有可能会触发这个条件,递归调用方法的过程中永远都不会满足这个条件,因为我们在每次递归调用之前就已经是判断过,只有是
            //索引合法的情况之下我们才进行的递归
            System.out.println("传入的索引位置不合法~~");
        }

        //向左进行遍历
        //我们在向左遍历之前一定要先判断我们的索引是否越界了,因为我们要向左递归,这个时候如果我们的index*2 + 1的位置都已经是索引越界了,这个时候当然就不能继续执行了
        if(index * 2 + 1 < arr.length) {
            postOrder(index * 2 + 1);
        }

        //向右进行遍历
        //对于向右进行遍历我们也会一样的,我们要先判断我们的索引是否是执行右递归的时候就会越界,如果是会越界那么这个时候我们就不能继续递归了

        if(index * 2 + 2 < arr.length) {
            postOrder(index * 2 + 2);
        }

        //输出当前节点
        System.out.print(arr[index]);
    }

    //提供重载的前序,中序,后序遍历顺序存储二叉树的方法, 如果我们是从index为0开始,那么我们直接调用重载方法即可
    public void preOrder(){
        preOrder(0);
    }

    public void infixOrder(){
        infixOrder(0);
    }

    public void postOrder(){
        postOrder(0);
    }
}

给出我们的测试程序:

//测试方法
public static void main(String[] args) {
    int [] arr = {1,2,3,4,5,6,7};

    //创建一个ArrayBinaryTree对象
    ArrayBinaryTree arrayBinaryTree = new ArrayBinaryTree(arr);

    //对顺序存储二叉树进行一个前序遍历
    arrayBinaryTree.preOrder();
    System.out.println();

    //中序遍历
    arrayBinaryTree.infixOrder();
    System.out.println();

    //后序遍历
    arrayBinaryTree.postOrder();
    System.out.println();

}