java实现二叉树的相关操作

 今天再看数据结构的二叉树，顿时感觉世界明亮了。就写了这个，当然了，这个呢。也是看网上的方法的。

非常感谢下面几篇文章的作者。

https://www.cnblogs.com/ysocean/p/8032642.html#_label0_0

https://www.cnblogs.com/lixiaolun/p/4658659.html

https://blog.csdn.net/u010842515/article/details/68951783

 下面就列出方法。

package com.tree;

import java.util.LinkedList;

/**
 * @author SunY
 * 实现二叉树的相关运算,继承我的的Tree
 * */
public class BinaryTree implements Tree{

    public BinaryTree(){ }
    /**
     * @param data
     * 建议使用泛型
     * */
    @Override
    public LinkedList<Node> createTree(int[] data) {
        LinkedList<Node> nodeLinkedList = null ; // 链表
        // 将数组的值一次转化成二叉树的节点值
        nodeLinkedList = new LinkedList<Node>();
        for(Object element : data){
            nodeLinkedList.add(new Node(element));
        }
        /**
         * * 完全二叉树中第i层的结点的个数最多为第1到i-1层上所有节点的个数和
         * * 所以父节点的个数最多为N-1个，N表示节点个数
         * */
        for(int parentIndex = 0 ; parentIndex < data.length / 2 - 1 ; parentIndex ++ ){
            // 根节点为空，即为空表时
            nodeLinkedList.get(parentIndex).leftChild =
                    nodeLinkedList.get(parentIndex*2 + 1);
            nodeLinkedList.get(parentIndex).rightChild =
                    nodeLinkedList.get(parentIndex*2 + 2);
            // 左 , 右 孩子 , 这个可能好理解一点
            //root.leftChild = new Node(array[parentIndex*2 + 1]) ;
            //root.rightChild = new Node(array[parentIndex*2 + 2]);
        }
        // 上面我们解决了前面的所有节点，但是我们的最后一个父节点，还没有处理，万一他们有孩子呢？
        int lastparentIndex = data.length / 2 - 1 ;
        nodeLinkedList.get(lastparentIndex).leftChild =
                nodeLinkedList.get(lastparentIndex*2 + 1);
        // 此时，我们需要注意一下，如果没有右孩子，怎么办？如果数组的长度为奇数才建立右孩子
        if(data.length % 2 == 1 ){
            nodeLinkedList.get(lastparentIndex).rightChild =
                    nodeLinkedList.get(lastparentIndex*2 + 2);
        }
        return nodeLinkedList;
    }

    /**
     * @param data
     * */
    @Override
    public boolean insertTree(Object data,LinkedList<Node> nodelist) {
        return false;
    }
    /**
     * @param data
     * */
    @Override
    public boolean deleteTree(Object data) {
        return false;
    }
    /**
     * @param node
     * */
    @Override
    public void visit(Node node) {
        if(node != null){
            System.out.print(node.data+" ");
        }
    }
    /**
     * @param node
     * 左序遍历
     * */
    @Override
    public void INOrderTraverse(Node node) {
        if(node == null )
            return ;
        INOrderTraverse(node.leftChild);
        visit(node);
        INOrderTraverse(node.rightChild);
    }
    /**
     * @param node
     * 先序遍历
     * */
    @Override
    public void PreOrderTraverse(Node node) {
        if(node == null )
            return ;
        visit(node);
        PreOrderTraverse(node.leftChild);
        PreOrderTraverse(node.rightChild);
    }
    /**
     * @param node
     * 后序遍历
     * */
    @Override
    public void PostOrderTraverse(Node node) {
        if(node == null )
            return ;
        PostOrderTraverse(node.leftChild);
        PostOrderTraverse(node.rightChild);
        visit(node);
    }
}

package com.tree;
/**
 * @author SunY
 * 二叉树的定义类
 * */
public class Node {

    public Object data ; // 节点数据
    public  Node leftChild ;// 左孩子节点
    public  Node rightChild ;// 右孩子节点
    public  Node(Object data){
        this.leftChild = null ;
        this.rightChild = null ;
        this.data = data ;
    }
    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                ", leftChild=" + leftChild +
                ", rightChild=" + rightChild +
                '}';
    }

}

package com.tree;

import java.util.LinkedList;
/**
 * @author SunY
 * 定义操作树方法接口
 *
 * */
public interface Tree {
    // 创建一个二叉树
    public LinkedList<Node> createTree(int[] data);
    // 插入
    public boolean insertTree(Object data ,LinkedList<Node> nodelist) ;
    // 删除
    public boolean deleteTree(Object data);
    // 输出二叉树
    public void visit(Node node) ;

    // 左序遍历
    public void INOrderTraverse(Node node);
    // 先序遍历
    public void PreOrderTraverse(Node node);
    //后序遍历
    public void PostOrderTraverse(Node node);

}

package com.tree.test;

import com.tree.BinaryTree;
import com.tree.Node;

import java.util.LinkedList;
/**
 * @author SunY
 * 二叉树的测试
 * */
public class BinaryTreeTest {
    private Node root = null , node = null ;

    private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // 自定义一个数组

    @org.junit.Test
    public void BinaryTest(){
        BinaryTree binaryTree = new BinaryTree();
        LinkedList<Node> nodelist = binaryTree.createTree(array) ; // 这里的数组可以替换成其他的Object类型，得到一个二叉树链表
        root = nodelist.get(0); // 得到根节点
        System.out.println("构建的二叉树为：");
        for(Node list : nodelist){
            System.out.println(list.toString());
        }

        System.out.println("先序遍历");
        binaryTree.PreOrderTraverse(root);
        System.out.println();
        System.out.println("中序遍历");
        binaryTree.INOrderTraverse(root);
        System.out.println();
        System.out.println("后序遍历");
        binaryTree.PostOrderTraverse(root);

    }
}