平衡二叉树

平衡二叉树

 

public class BinaryTree {

    public Node root;
    

    /**
     * 内部类实现结点类，可提高安全性
     * 
     */
    static class Node{
        int data;
        Node left;
        Node right;
        Node(int newData){
            left = null;
            right = null;
            data = newData;
        }
    }


    /**
     * 创建一个空的二叉树
     */

    public BinaryTree() {
        root = null;
    }
    
    /**
     * 递归的插入数值
     * @param data    要插入的数值
     */

    public void insert(int data) {
        root = insert(root,data);
    }
    
    /**
     * 将数值插入到二叉树中，比当前结点小或等于当前结点的插在当前结点的左侧，比当前结点大的数插在当前结点的右侧，每次从根结点开始递归比较
     * @param node    当前的结点，就是根结点，只是每次根结点的左右子孙更新
     * @param data    要插入的数值
     * @return    新排好的二叉树
     */

    private Node insert(Node node, int data) {
        if(node == null){
            node = new Node(data);
        }else{
            if(data <= node.data){
                node.left = insert(node.left,data);
            }else{
                node.right = insert(node.right,data);
            }
        }
        
        return node;
    }
    
    /**
     * 将数值输入构建二叉树
     * @param data    要输入的数值
     */

    public void buildTree(int[] data) {
        for(int i=0; i<data.length; i++){
            insert(data[i]);
        }

    }
    
    /**
     * 递归打印出二叉树
     */

    public void printTree() {
        printTree(root);
        System.out.println();
    }
    
    /**
     * 从根结点开始遍历，从树的最高层叶子结点开始输出，从左至右
     * @param node    当前的结点
     */

    private void printTree(Node node) {
        if(node == null){
            return;
        }else{
            printTree(node.left);
            System.out.print(node.data+"  ");
            printTree(node.right);
        }
        
    }

}

对递归的理解：

  root = insert(root,data);

这行代码和

private Node insert(Node node, int data) {
        if(node == null){
            node = new Node(data);
        }else{
            if(data <= node.data){
                node.left = insert(node.left,data);
            }else{
                node.right = insert(node.right,data);
            }
        }
        
        return node;
    }

上面的函数确定了根节点一定是第一个输出的节点，且不论后面如何调用根节点始终保持不变，函数返回值和传入参数相等，传入根节点，返回一定也是根节点。
每次增加虽然总是返回根节点，但递归加深了叶子节点数，让更多的节点间接和根节点产生关联。因为随着递归的不断递进，肯定会出现 node==null，这时就
会新建节点，节点链接在相应位置上。

下面再分析打印程序：
打印程序也是递归结构的，递归的打印肯定类似逆序打印。上面的程序其实就是中序遍历。

测试用例：

import junit.framework.TestCase;

public class BinaryTreeTest extends TestCase {

    public void testBinaryTreeTest() {

        BinaryTree biTree = new BinaryTree();

        int[] data = {100,2,103, 8, 7,23};

        biTree.buildTree(data);

        biTree.printTree();
        System.out.println(biTree.root.data);
        System.out.println(biTree.root.left.data);
        System.out.println(biTree.root.left.right.data);
        System.out.println(biTree.root.left.right.left.data);
        System.out.println(biTree.root.left.right.right.data);
        
        System.out.println(biTree.root.right.data);
    }

}

结果输出：

2  7  8  23  100  103  
100
2
8
7
23
103

构建的平衡二叉树为：

                100        
//          /        \
//         2          103
//       /   \     
//            8
             / \   
            7   23