树的实现

1. 数组 表示的节点

public class TreeNode {

    private Object mData;  //存储的数据
    private int mParent;  //父亲节点的下标

    public TreeNode(Object data, int parent) {
        mData = data;
        mParent = parent;
    }

    public Object getData() {
        return mData;
    }

    public void setData(Object data) {
        mData = data;
    }

    public int getParent() {
        return mParent;
    }

    public void setParent(int parent) {
        mParent = parent;
    }
}

      上述代码中，使用 角标 来指明父亲节点的位置，使用这个节点组成的数组就可以表示一棵树

public static void main(String[] args){
    TreeNode[] arrayTree = new TreeNode[10];
}

     用数组实现的树表示下面的树，（其中一种 ）结果

     

     

     

2. 链表 表示的节点

public class LinkedTreeNode {

    private Object mData;  //存储的数据
    private LinkedTreeNode mParent;  //父亲节点的下标
    private LinkedTreeNode mChild;  //孩子节点的引用

    public LinkedTreeNode(Object data, LinkedTreeNode parent) {
        mData = data;
        mParent = parent;
    }

    public Object getData() {
        return mData;
    }

    public void setData(Object data) {
        mData = data;
    }

    public Object getParent() {
        return mParent;
    }

    public void setParent(LinkedTreeNode parent) {
        mParent = parent;
    }

    public LinkedTreeNode getChild() {
        return mChild;
    }

    public void setChild(LinkedTreeNode child) {
        mChild = child;
    }

}

public static void main(String[] args){
    LinkedList<LinkedTreeNode> linkedTree = new LinkedList<>();
}

3. 二叉树 的节点

    

     （1）递归节点实现法/左右链表示法（常用）

public class BinaryTreeNode {
    /*
    * 一个二叉树包括 数据、左右孩子 三部分
    */
    private int mData;
    private BinaryTreeNode mLeftChild;
    private BinaryTreeNode mRightChild;

    public BinaryTreeNode(int data, BinaryTreeNode leftChild, BinaryTreeNode rightChild) {
        mData = data;
        mLeftChild = leftChild;
        mRightChild = rightChild;
    }

    public int getData() {
        return mData;
    }

    public void setData(int data) {
        mData = data;
    }

    public BinaryTreeNode getLeftChild() {
        return mLeftChild;
    }

    public void setLeftChild(BinaryTreeNode leftChild) {
        mLeftChild = leftChild;
    }

    public BinaryTreeNode getRightChild() {
        return mRightChild;
    }

    public void setRightChild(BinaryTreeNode rightChild) {
        mRightChild = rightChild;
    }

}

     （2）数组下标表示法

public class BinaryTreeArrayNode {
    /**
    * 数组实现，保存的不是 左右子树的引用，而是数组下标
    */
    private int mData;
    private int mLeftChild;
    private int mRightChild;

    public int getData() {
        return mData;
    }

    public void setData(int data) {
        mData = data;
    }

    public int getLeftChild() {
        return mLeftChild;
    }

    public void setLeftChild(int leftChild) {
        mLeftChild = leftChild;
    }

    public int getRightChild() {
        return mRightChild;
    }

    public void setRightChild(int rightChild) {
        mRightChild = rightChild;
    }
}

4. 二叉树的创建

     

     创建一个二叉树只需要有一个 二叉根节点，然后提供设置根节点的方法即可

public class BinaryTree {
    private BinaryTreeNode mRoot;  //根节点

    public BinaryTree() {
    }

    public BinaryTree(BinaryTreeNode root) {
        mRoot = root;
    }

    public BinaryTreeNode getRoot() {
        return mRoot;
    }

    public void setRoot(BinaryTreeNode root) {
        mRoot = root;
    }
}

5. 二叉树的添加元素

      二叉树有左右子树之分，所以添加元素时也分为两种情况：添加为左子树还是右子树

public void insertAsLeftChild(BinaryTreeNode child){
        checkTreeEmpty();
        mRoot.setLeftChild(child);
    }

    public void insertAsRightChild(BinaryTreeNode child){
        checkTreeEmpty();
        mRoot.setRightChild(child);
    }

    private void checkTreeEmpty() {
        if (mRoot == null){
            throw new IllegalStateException("Can't insert to a null tree! Did you forget set value for root?");
        }
    }

6. 二叉树的删除元素

     删除某个元素只需要把自己设为 null

     但是为了避免浪费无用的内存，方便 GC 及时回收，还需要遍历这个元素的左右子树，挨个设为空

public void deleteNode(BinaryTreeNode node){
    checkTreeEmpty();
    if (node == null){  //递归出口
        return;
    }
    deleteNode(node.getLeftChild());
    deleteNode(node.getRightChild());
    node = null;
}

7. 二叉树的清空

      二叉树的清空其实就是特殊的删除元素–删除根节点

public void clear(){
    if (mRoot != null){
        deleteNode(mRoot);
    }
}

8. 获得二叉树的高度

     二叉树中，树的高度是 各个节点度的最大值

     因此获得树的高度需要递归获取所有节点的高度，然后取最大值

  /**
    * 获取树的高度 ，特殊的获得节点高度
    * @return
    */
    public int getTreeHeight(){
        return getHeight(mRoot);
    }
    /**
    * 获得指定节点的度
    * @param node
    * @return
    */
    public int getHeight(BinaryTreeNode node){
        if (node == null){      //递归出口
            return 0;
        }
        int leftChildHeight = getHeight(node.getLeftChild());
        int rightChildHeight = getHeight(node.getRightChild());

        int max = Math.max(leftChildHeight, rightChildHeight);

        return max + 1; //加上自己本身
    }

9. 获得二叉树的节点数

      获得二叉树的节点数，需要遍历所有子树，然后加上总和

public int getSize(){
    return getChildSize(mRoot);
}

/**
* 获得指定节点的子节点个数
* @param node
* @return
*/
public int getChildSize(BinaryTreeNode node){
    if (node == null){
        return 0;
    }
    int leftChildSize = getChildSize(node.getLeftChild());
    int rightChildSize = getChildSize(node.getRightChild());

    return leftChildSize + rightChildSize + 1;
}

10. 获得某个节点的父节点

     由于使用左右子树表示的节点，不含有父亲节点引用，因此有时候可能也需要一个方法，返回二叉树中，指定节点的父亲节点

     需要从顶向下遍历各个子树，若该子树的根节点的孩子就是目标节点，返回该节点，否则递归遍历它的左右子树

/**
* 获得指定节点的父亲节点
* @param node
* @return
*/
public BinaryTreeNode getParent(BinaryTreeNode node) {
    if (mRoot == null || mRoot == node) {  //如果是空树，或者这个节点就是根节点，返回空
        return null;
    } else {
        return getParent(mRoot, node);  //否则递归查找 父亲节点
    }
}

/**
* 递归对比 节点的孩子节点 与 指定节点 是否一致
*
* @param subTree 子二叉树根节点
* @param node    指定节点
* @return
*/

public BinaryTreeNode getParent(BinaryTreeNode subTree, BinaryTreeNode node) {

    if (subTree == null) {      //如果子树为空，则没有父亲节点，递归出口

        return null;
    }

    //正好这个根节点的左右孩子之一与目标节点一致

    if (subTree.getLeftChild() == node || subTree.getRightChild() == node) {    //递归出口

        return subTree;
    }
    //需要遍历这个节点的左右子树
    BinaryTreeNode parent;
    if ((parent = getParent(subTree.getLeftChild(), node)) != null) { //左子树节点就是指定节点，返回
        return parent;
    } else {
        return getParent(subTree.getRightChild(), node);    //从右子树找找看
    }

}

11. 二叉树的遍历

     （1）先序遍历

/**
* 先序遍历
* @param node
*/
public void iterateFirstOrder(BinaryTreeNode node){
    if (node == null){
        return;
    }
    operate(node);
    iterateFirstOrder(node.getLeftChild());
    iterateFirstOrder(node.getRightChild());
}

/**
* 模拟操作
* @param node
*/
public void operate(BinaryTreeNode node){
    if (node == null){
        return;
    }
    System.out.println(node.getData());
}

     （2）中序遍历

/**
* 中序遍历
* @param node
*/
public void iterateMediumOrder(BinaryTreeNode node){
    if (node == null){
        return;
    }
    iterateMediumOrder(node.getLeftChild());
    operate(node);
    iterateMediumOrder(node.getRightChild());
}

     （3）后序遍历

/**
* 后序遍历
* @param node
*/
public void iterateLastOrder(BinaryTreeNode node){
    if (node == null){
        return;
    }
    iterateLastOrder(node.getLeftChild());
    iterateLastOrder(node.getRightChild());
    operate(node);
}