数据结构之二叉树

二叉树的实现及其主要方法

一、二叉树的分类
(1)完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。
(2)满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。
(3)平衡二叉树——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

二、Java实现二叉树
(1)二叉树的节点实现

package com.dxx.tree;
/** 
 *二叉树的节点
 * @author dxx
 * @version 2017-10-20  
 */
public class Node {
    //关键字（索引）
    private int keyData;
    //其他数据
    private int otherData;
    //左子节点
    private Node leftNode;
    //右子节点
    private Node rightNode;

    public Node(int keyData, int otherData) {
        this.keyData = keyData;
        this.otherData = otherData;
    }
    public int getKeyData() {
        return keyData;
    }
    public void setKeyData(int keyData) {
        this.keyData = keyData;
    }
    public int getOtherData() {
        return otherData;
    }
    public void setOtherData(int otherData) {
        this.otherData = otherData;
    }
    public Node getLeftNode() {
        return leftNode;
    }
    public void setLeftNode(Node leftNode) {
        this.leftNode = leftNode;
    }
    public Node getRightNode() {
        return rightNode;
    }
    public void setRightNode(Node rightNode) {
        this.rightNode = rightNode;
    }

    /**
     * 其他方法
     */
    public void display(){
        System.out.println(this.keyData+" "+this.getKeyData());
    }
}

(2)二叉树的实现及其主要方法

package com.dxx.tree;
/** 
 *二叉树的一些方法
 * @author dxx 
 * @version 2017-10-20  
 */
public class Tree {
    //根节点
    private Node root;

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    /**
     * 插入方法
     */
    public void insert(int keyData,int otherData){
        Node newNode=new Node(keyData, otherData);
        if(root==null){
            root=newNode;
        }else{
            //当前节点
            Node current=root;
            Node parent;
            while(true){
                //设置该次循环的父节点
                parent =current;
                //判断在左边还是右边
                if(keyData<current.getKeyData()){
                    current=current.getLeftNode();
                    if(current==null){
                        parent.setLeftNode(newNode);
                        return;
                    }
                }else{
                    current=current.getRightNode();
                    if(current==null){
                        parent.setRightNode(newNode);
                        return;
                    }
                }
            }
        }
    }

    /**
     * 查找节点
     */
    public Node find(int keyData){
        Node current =root;
        while(current.getKeyData() !=keyData){
            if(keyData<current.getKeyData()){
                current=current.getLeftNode();
            }else if(keyData>current.getKeyData()){
                current=current.getRightNode();
            }
            if(current==null){
                return null;
            }
        }
        //返回当前节点
        return current;
    }

    /**
     * 先序遍历
     * 核心思想：访问节点--->递归遍历左子树--->递归遍历右子树
     */
    public void beforeOrder(Node node){
        if(node!=null){
            node.display();
            beforeOrder(node.getLeftNode());//递归遍历左子树
            beforeOrder(node.getRightNode());//递归遍历右子树
        }
    }

    /**
     * 中序遍历
     * 核心思想：递归遍历左子树--->访问节点--->递归遍历右子树
     */
    public void middleOrder(Node node){
        if(node!=null){
            middleOrder(node.getLeftNode());//递归遍历左子树
            node.display();
            middleOrder(node.getRightNode());//递归遍历右子树
        }
    }

    /**
     * 后序遍历
     * 核心思想：访问节点--->递归遍历右子树--->递归遍历左子树
     */
    public void afterOrder(Node node){
        if(node!=null){
            node.display();
            beforeOrder(node.getRightNode());//递归遍历右子树
            beforeOrder(node.getLeftNode());//递归遍历左子树
        }
    }

    /**
     * 反转二叉树
     * 核心思想：使用递归逐个节点反转
     */
    public void reversalTree(Node node){
        if(node!=null){
            Node temp=node.getLeftNode();
            node.setLeftNode(node.getRightNode());
            node.setRightNode(temp);
            reversalTree(node.getLeftNode());
            reversalTree(node.getRightNode());
        }
    }
}

三、测试
创建一个二叉树并测试：

package com.dxx.tree;
/** 
 *
 * @author dxx 
 * @version 2017-10-20 下午7:52:38 
 */
public class Test {
    public static void main(String[] args) {
        Tree tr=new Tree();
        tr.insert(36, 36);
        tr.insert(13, 13);
        tr.insert(27, 27);
        tr.insert(31, 31);
        tr.insert(53, 53);
        tr.insert(5, 5);
        tr.insert(17, 17);
        tr.insert(60, 60);
        tr.insert(42, 42);
        tr.insert(58, 58);
        tr.insert(9, 9);
        tr.insert(92, 92);
        tr.insert(82, 82);
        tr.insert(38, 38);
        //查找节点
        System.out.println(tr.find(36).getLeftNode().getOtherData());
        //先序遍历
        tr.beforeOrder(tr.getRoot());
        System.out.println();
        //中序遍历
        tr.middleOrder(tr.getRoot());
        System.out.println();
        //后序遍历
        tr.afterOrder(tr.getRoot());
        System.out.println();

        //二叉树反转
        tr.reversalTree(tr.getRoot());
        System.out.println("------以下是反转后的结果------");
        //查找节点
        System.out.println(tr.find(36).getLeftNode().getOtherData());
        //先序遍历
        tr.beforeOrder(tr.getRoot());
        System.out.println();
        //中序遍历
        tr.middleOrder(tr.getRoot());
        System.out.println();
        //后序遍历
        tr.afterOrder(tr.getRoot());
    }
}

二叉树图示：

“`
测试结果：