树状图的输出(递归转循环)

2401_86637493

于 2024-09-11 16:04:45 发布

阅读量96

点赞数 1

文章标签：服务器 windows linux

本文链接：https://blog.csdn.net/2401_86637493/article/details/142142657

版权

            "                    \"child\":[\n" +

            "\n" +

            "                    ]\n" +

            "                }\n" +

            "            ]\n" +

            "        },\n" +

            "        {\n" +

            "            \"name\":\"3\",\n" +

            "            \"child\":[\n" +

            "                {\n" +

            "                    \"name\":\"6\",\n" +

            "                    \"child\":[\n" +

            "\n" +

            "                    ]\n" +

            "                },\n" +

            "                {\n" +

            "                    \"name\":\"7\",\n" +

            "                    \"child\":[\n" +

            "\n" +

            "                    ]\n" +

            "                },\n" +

            "                {\n" +

            "                    \"name\":\"8\",\n" +

            "                    \"child\":[\n" +

            "\n" +

            "                    ]\n" +

            "                }\n" +

            "            ]\n" +

            "        }\n" +

            "    ]\n" +

            "}";





    Person person = new Gson().fromJson(json, Person.class);



    // 常规的递归

    Log.d(TAG, "------------------------------ 常用递归");

    printPerson(person);



    // 递归改循环（广度优先）（避免爆栈）

    Log.d(TAG, "------------------------------ 递归改循环（广度优先）");

    printPerson2(person);



    // 递归改循环（深度优先）（避免爆栈）

    Log.d(TAG, "------------------------------ 递归改循环（深度优先）");

    printPerson3(person);



    // 生成新的树状图对象（递归）

    Log.d(TAG, "------------------------------ 生成新的树状图对象（递归） ");

    Human human = printPerson4(person);

    Log.d(TAG, "human json: " + new Gson().toJson(human));



    // 生成新的树状图对象（循环）

    Log.e(TAG, "------------------------------ 生成新的树状图对象（循环） ");

    Human human2 = printPerson5(person);

    Log.e(TAG, "human2 json: " + new Gson().toJson(human2));



    // 递归改循环（广度优先）（避免爆栈）(加入深度)

    Log.d(TAG, "------------------------------ 归改循环（广度优先）（避免爆栈）(加入深度) ");

    printPerson6(person);

}



private void printPerson(Person person) {

    Log.d(TAG, person.getName());

    if (person.getChild() != null && person.getChild().size() != 0) {

        for (int i = 0; i < person.getChild().size(); i++) {

            printPerson(person.getChild().get(i));

        }

    }

}



private void printPerson2(Person rooPerson) {

    List<Person> personList = new ArrayList<>();



    personList.add(rooPerson);



    while (personList.size() != 0) {

        Person person = personList.remove(0);

        if (person == null) continue;

        Log.d(TAG, person.getName());

        if (person.getChild() != null && person.getChild().size() != 0) {

            personList.addAll(person.getChild());

        }

    }

}



private void printPerson3(Person rooPerson) {



    Stack<Person> stack = new Stack<>();

    stack.push(rooPerson);



    while (!stack.isEmpty()) {

        Person person = stack.pop();

        Log.d(TAG, person.getName());

        if (person.getChild() != null && person.getChild().size() != 0) {

            for (int i = person.getChild().size() - 1; i >= 0; i--) {

                stack.push(person.getChild().get(i));

            }

        }

    }

}



private Human printPerson4(Person rooPerson) {



    Human rootHuman = new Human();

    rootHuman.setName(rooPerson.getName());



    if (rooPerson.getChild() != null && rooPerson.getChild().size() != 0) {

        List<Human> humanList = new ArrayList<>();

        for (int i = 0; i < rooPerson.getChild().size(); i++) {

            humanList.add(printPerson4(rooPerson.getChild().get(i)));

        }

        rootHuman.setChild(humanList);

    }



    return rootHuman;

}



private static Human printPerson5(Person rooPerson) {

    List<Person> personList = new ArrayList<>();

    List<Human> humanList = new ArrayList<>();

    Human rootHuman = new Human();

    personList.add(rooPerson);

    humanList.add(rootHuman);

    while (personList.size() != 0) {

        Person person = personList.remove(0);

        Human human = humanList.remove(0);

        if (person == null) continue;

        human.setName(person.getName());

        //System.out.println(person.getName());

        if (person.getChild() != null && person.getChild().size() != 0) {

            personList.addAll(person.getChild());

            List<Human> list = new ArrayList<>();

            for (int i = 0; i < person.getChild().size(); i++) {

                Human h = new Human();

                list.add(h);

            }

            humanList.addAll(list);

            human.setChild(list);

        }

    }

    return rootHuman;

}



private void printPerson6(Person rooPerson) {

    DepthPerson rootDepthPerson = new DepthPerson();

    rootDepthPerson.setChild(rooPerson.getChild());

    rootDepthPerson.setIndex(rooPerson.getIndex());

    rootDepthPerson.setName(rooPerson.getName());

    rootDepthPerson.setDepth(1); // 初始 1



    List<DepthPerson> depthPersonList = new ArrayList<>();



    depthPersonList.add(rootDepthPerson);



    while (depthPersonList.size() != 0) {

        DepthPerson depthPerson = depthPersonList.remove(0);

        if (depthPerson == null) continue;

        Log.d(TAG, depthPerson.getName() + "  深度：" + depthPerson.getDepth());

        if (depthPerson.getChild() != null && depthPerson.getChild().size() != 0) {

            for (int i = 0; i < depthPerson.getChild().size(); i++) {

                Person person = depthPerson.getChild().get(i);

                DepthPerson temp = new DepthPerson();

                temp.setChild(person.getChild());

                temp.setIndex(person.getIndex());

                temp.setName(person.getName());

                temp.setDepth(depthPerson.getDepth() + 1); 

                depthPersonList.add(temp);

            }

        }

    }

}



// ---------------------------------------------------------------------------------------------

//

// Person 、 Human 两个实体类

//

// ---------------------------------------------------------------------------------------------



public static class Person {

    private int index;

    private String name;

    private List<Person> child;



    public int getIndex() {

        return index;

    }



    public void setIndex(int index) {

        this.index = index;

    }



    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    public List<Person> getChild() {

        return child;

    }



    public void setChild(List<Person> child) {

        this.child = child;

    }

}



public static class DepthPerson extends Person {



    private int depth;





    public int getDepth() {

        return depth;

    }



    public void setDepth(int depth) {

        this.depth = depth;

    }

}



public static class Human {

    private String name;

    private int depth;

    private List<Human> child;



    public Human() {

    }



    public String getName() {

        return name;

    }



    public void setName(String name) {

        this.name = name;

    }



    public int getDepth() {

        return depth;

    }



    public void setDepth(int depth) {

        this.depth = depth;

    }



    public List<Human> getChild() {

        return child;

    }



    public void setChild(List<Human> child) {

        this.child = child;

    }

}

}