java实现二叉树及遍历、删除

java实现二叉树及遍历、删除

个人网站：多猫影视【可以看各大网站的VIP视频】www.duomao.xyz

二叉树是 递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态：

(1)空二叉树——如图(a)；

(2)只有一个根结点的二叉树——如图(b)；

(3)只有左子树——如图(c)；

(4)只有右子树——如图(d)；

(5) 完全二叉树——如图(e)。

注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。[1]  

类型

(1) 完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有 叶子结点，并且叶子结点都是从左到右依次排布，这就是 完全二叉树。

(2) 满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。

(3)平衡二叉树——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

代码注释的比较详细，就不用再说明了。

package com.niu.test;

/**
 * Created by Administrator on 2017/9/26.
 */
public class AlvinTree {

    private Node root;

    //1、创建二叉树的结点（三个要素：结点数据，左结点，右结点）
    private class Node {
        //层序
        private int key;
        //结点中存储的数据
        private Object data;
        //左右子树
        private Node leftNode;
        private Node rightNode;
        private boolean isVisted = false;

        //空的构造方法
        public Node() {
        }

        public Node(int key, Object data) {
            this.data = data;
            this.key = key;
            this.leftNode = null;
            this.rightNode = null;
        }
    }

    //2、创建根节点(构造函数)
    public AlvinTree() {
        root = new Node(1, "A");
    }

    //3、创建一棵树
    public void creatTree(Node root) {
        Node nodeb = new Node(2, "B");
        Node nodec = new Node(3, "C");
        Node noded = new Node(4, "D");
        Node nodee = new Node(5, "E");
        Node nodef = new Node(6, "F");
        Node nodeg = new Node(7, "G");
        root.leftNode = nodeb;
        root.rightNode = nodec;
        root.leftNode.leftNode = noded;
        root.leftNode.rightNode = nodee;
        nodec.leftNode = nodef;
        nodef.rightNode = nodeg;
       /*           A
            B               C
        D       E       F
                      G
       树的结构图
        */
    }

    //4、树的高度（利用递归思想）
    public int height() {
        return height(root);
    }

    public int height(Node node) {
        //空树高度为0
        if (node == null) {
            return 0;
        } else {
            //左右子树的高度
            int l = height(node.leftNode);
            int r = height(node.rightNode);
            //三元运算符，哪边的树高为哪边
            return l < r ? (r + 1) : (l + 1);
        }
    }

    //5、结点的数量
    public int size() {
        return size(root);
    }

    public int size(Node node) {
        if (node == null) {
            return 0;
        } else {
            //利用递归的思想，只要存在子节点就加1
            return 1 + size(node.leftNode) + size(node.rightNode);
        }
    }

    //6、查找双亲结点（如果A结点是B结点的子节点，则B是A的双亲）
    public Node parent(Node node) {
        return (node == null || root == node) ? null : parent(root, node);
    }

    /*
    按照从上往下，先左子树后右子树的方法去从root结点向下寻找双亲结点
    up:上级结点，index要查找的结点
    如果找到了双亲就返回双亲结点，否则返回null
     */
    public Node parent(Node up, Node index) {
        //老规矩，先判断是否为空
        if (up == null) {
            return null;
        }
        //如果上级结点up是双亲，则返回up
        if (up.leftNode == index || up.rightNode == index) {
            return up;
        }
        //否则先查找左子节点，后右子节点
        Node parent;
        if ((parent = parent(up.leftNode, index)) != null) {
            return parent;
        } else {
            return parent(up.rightNode, index);
        }

    }

    //7、返回左孩子
    public Node getLeftChild(Node node) {
        return (node.leftNode != null) ? node.leftNode : null;
    }

    //8、返回右孩子
    public Node getRightChild(Node node) {
        return (node.rightNode != null) ? node.rightNode : null;
    }

    //9、返回根节点
    public Node getRoot() {
        return root;
    }

    //10、删除某个结点（删除结点需要保证其下的子结点全部删除
    public void delete(Node node) {
        if (node != null) {
            delete(node.leftNode);
            delete(node.rightNode);
            node = null;
        }
    }

    public void visit(Node node){
        node.isVisted=true;
        System.out.println("结点"+node.key+"信息："+node.data);
    }

    //11、前序遍历：根节点，左结点，右结点
    public void preorder(Node node){
        if(node!=null){
            visit(node);
            preorder(node.leftNode);
            preorder(node.rightNode);
        }
    }
    //12、中序遍历：左根右
    public void inorder(Node node){
        if (node!=null){
            inorder(node.leftNode);
            visit(node);
            inorder(node.rightNode);
        }
    }
    //13、后续遍历
    public void postorder(Node node){

        if(node!=null){
            postorder(node.leftNode);
            postorder(node.rightNode);
            visit(node);
        }
    }

    public static void main(String[] args) {
        AlvinTree alvinTree=new AlvinTree();
        alvinTree.creatTree(alvinTree.root);
        System.out.println("size:"+alvinTree.size());
        System.out.println("height:"+alvinTree.height());


    }
}