java实现二叉树的顺序存储

1.树的顺序存储

树的顺序存储一般是用来存储满二叉树或者完全二叉树的，如果用来存储一般的二叉树会有空间浪费。

2.注意要点

1..对于完全二叉树，若从上往下，从左到右，则编号为i的结点，其左孩子编号必定为2i，其右边孩子编号必定为2i+1，其双亲结点编号必定为i/2.

2.深度为k的二叉树至多有2^k-1个结点

3.第i层有2^(k-1)个结点

4.对于任何一棵二叉树，若2度的结点数有n2个，则叶子树n0必定为n2+1（即n0=n2+1）

5.抽象的结构

1.初始化增加结点

2.返回指定结点的左节点

3.返回指定节点的右节点

4.添加指定节点的左右节点

5.判断树是否为空

3.实现细节

1.有三种构造器，分别无无参构造器，一个参数（树的深度）的构造器，两个参数（树的深度和根结点）的构造器。定义了DEFAULE_KEEP:默认深度；定义了树的长度；定义了一个数组用来存储树种结点的信息。

2.添加结点的方法写了两种，一种是初始化直接一次性添加，然后输入第0的时候退出添加；二种是添加指定结点的左节点和右节点，添加的时候进行判断指定结点的左节点和右节点是否为空，如果为空是否选择覆盖。

3.返回指定结点的左节点，右节点和父节点。当前结点下标为i，左节点是2i，右节点是2i+1,父节点是i/2;需要注意的是满足这些条件的前提示，根结点的下标是从1开始。

package OrderBinaryTree;

import java.util.Scanner;


public class BinaryTree {
    final private int DEFAULT_PEEK=6;
    private int deep;
    private int length;
    private String[] array;
    /**
     * 无参构造器
     */
    public BinaryTree() {
        this.deep=DEFAULT_PEEK;
        this.length=(int)(Math.pow(2,deep)-1);
        array=new String[length];
    }
    /**
     * 传入深度参数的构造器
     */
    public BinaryTree(int deep) {
        this.deep=deep;
        this.length=(int)(Math.pow(2,deep)-1);
        array=new String[length];
    }
    /**
     * 传入参数深度和根结点的构造器
     */
    public BinaryTree(int deep,String data) {
        this.deep=deep;
        this.length=(int)(Math.pow(2,deep)-1);
        array=new String[length];
        array[1]=data;
    }
    /**
     * 添加初始化结点
     */
    public void addNode() {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入二叉树信息，输入值为0结束输入");
            for (int i = 1; i < array.length; i++) {
                if (array[i]==null||array[i].equals("0")==true) {
                    array[i]=input.nextLine();
                    if (array[i].equals("0")==true) {
                        break;
                }
            }
        }
    }
    /**
     * 判断二叉树是否为空
     */
    public boolean isEmpaty() {
        if (array[1]!=null&&array[1].equals("0")!=true) {
            return false;
        }else {
            return true;
        }
    }
    /**
     * 返回指定结点的值
     */
    public String returnData(int index) {
        if (index<1||index>array.length-1) {
            return null;
        }else {
            return array[index];
        }
    }
    /**
     * 返回指定结点的父节点
     */
    public String getParent(int index) {
        if (index<1||index>array.length-1) {
            return null;
        }else {
            return array[index/2];
        }
    }
    
    /**
     * 添加指定结点的左节点
     */
    public void addNodeLeft(int index,String data) {
        if (array[2*index]!=null&&array[2*index].equals("0")!=true) {
            System.out.println("当前结点左节点已有值，是否覆盖？Y/N");
            Scanner input=new Scanner(System.in);
            String in=input.nextLine();
            if (in.equals("Y")) {
                array[index*2]=data;
            }else if (in.equals("N")) {
                return;
            }
        }
    }
    
    /**
     * 添加指定结点的左节点
     */
    public void addNodeRight(int index,String data) {
        if (array[2*index+1]!=null&&array[2*index+1].equals("0")!=true) {
            System.out.println("当前结点右节点已有值，是否覆盖？Y/N");
            Scanner input=new Scanner(System.in);
            String in=input.nextLine();
            if (in.equals("Y")) {
                array[index*2+1]=data;
            }else if(in.equals("N")) {
                return;
            }
        }
    }
    
    /**
     * 返回指定结点的左节点
     */
    public String getLeftNode(int index) {
        if (array[2*index]!=null&&array[2*index].equals("0")!=true) {
            return array[index*2];
        }
        else {
            return null;
        }
    }
    
    /**
     * 返回指定结点的右节点
     */
    public String getRightNode(int index) {
        if (array[2*index+1]!=null&&array[2*index+1].equals("0")!=true) {
            return array[index*2+1];
        }
        else {
            return null;
        }
    }
}

测试类：

package OrderBinaryTree;
public class TreeText {
    public static void main(String[] args) {
        BinaryTree bin=new BinaryTree();
        bin.addNode();
        System.out.println("左节点是：");
        System.out.println(bin.getLeftNode(2));
        System.out.println("右节点是：");
        System.out.println(bin.getRightNode(2));
        System.out.println("====================");
        bin.addNodeLeft(2, "insert");
        bin.addNodeRight(2, "insert");
        System.out.println("插入后左节点是：");
        System.out.println(bin.getLeftNode(2));
        System.out.println("====================");
        System.out.println("插入后右节点是：");
        System.out.println(bin.getRightNode(2));
    }

}