java_数据结构_基于树形结构存储元素的容器_自定义实现

用到的树的结构示意图

基于树形结构存储元素的容器

代码实例：

package tree;

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

/**
 *基于树形结构存储元素的容器
 */
public class MyTree <E> {
    private Map<E,E> map = new HashMap<>();   //String-->String
    private Map<E,List<E>> map1 = new HashMap<>();    //String-->List


    /**
     * 向容器中添加元素
     */
    public void add(E parent,E item){
        //完成多结点之间的映射
        map.put(item,parent);
        //完成多结点之间的映射
        List<E> list = this.map1.get(parent);
        //判断当前结点的父结点是否存在子结点
        if (list == null){
            list = new ArrayList<>();
            this.map1.put(parent,list);

        }
        list.add(item);

    }
    /**
     * 获取当前结点的父结点
     */
    public E getParent(E item){
        return this.map.get(item);
    }
    /**
     * 获取当前结点的子结点
     */
    public List<E> getChild(E item){
        return this.map1.get(item);
    }

    /**
     * 获取当前结点的兄弟结点
     */
    public List<E> getBrother(E item){
        //先获取父结点
        E parent = this.getParent(item);
        // 再通过父结点获取子结点
        List<E> list = this.getChild(parent);
        List<E> bro = new ArrayList<>();
        // 然后删除自身
        if (list != null)
            bro.addAll(list);
            bro.remove(item);
        return bro;
    }
    /**
     * 获取当前结点的祖先结点
     */
    public List<E> getForfathers(E item){
        //获取当前结点的父亲结点
        E parent = this.getParent(item);
        //结束递归的边界条件
        if(this.getParent(parent) == null){
             return new ArrayList<>();
        }
        List<E> list = this.getForfathers(parent);
        list.add(parent);
        return list;
    }
    /**
     * 获取当前结点的子孙结点
     */
    public List<E> getGrandChildren(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.getGrandChildren(ele);
            list.add(ele);
            list.addAll(temp);
        }
        return list;
    }

    public static void main(String[] args) {
        //实例化容器
        MyTree<String> myTree = new MyTree<>();

        //添加元素
        myTree.add("root", "生物");
        myTree.add("生物", "动物");
        myTree.add("生物", "植物");
        myTree.add("生物", "菌类");
        myTree.add("动物", "脊索动物");
        myTree.add("动物", "脊椎动物");
        myTree.add("动物", "腔肠动物");
        myTree.add("脊椎动物", "哺乳动物");
        myTree.add("脊椎动物", "鱼类");
        myTree.add("哺乳动物", "🐱");
        myTree.add("哺乳动物", "🐂");
        myTree.add("哺乳动物", "人");

        System.out.println("----获取父结点---");
        String parent = myTree.getParent("鱼类");
        System.out.println("鱼类的父节点："+parent);
        System.out.println("---获取子结点---");
        List<String> child = myTree.getChild("哺乳动物");
        System.out.println("哺乳动物的子结点：");
        for (String s:child){
            System.out.println(s);
        }
        System.out.println("---获取兄弟结点---");
        System.out.println("生物的兄弟结点：");
        List<String> bro = myTree.getBrother("动物");
        for (String s1:bro){
            System.out.println(s1);
        }
        System.out.println("---获取祖先结点---");
        System.out.println("鱼类的祖先结点：");
        List<String> forfather = myTree.getForfathers("鱼类");
        for(String s2:forfather){
            System.out.println(s2);
        }
        System.out.println("---获取子孙结点---");
        System.out.println("动物的子孙结点：");
        List<String> grandchildren = myTree.getGrandChildren("动物");
        for (String s3:grandchildren){
            System.out.println(s3);
        }
    }
}

运行结果：

----获取父结点—
鱼类的父节点：脊椎动物
—获取子结点—
哺乳动物的子结点：
🐱
🐂
人
—获取兄弟结点—
生物的兄弟结点：
植物
菌类
—获取祖先结点—
鱼类的祖先结点：
生物
动物
脊椎动物
—获取子孙结点—
动物的子孙结点：
脊索动物
脊椎动物
哺乳动物
🐱
🐂
人
鱼类

----获取父结点—
鱼类的父节点：脊椎动物
—获取子结点—
哺乳动物的子结点：
🐱
🐂
人
—获取兄弟结点—
生物的兄弟结点：
植物
菌类
—获取祖先结点—
鱼类的祖先结点：
生物
动物
脊椎动物
—获取子孙结点—
动物的子孙结点：
脊索动物
脊椎动物
哺乳动物
🐱
🐂
人
鱼类
腔肠动物