Java学习笔记＜十六＞(树形结构存储)

1.树形结构的介绍

 * 树形结构简介
 * 树形结构是一种非线性结构，存储的是“一对多的”关系的数据元素的集合
 *
 * 树形结构的相关术语：
 * 节点（Node）：使用树结构存储的每一个数据元素都被称为“节点”
 * 节点的度（Degree of Node）：某个节点所拥有的子树的个数
 * 树的深度（Degree of Tree）：树中节点的最大层数
 * 叶子节点（Leaf Node）：度为0的节点，也叫终端节点
 * 分支节点（Branch Node）：度不为0的节点，也叫非终端节点或内部节点
 * 孩子（child）：也可称之为子树或子节点，表示当前节点下层的直接节点
 * 双亲（parent）：也可称为父节点，表示当前节点的直接上层节点
 * 根节点（Root Node）：没有双亲节点的节点，在树形结构中只有一个根节点
 * 祖先（Ancestor）：当前节点上层的所有节点（当前节点的直接祖先节点）
 * 子孙（Descendent）：当前节点下层的所有节点
 * 兄弟（Brother）：同一双亲孩子
 *
 * 二叉树简介
 * 二叉树（Binary Tree）是树形结构的重要类型
 * 二叉树特点是每个节点最多只能有两颗子树，且有左右之分
 *
 * 二叉树分类
 * 满二叉树：除最后一层外，每一层上的所有节点都有两个子节点
 * 完全二叉树：除最后一层可能不满外，其他各层都达到该层节点的最大数，最后一层如果不满，该层节点全部靠左排
 *
 * 二叉树遍历方式
 * 前序遍历：根-左-右
 * 中序遍历：左-根-右
 * 后序遍历：左-右-根
 * 层序遍历：从上至下逐层遍历

2.树形结构容器类--递归方法的使用--this关键字的指向

package DataStructure_8;

//树形结构容器类--递归方法的使用--this关键字的指向

/**
 * 自定义树形结构容器：
 * 能够找到当前节点的父节点
 * 能够找到当前节点的子节点
 * 能够找到当前节点的兄弟节点
 * 能够找到当前节点的祖先节点
 * 能够找到当前节点的子孙节点
 *
 */

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 基于树形结构实现元素存储的容器
 */
//一个节点就是一个元素
public class Text5<E> {

    //子节点映射父节点
    private Map<E,E> aa=new HashMap<>();
    //父节点映射子节点
    private Map<E,List<E>> bb=new HashMap<>();


    //向容器中添加元素的方法
    private void add(E parent,E item){          //参数为父节点和子节点，每个节点就是一个元素
        //完成单节点之间的映射，子节点映射父节点
        this.aa.put(item,parent);
        //完成多节点之间的映射，父节点映射子节点
        List<E> list=this.bb.get(parent);
        //判断装载子节点的容器是否为空，为空则创建新list容器装载子节点
        if (list==null){
            list=new ArrayList<>();
            this.bb.put(parent,list);       //将新创建的list容器赋给父节点的value
        }
        list.add(item);     //为list容器添加子节点元素

    }

    //根据当前节点获取其父节点
    private E getParent(E item){
        return this.aa.get(item);
    }

    //获取当前节点的子节点
    private List<E> getChild(E item){
        return this.bb.get(item);
    }

    //获取当前节点的兄弟节点
    private List<E> getBrother(E item){
        //获取当前节点的父节点
        E parent=this.getParent(item);
        //获取当亲节点的子节点容器
        List<E> list=this.getChild(parent);
        //list容器中的子节点不能删除，否则子节点会被永久删除
        List<E> brother=new ArrayList<>();
        if (brother != null){           //新建ArrayList对象为[]，不为null
            brother.addAll(list);
            brother.remove(item);
        }
        return brother;
    }

    //获取当前节点的祖先节点
    private List<E> getFullFathers(E item){
        //获取当前节点的父节点
        E parent=this.getParent(item);
        //递归终止条件
        if (parent==null){
            return new ArrayList<>();       //此处return直接返回ArrayList容器对象
        }
        List<E> list=this.getFullFathers(parent);
        list.add(parent);
        return list;
    }

    //获取当前节点的子孙节点
    private List<E> getGrandChild(E item){
        //创建容器装载当前节点所有子孙节点
        List<E> list= new ArrayList<>();

        List<E> child=this.getChild(item);
        if (child==null){
            return list;
        }
        for (int i = 0; i <child.size() ; i++) {
            E ele = child.get(i);
            List<E> temp =this.getGrandChild(ele);      //将list易容成temp，list就是temp，返回的list，与temp等同
            temp.add(ele);           //因为list与temp等同，所以此处使用谁都行
            list.addAll(temp);      //list不能与list求并集，因此使用temp代替list
        }
        return list;
    }

    public static void main(String[] args) {

        Text5<String> uu=new Text5<>();

        uu.add("root","生物");
        uu.add("生物","植物");
        uu.add("生物","动物");
        uu.add("生物","动物");
        uu.add("动物","脊索动物");
        uu.add("动物","脊椎动物");
        uu.add("动物","肠腔动物");
        uu.add("脊椎动物","哺乳动物");
        uu.add("脊椎动物","鱼类");
        uu.add("哺乳动物","猫");
        uu.add("哺乳动物","牛");
        uu.add("哺乳动物","人");

        System.out.println("========获取当前节点的父节点=========");
        String aa = uu.getParent("鱼类");
        System.out.println(aa);

        System.out.println("========获取当前节点的父节点=========");
        List<String> bb = uu.getChild("脊椎动物");
        for (int i = 0; i <bb.size() ; i++) {
            System.out.println(bb.get(i));
        }

        System.out.println("==========获取兄弟节点==================");
        List<String> cc=uu.getBrother("动物");
        for (int i = 0; i < cc.size(); i++) {
            System.out.println(cc.get(i));
        }

        System.out.println("===========获取祖先节点================");
        List<String> dd = uu.getFullFathers("人");
        for (int i = 0; i <dd.size() ; i++) {
            System.out.println(dd.get(i));
        }

        System.out.println("============获取子孙节点==============");
        List<String> ff=uu.getGrandChild("root");
        for (int i = 0; i <ff.size() ; i++) {
            System.out.println(ff.get(i));
        }

    }
}