菜单的遍历--树形结构

树形结构

一、题目信息

二、思路分析

1. MenuItem类：构建一个ArrayList的集合来存放每一个菜单名，包含当前菜单和子菜单，用于遍历（即打印菜单的操作），【ArrayList相比于LinkedList遍历的效率更高】
2. LinkedMenu类：建立一个LinkedList的集合来存放单层菜单，可以按照txt文件的顺序从上至下一次将每一个菜单名插入相应的层。用于插入操作【在插入操作较多的情况下LinkedList相比于ArrayList插入的效率更高】，但是事实上，在此题目中。我们在把每一个菜单选项插入相应的层时都是插入在层的末尾，因而，在此前提下，使用ArrayList的用来做插入操作的实际效率是要高于LinkedList的。（此处选用LinkedList【考虑到现实中一般不会是次次插入在末尾】）
3. ReadFile：读取菜单列表的txt文档，将每一行的内容存入Link集合中，每一行（涵盖一个菜单名）作为集合中的一个元素
4. TreeBuild：构建菜单的树形结构。通过每一个菜单名前的空格数来判断当前遍历所在的菜单名时属于哪一层，并且将其插入相应的LinkedList集合的层中。并在上一层的末尾找到其父节点。

三、代码

1.MenuItem类：提供了菜单的结构体，包含当前菜单和子菜单

 package edu.moth11;

import java.util.ArrayList;
import java.util.List;

/**
 * 构建一个容纳菜单名的ArrayList结构，便于遍历
 */
public class MenuItem {
    //菜单名
    private String menuTitle;
    //子菜单集合,查询较多时用ArrayList
    private List<MenuItem> subMenu = new ArrayList<>();

    /**
     * 构造方法
     * @param menuTitle
     */
    public MenuItem(String menuTitle) {
        this.menuTitle = menuTitle;
    }

    /**
     * getter and setter
      * @return
     */
    public String getMenuTitle() {
        return menuTitle;
    }

    public void setMenuTitle(String menuTitle) {
        this.menuTitle = menuTitle;
    }

    public List<MenuItem> getSubMenu() {
        return subMenu;
    }

    public void setSubMenu(List<MenuItem> subMenu) {
        this.subMenu = subMenu;
    }

    /**
     * 打印当前目录以及子目录
     */
    public void printMenu(){
        //打印目录名
        System.out.println(menuTitle);

        //递归打印子目录
        for (int i = 0; i < subMenu.size(); i++) {
            subMenu.get(i).printMenu();
        }
    }
}

2. 构建一个菜单的LinkedList容器

package edu.moth11;

import java.util.LinkedList;

/**构建一个LinkedList结构，便于插入
 * 层结构
 * 将是属于同一个层的菜单列入一个集合当中
 */
public class LinkedMenu {
    //定义了菜单名前的空格数
    private int preBlank_name = 0;

    private LinkedList<MenuItem> same_Level_Menu = new LinkedList<>();

    public LinkedMenu(int preBlank_name) {
        this.preBlank_name = preBlank_name;
    }

    public LinkedList<MenuItem> getSame_Level_Menu() {
        return same_Level_Menu;
    }

    public void add_MenuItem(MenuItem menuItem){
        same_Level_Menu.add(menuItem);
    }
}

3. 读取txt文件操作

package edu.moth11;
import java.io.*;
import java.util.ArrayList;
import java.util.List;


public class ReadFile {
    /**
     * 构建一个文件读取的方法，通过这个方法得到菜单名的一个集合，每一个菜单名（每一行）是集合中的一个元素
     * @param pathname
     * @return
     */
    public static List<String> readFile(String pathname) {
        String filePath = pathname;
        File file = new File(filePath);
        List<String> menu_Name = new ArrayList<>();
        if(file.exists()&&file.isFile()){
            try {
                BufferedReader br = new BufferedReader(new FileReader(file));
                String line = null;
                while ((line=br.readLine())!=null)
                    menu_Name.add(line);
                br.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }catch(IOException e){
                e.printStackTrace();
            }

        }
        return menu_Name;
    }
}

4. 构建菜单的树形结构

package edu.moth11;

import java.util.ArrayList;
import java.util.List;

public class TreeBuild {

    public static int getLevels(String s){
        int pre=0;
        int level = 0;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(s.charAt(i) == ' ')
                pre++;
            else break;
        }
        level = pre/4;
        return level;
    }
    public static List<LinkedMenu> createMenuTree(List<String> strings){
        //创建一个以单个层为元素的集合容器
        List<LinkedMenu> menuTree=new ArrayList<>();
        //定义pre为菜单名前的空格数
        int level=0;
        for (int i = 0;i < strings.size();i++){
            String s = strings.get(i);
            //获取菜单名前的空格数
            level = getLevels(s);

            MenuItem menuItem=new MenuItem(s);

            /**
             * 如果level对应的层已经存在，则将遍历到的菜单名加入该层
             * 如果该层不存在，则建立新的层，并将遍历得到的菜单名加入新的层
             */
            if(level<menuTree.size()){
                menuTree.get(level).add_MenuItem(menuItem);
            }else{
                //新建一层菜单
                LinkedMenu linkedMenu=new LinkedMenu(level);
                //将新建的那层菜单加入菜单树结构的下一层
                menuTree.add(linkedMenu);
                //将遍历到的MenuItem对象添加到新的菜单层里
                linkedMenu.add_MenuItem(menuItem);
            }

            if (level>0){
                //获取上一层的最后一个,即父节点
                MenuItem father=menuTree.get(level-1).getSame_Level_Menu().getLast();
                //再将其加入父节点的子节点中
                father.getSubMenu().add(menuItem);
            }
        }
        return menuTree;
    }
}

5. 运行类，包含main方法

package edu.moth11;

import java.io.FileReader;
import java.util.List;

public class TestMain {
    public static void main(String[] args) {
        List<String> list = ReadFile.readFile("D://TurboC.txt");
        List<LinkedMenu> linkedMenus = TreeBuild.createMenuTree(list);
        for (int i = 0; i < linkedMenus.get(0).getSame_Level_Menu().size(); i++) {
            MenuItem menuItem =  linkedMenus.get(0).getSame_Level_Menu().get(i);
            menuItem.printMenu();
        }
    }
}

四、运行结果