有向图邻接表

邻接表有向图是指通过邻接表表示的有向图。

有向图可以理解为一种数据结构，处理特定场景的问题会比较简单

对于java来说，用map实现有向图比较便于进行查找操作。

实现有向图这种数据结构并不困难，难的是如何对有向图遍历。

下面代码中route是每一条有向的道路，它存在起始点和终点，唯一名称，长度等，town对应每个点，其中有一个包含所有以自身为起点的路的map集合

如果做不重复遍历一定要加限制条件，下面的后面两个方法（不包含递归的方法）就是以距离和经过的点的数量为限制进行遍历查找

/**
     * 选取两地间所有不重复的路线
     *
     * @param towns
     * @return
     */
    public LinkedList<String> findRoutesNonRepetitive(String towns) {
        // 处理参数
        String[] townArray = towns.toUpperCase().split("-");
        String beginName = townArray[0];
        if (!Utils.checkTownName(beginName, townsMap)) {
            System.out.println("起始城镇名称错误");
            return null;
        }
        String endName = townArray[1];
        if (!Utils.checkTownName(endName, townsMap)) {
            System.out.println("终点城镇名称错误");
            return null;
        }

        // 用于保存选取出的路线
        LinkedList<String> routeList = new LinkedList<>();
        // 用于标记已选过的路线
        LinkedList<String> flag = new LinkedList<>();

        selectRoutesByRecursionNonRepetitive(flag, beginName, endName, routeList);

        return routeList;
    }

 /**
     * 递归选出不重复路线
     *
     * @param flag
     * @param beginName
     * @param endName
     * @param routeList
     */
    public void selectRoutesByRecursionNonRepetitive(LinkedList<String> flag, String beginName, String endName, LinkedList<String> routeList) {
        // 遍历已存在的每一条线路
        for (String routeName : setAllRouteName) {
            if (routeName.startsWith(beginName)) {
                // 判断该路线是否存在于标记路线中，不存在，说明此路尚未走，则此路可选
                if (!flag.contains(routeName)) {
                    flag.add(routeName);
                    Route route = routeMap.get(routeName);
                    // 如果该路线的终点城镇名等于endName，则进行保存
                    if (route.getEndTownName().equals(endName)) {
                        String s = Utils.formatList(flag);
                        routeList.add(s);
                    }
                    // 将终点城镇赋值给起始城镇，递归遍历
                    beginName = route.getEndTownName();
                    selectRoutesByRecursionNonRepetitive(flag, beginName, endName, routeList);
                    // 递归之后要将起始城镇向前重置，并删除标记路线的最后一个节点
                    if (flag != null && flag.size() != 0) {
                        beginName = flag.removeLast().split("-")[0];
                    }
                }
            }
        }
    }

    /**
     * 以站点数量为限制选取可重复路线
     *
     * @param i
     * @param towns
     */
    public LinkedList<String> selectRoutesByStops(int i, String towns) {
        // 处理参数
        int count = i;
        String[] townArray = towns.toUpperCase().split("-");
        String beginName = townArray[0];
        if (!Utils.checkTownName(beginName, townsMap)) {
            System.out.println("起始城镇名称错误");
            return null;
        }
        String endName = townArray[1];
        if (!Utils.checkTownName(endName, townsMap)) {
            System.out.println("终点城镇名称错误");
            return null;
        }

        // 用于保存选取出的路线
        LinkedList<String> routeList = new LinkedList<>();
        // 用于标记已选过的路线
        LinkedList<String> flag = new LinkedList<>();

        selectRoutesByRecursion(flag, beginName, endName, routeList, count, 0);

        return routeList;

    }

    /**
     * 递归选出可重复路线
     *
     * @param flag
     * @param beginName
     * @param endName
     * @param routeList
     * @param count     外部传入的限定值
     * @param sign      自身用于递归增长的判断值
     */
    public void selectRoutesByRecursion(LinkedList<String> flag, String beginName, String endName, LinkedList<String> routeList, int count, int sign) {

        // 遍历已存在的每一条线路
        for (String routeName : setAllRouteName) {
            sign++;
            // 自身递归小于等于限定值时，可以继续递归
            if (sign <= count) {
                if (routeName.startsWith(beginName)) {
                    flag.add(routeName);
                    Route route = routeMap.get(routeName);
                    // 如果该路线的终点城镇名等于endName，则进行保存
                    if (route.getEndTownName().equals(endName)) {
                        String s = Utils.formatList(flag);
                        routeList.add(s);
                    }
                    // 将终点城镇赋值给起始城镇，递归遍历
                    beginName = route.getEndTownName();
                    selectRoutesByRecursion(flag, beginName, endName, routeList, count, sign);
                    // 递归之后要将起始城镇向前重置，并删除标记路线的最后一个节点
                    if (flag != null && flag.size() != 0) {
                        beginName = flag.removeLast().split("-")[0];
                    }
                }
            }
            sign--;
        }
    }


    /**
     * 以总距离为限制选取可重复路线
     *
     * @param i
     * @param towns
     */
    public LinkedList<String> findRoutesByDistance(int i, String towns) {
        // 处理参数
        int totalDistance = i;
        String[] townArray = towns.toUpperCase().split("-");
        String beginName = townArray[0];
        if (!Utils.checkTownName(beginName, townsMap)) {
            System.out.println("起始城镇名称错误");
            return null;
        }
        String endName = townArray[1];
        if (!Utils.checkTownName(endName, townsMap)) {
            System.out.println("终点城镇名称错误");
            return null;
        }

        // 用于保存选取出的路线
        LinkedList<String> routeList = new LinkedList<>();
        // 用于标记已选过的路线
        LinkedList<String> flag = new LinkedList<>();

        queryRoutesByDistance(flag, beginName, endName, routeList, totalDistance, 0);

        return routeList;

    }

    /**
     * 根据距离，递归选出不重复路线
     *
     * @param flag
     * @param beginName
     * @param endName
     * @param routeList
     * @param totalDistance 外部传入的限定值
     * @param distance      自身用于递归增长的判断值
     */
    public void queryRoutesByDistance(LinkedList<String> flag, String beginName, String endName, LinkedList<String> routeList, int totalDistance, int distance) {

        // 遍历已存在的每一条线路
        for (String routeName : setAllRouteName) {

            distance += getDistanceOfTown(routeName);
            // 路线距离小于最大距离时，可以继续递归
            if (distance < totalDistance) {
                if (routeName.startsWith(beginName)) {

                    flag.add(routeName);
                    Route route = routeMap.get(routeName);
                    // 如果该路线的终点城镇名等于endName，则进行保存
                    if (route.getEndTownName().equals(endName)) {
                        String s = Utils.formatList(flag);
                        routeList.add(s);
                    }
                    // 将终点城镇赋值给起始城镇，递归遍历
                    beginName = route.getEndTownName();
                    queryRoutesByDistance(flag, beginName, endName, routeList, totalDistance, distance);
                    // 递归之后要将起始城镇向前重置，并删除标记路线的最后一个节点
                    if (flag != null && flag.size() != 0) {
                        beginName = flag.removeLast().split("-")[0];
                    }
                }
            }
            distance -= getDistanceOfTown(routeName);
        }

    }

 

 

参考：http://www.cnblogs.com/skywang12345/