树-二叉树存储及遍历

一、二叉树的概述

二、树和二叉树的区别

　　1、普通树中节点的最大度数没有限制，而二叉树节点的最大度数是2。

　　2、无序树的节点无左右之分，而二叉树的节点有左右之分，也就是二叉树的是有序树

三、满二叉树

　　如果它包含了2的整指数节点，就是满二叉树，满二叉树的特点是每一层上的节点数都是最大节点数，即各层节点数分别为1、2、4、8、16...2的k-1次方

 四、完全二叉树

　　如果一棵二叉树除最后一层外，就其余层的所有节点都是满的，并且最后一层或者是满的，或者仅仅在右边缺少若干连续的节点，这就是完全二叉树。

 五、二叉树的性质

　　1、二叉树第i层上的节点数目至多为2的i-1次方。

　　2、深度为k的二叉树总共的节点数为：至多有2的k次方-1个节点

　　3、在任何一棵二叉树中，如果其叶子节点的数量为n0，度（节点拥有子树的个数）为2的子节点数量为n2

　　4、具有n个节点的完全二叉树的深度为deep=log2 n +1；

　　

六、二叉树-顺序存储

　　顺序存储指的是充分利用满二叉树的特性，每层的节点数分别是1、2、4、8.......2的i-1次方

 　　缺陷：如果右节点过多时会产生空间浪费，数组中会产生好多空余数组元素。

package com.zxc.TreeLearning.BinaryTreeLearning;

import org.junit.Test;

/**
 * Created by Administrator on 2018/2/19 0019.
 * 二叉树顺序存储
 */
public class BinaryTreeA {
    private Object[] datas;//使用数组来记录该树的所有节点
    private int DEFAULT_DEEP=8;//保存该树的深度
    private int arraySize;//二叉树中总节点的个数
    private int deep;

    public void init(String data){
        this.deep=DEFAULT_DEEP;
        this.arraySize=(int)Math.pow(2,deep)-1;//按照满二叉树开的节点个数
        datas=new Object[arraySize];
        datas[0]=data;
    }

    public void add(int index,String data,boolean left){
        if(datas[index]==null){
            throw new RuntimeException(index+"处节点为空，无法添加子节点");
        }
        if(2*index+1>=arraySize){//右越界左肯定越界，所以判断左节点
            throw new RuntimeException("树底层的数组已满，树越界异常");
        }
        if(left){//左节点
            datas[2*index+1]=data;
        }else{//右节点
            datas[2*index+2]=data;
        }
    }

    /**
     *
     * @param index:父节点索引
     * @return 返回左子节点的数据
     */
    public String left(int index){
        return datas[2*index+1].toString();
    }

    /**
     *
     * @param index:父节点索引
     * @return 返回右子节点的数据
     */
    public String right(int index){
        return datas[2*index+2].toString();
    }

    @Test
    public void test(){
        this.init("A");
        this.add(0,"B",true);
        this.add(0,"C",false);
        System.out.println(this.left(0));
        System.out.println(this.right(0));
    }
}

 七、二叉链式存储

利用链表特性，每个节点都有左节点和右节点

package com.zxc.TreeLearning.BinaryTreeLearning;

import org.junit.Test;
import sun.reflect.generics.tree.Tree;

/**
 * Created by Administrator on 2018/2/20 0020.
 * 二叉链表存储
 */
public class BinaryTreeB {
    public static class TreeNode{
        String data;
        TreeNode left;
        TreeNode right;

        public TreeNode() {
        }

        public TreeNode(String data) {
            this.data = data;
        }

        public TreeNode(String data, TreeNode left, TreeNode right) {
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }
    //根节点
    private TreeNode root;



    /**
     *
     * @param parent 父节点对象
     * @param data  新增节点数据
     * @param isLeft  是否为新增左子节点
     * @return 返回新增的节点
     */
    public TreeNode addNode(TreeNode parent,String data,boolean isLeft){
        if(parent==null){
            System.out.println("不能增加子节点，父节点为空");
            return null;
        }
        if(isLeft&&parent.left!=null){
            System.out.println("左子节点已经存在，不能增加子节点");
            return null;
        }
        if(!isLeft&&parent.right!=null){
            System.out.println("右子节点已经存在，不能添加");
            return null;
        }

        TreeNode node=new TreeNode(data);
        if(isLeft){
            parent.left=node;
        }else{
            parent.right=node;
        }
        return node;
    }

    /**
     *
     * @param parent 父节点对象
     * @return 返回左子节点数据
     */
    public String leftChild(TreeNode parent){
        if(parent==null){
            throw new RuntimeException(parent+"节点为null，无法添加子节点");
        }
        return parent.left==null?null:(String)parent.left.data;
    }

    /**
     *
     * @param parent 需要查询的父节点对象
     * @return 返回右子节点数据
     */
    public String rightChild(TreeNode parent){
        if(parent==null){
            throw new RuntimeException(parent+"节点为null，无法添加子节点");
        }
        return parent.left==null?null:(String)parent.right.data;
    }

    /**
     *
     * @param node:判断的当前节点
     * @return ：当前节点的深度
     */
    public int deep(TreeNode node){
        if(node==null){
            return 0;
        }
        if(node.left==null&&node.right==null){
            return 1;
        }

        int leftdeep=deep(node.left);
        int rightdeep=deep(node.right);
        int max=0;
        max=leftdeep>rightdeep?leftdeep:rightdeep;
        return ++max;
    }

    public void init(String data){
        this.root=new TreeNode(data);
        TreeNode a=this.addNode(this.root,"A",true);
        TreeNode b=this.addNode(this.root,"B",false);
        TreeNode c=this.addNode(a,"C",true);
        TreeNode d=this.addNode(a,"D",false);
        System.out.println(this.leftChild(a));
        System.out.println(this.rightChild(a));
        System.out.println(this.deep(a));
    }

    @Test
    public void test(){
        init("Root");
    }
}

缺陷：遍历树的时候效率不高，指定节点访问其父节点时也比较困难。

八、二叉树遍历　　

　　1、二叉树的先序遍历（DLR）

　　　　若二叉树为空，则不进行任何操作，否则

　　　　　　1、访问根节点

　　　　　　2、先序方式遍历左子树

　　　　　　3、先序遍历右子树

　　ABDECF

　　2、二叉树的中序遍历（LDR）  投影法遍历

　　　　若二叉树为空，则不进行任何操作，否则

　　　　　　1、中序遍历左子树

　　　　　　2、访问根节点

　　　　　　3、中序遍历右子树

　　3、二叉树的后序遍历（LRD）

　　　　若二叉树为空，则不进行任何操作，否则

　　　　　　1、后序遍历左子树

　　　　　　2、后序遍历右子树

　　　　　　3、访问根节点

结果为 DEBFCA

package com.zxc.TreeLearning.BinaryTreeLearning;

import org.junit.Test;

/**
 * Created by Administrator on 2018/2/20 0020.
 * 遍历二叉树，先序（DLR)，中序(LDR)，后序(LRD)
 */
public class BinaryTreeSearch {
    class TreeNode{
        private String data;
        private TreeNode leftNode;
        private TreeNode rightNode;
        public TreeNode(String data,TreeNode leftNode,TreeNode rightNode){
            this.data=data;
            this.leftNode=leftNode;
            this.rightNode=rightNode;
        }
        public String getData(){
            return data;
        }
        public TreeNode getLeftNode(){
            return leftNode;
        }
        public TreeNode getRightNode(){
            return rightNode;
        }
    }

    public void printNode(TreeNode node){
        System.out.println(node.getData());
    }

    //初始化二叉树
    /*
     *                     A
     *                 /        
     *              B             C
     *             /           /   
     *           D    E       F       G
     *            /             /
     *              H   I       J   P
     *
     */

    @Test
    public void init(){
        TreeNode D=new TreeNode("D",null,null);
        TreeNode H=new TreeNode("H",null,null);
        TreeNode I=new TreeNode("I",null,null);
        TreeNode E=new TreeNode("E",H,I);
        TreeNode B=new TreeNode("B",D,E);
        TreeNode J=new TreeNode("J",null,null);
        TreeNode P=new TreeNode("P",null,null);
        TreeNode F=new TreeNode("F",null,J);
        TreeNode G=new TreeNode("G",P,null);
        TreeNode C=new TreeNode("C",F,G);
        TreeNode A=new TreeNode("A",B,C);
        pre(A);
        System.out.println();
        middle(A);
        System.out.println();
        last(A);
        System.out.println();
    }

    /**
     * 先序遍历
     * @param node 从node处先序遍历
     */
    public void pre(TreeNode node){
        System.out.print(node.data);
        if(node.leftNode!=null){
            this.pre(node.leftNode);
        }
        if(node.rightNode!=null){
            this.pre(node.rightNode);
        }
    }

    /**
     * 中序排序
     * @param node 从node处开始中序遍历
     */
    public void middle(TreeNode node){
        if(node.leftNode!=null){
            this.middle(node.leftNode);
        }
        System.out.print(node.data);
        if(node.rightNode!=null){
            this.middle(node.rightNode);
        }

    }

    /**
     * 后序排序
     * @param node 从node处开始后序遍历
     */
    public void last(TreeNode node){
        if(node.leftNode!=null){
            this.last(node.leftNode);
        }
        if(node.rightNode!=null){
            this.last(node.rightNode);
        }
        System.out.print(node.data);

    }
}

九、二叉树的深度、广度优先搜索

　　深度优先搜索就是先序遍历

　　广度优先搜索就是按照层，从根开始依次从左向右，从上到下进行遍历输出。

package com.zxc.TreeLearning.BinaryTreeLearning;

import org.junit.Test;
import sun.reflect.generics.tree.Tree;

import java.util.ArrayDeque;
import java.util.Stack;

/**
 * Created by Administrator on 2018/2/20 0020.
 * 遍历二叉树，先序（DLR)，中序(LDR)，后序(LRD)
 */
public class BinaryTreeDW {
    class TreeNode{
        private String data;
        private TreeNode leftNode;
        private TreeNode rightNode;
        public TreeNode(String data,TreeNode leftNode,TreeNode rightNode){
            this.data=data;
            this.leftNode=leftNode;
            this.rightNode=rightNode;
        }
        public String getData(){
            return data;
        }
        public TreeNode getLeftNode(){
            return leftNode;
        }
        public TreeNode getRightNode(){
            return rightNode;
        }
    }

    public void printNode(TreeNode node){
        System.out.println(node.getData());
    }

    //初始化二叉树
    /*
     *                     A
     *                 /        
     *              B             C
     *             /           /   
     *           D    E       F       G
     *            /             /
     *              H   I       J   P
     *
     */

    /**
     * 深度优先搜索，实际上就是一个DLR，即先序遍历
     */
    public void depthOrderTraversal(){
        if(this.root==null){
            System.out.println("不能深搜，因为没有根节点");
            return ;
        }
        Stack<TreeNode> stack=new Stack<>();
        stack.push(this.root);
        while(stack.isEmpty()!=true){
            TreeNode node= stack.pop();
            System.out.print(node.data);
            if(node.getRightNode()!=null){
                stack.push(node.rightNode);
            }
            if(node.getLeftNode()!=null){
                stack.push(node.leftNode);
            }
        }
    }

    /**
     * 广度优先搜索
     */
    public void levelOrderTraversal(){
        if(this.root==null){
            System.out.println("不能深度，因为没有根节点");
        }//使用队列功能，先进先出
        ArrayDeque<TreeNode> ad=new ArrayDeque();
        ad.add(this.root);
        while(!ad.isEmpty()){
            TreeNode node=ad.remove();
            System.out.println(node.data);
            if(node.leftNode!=null){
                ad.add(node.leftNode);
            }
            if(node.rightNode!=null){
                ad.add(node.rightNode);
            }
        }
    }

    private TreeNode root;
    @Test
    public void init(){
        TreeNode D=new TreeNode("D",null,null);
        TreeNode H=new TreeNode("H",null,null);
        TreeNode I=new TreeNode("I",null,null);
        TreeNode E=new TreeNode("E",H,I);
        TreeNode B=new TreeNode("B",D,E);
        TreeNode J=new TreeNode("J",null,null);
        TreeNode P=new TreeNode("P",null,null);
        TreeNode F=new TreeNode("F",null,J);
        TreeNode G=new TreeNode("G",P,null);
        TreeNode C=new TreeNode("C",F,G);
        TreeNode A=new TreeNode("A",B,C);
        root=A;
        depthOrderTraversal();
    }

}