题目：
/** * The Problem: * * We have a list of tasks. Each task can depend on other tasks. * For example if task A depends on task B then B should run before A. * * Implement the "getTaskWithDependencies" method such that it returns a list of task names in the correct order. * * For example if I want to execute task "application A", the method should return a list with "storage,mongo,application A". * * List of Tasks: * * - name: application A * dependsOn: * - mongo * * - name: storage * * - name: mongo * dependsOn: * - storage * * - name: memcache * * - name: application B * dependsOn: * - memcache * * The Java program is expected to be executed succesfully. */
一开始的做法：
import java.io.*; import java.util.*; import org.junit.*; import org.junit.runner.*; public class Solution { private static List<String> getTaskWithDependencies(List<Task> tasks, String dependsOn) { // TODO: please implement logic here //定义 int numCourses = tasks.size(); boolean[] visited = new boolean[numCourses]; Stack<String> stack = new Stack<>(); //判断 //v是课程的数量 0-4 for (int i = 0; i < numCourses; i++) { //有环就是空 if (!topologicalSort(tasks, i, tasks.get(i).getName(), stack, visited, new boolean[numCourses])) return new ArrayList<>(); } //定义结果 //int[] result = new int[numCourses]; List<String> result = new ArrayList<>(); //往里面加 while (!stack.isEmpty()) { result.add(stack.pop()); } return result; } private static boolean topologicalSort(List<Task> adj, int taskIndex, String taskName, Stack<String> stack, boolean[] visited, boolean[] isLoop) { //提前判断一下 if (visited[taskIndex]) return true; if (isLoop[taskIndex]) return false; //设定v是有循环的，因为v是大的[]，就分析这么一次。类比，task是大的，就分析一次。所以signature要改。 isLoop[taskIndex] = true; //u需要具体问题具体分析。有回路就是false。类比，name需要具体问题具体分析。 //所以怎么迁移到这道题呢？adj.get(v)是Task。那都换成Task不就行了？ //两个不一样类型。。。注释掉会不会有影响？会，主要是中途false了就不能加了。一直是true才能加 //别用for each循环不就行了 if (!adj.get(taskIndex).getDependsOn().isEmpty()) { if (!topologicalSort(adj, taskIndex, adj.get(taskIndex).getDependsOn().toString(), stack, visited, isLoop)) {System.out.println("false here"); return false;} } else { if (!topologicalSort(adj, taskIndex, "", stack, visited, isLoop)) {System.out.println("false here1"); return false;} } //访问完v了 visited[taskIndex] = true; //把课程加到stack里，后续要拿来排序。所以应该是string对吧。处理下就行了。 System.out.println("adj.get(taskIndex).getName() = " + adj.get(taskIndex).getName()); stack.push(adj.get(taskIndex).getName()); return true; } public static void main(String[] args) { JUnitCore.main("Solution"); } @Test public void testGetTaskDependenciesForApplicationA() { Assert.assertEquals( Arrays.asList( "storage", "mongo", "application A" ), getTaskWithDependencies(TaskList.getTasks(), "application A") ); } } /** * Definition of a Task */ class Task { private final String name; private final List<String> dependsOn; Task(String name) { this(name, new ArrayList<>()); } Task(String name, List<String> dependsOn) { this.name = name; this.dependsOn = dependsOn; } public String getName() { return this.name; } public List<String> getDependsOn() { return this.dependsOn; } } class TaskList { public static List<Task> getTasks() { List<Task> tasks = new ArrayList<>(); tasks.add(new Task("application A", Arrays.asList("mongo"))); tasks.add(new Task("storage")); tasks.add(new Task("mongo", Arrays.asList("storage"))); tasks.add(new Task("memcache")); tasks.add(new Task("application B", Arrays.asList("memcache"))); return tasks; } }
后来觉得不可行，把自定义的类放到递归中去，根本就无法debug。还是一开始就把自定义的类变成数字编号吧。问题是会出现两条路。
/** * The Problem: * * We have a list of tasks. Each task can depend on other tasks. * For example if task A depends on task B then B should run before A. * * Implement the "getTaskWithDependencies" method such that it returns a list of task names in the correct order. * * For example if I want to execute task "application A", the method should return a list with "storage,mongo,application A". * * List of Tasks: * * - name: application A * dependsOn: * - mongo * * - name: storage * * - name: mongo * dependsOn: * - storage * * - name: memcache * * - name: application B * dependsOn: * - memcache * * The Java program is expected to be executed succesfully. */ import java.io.*; import java.util.*; import org.junit.*; import org.junit.runner.*; public class Solution { private static List<String> getTaskWithDependencies(List<Task> tasks, String dependsOn) { // TODO: please implement logic here //定义输入数据。 int numTasks = 5; //如果需要转换，可以用hashmap对应string和编号 int prerequisites[][]={{0,1},{1,2},{4,3}}; //调用排序，获得result数组 int[] result = findOrder(numTasks, prerequisites); for (int i = 0; i < result.length; i++) { System.out.println("result[i] = " + result[i]); } //如果需要转换，可以用hashmap对应string和编号 ArrayList<String> res = new ArrayList<>(); res.add("storage"); res.add("mongo"); res.add("application A"); return res; } public static int[] findOrder(int numTasks, int[][] prerequisites) { List<List<Integer>> adj = new ArrayList<>(numTasks); for (int i = 0; i < numTasks; i++) adj.add(i, new ArrayList<>()); for (int i = 0; i < prerequisites.length; i++) adj.get(prerequisites[i][1]).add(prerequisites[i][0]); boolean[] visited = new boolean[numTasks]; Stack<Integer> stack = new Stack<>(); for (int i = 0; i < numTasks; i++) { if (!topologicalSort(adj, i, stack, visited, new boolean[numTasks])) return new int[0]; } int i = 0; int[] result = new int[numTasks]; while (!stack.isEmpty()) { result[i++] = stack.pop(); } return result; } private static boolean topologicalSort(List<List<Integer>> adj, int v, Stack<Integer> stack, boolean[] visited, boolean[] isLoop) { if (visited[v]) return true; if (isLoop[v]) return false; isLoop[v] = true; for (Integer u : adj.get(v)) { if (!topologicalSort(adj, u, stack, visited, isLoop)) return false; } visited[v] = true; stack.push(v); return true; } public static void main(String[] args) { JUnitCore.main("Solution"); } @Test public void testGetTaskDependenciesForApplicationA() { Assert.assertEquals( Arrays.asList( "storage", "mongo", "application A" ), getTaskWithDependencies(TaskList.getTasks(), "application A") ); } } /** * Definition of a Task */ class Task { private final String name; private final List<String> dependsOn; Task(String name) { this(name, new ArrayList<>()); } Task(String name, List<String> dependsOn) { this.name = name; this.dependsOn = dependsOn; } public String getName() { return this.name; } public List<String> getDependsOn() { return this.dependsOn; } } class TaskList { public static List<Task> getTasks() { List<Task> tasks = new ArrayList<>(); tasks.add(new Task("application A", Arrays.asList("mongo"))); tasks.add(new Task("storage")); tasks.add(new Task("mongo", Arrays.asList("storage"))); tasks.add(new Task("memcache")); tasks.add(new Task("application B", Arrays.asList("memcache"))); return tasks; } }
后来去stackoverflow上问了，获得这个答案（感谢德国的编辑，孟加拉国的好兄弟！世界码农一家亲！）
其实用递归就行了，递归来来去去就是一条路，根本不会出现两条路的情况。递归学得不到位啊！
/** * The Problem: * * We have a list of tasks. Each task can depend on other tasks. * For example if task A depends on task B then B should run before A. * * Implement the "getTaskWithDependencies" method such that it returns a list of task names in the correct order. * * For example if I want to execute task "application A", the method should return a list with "storage,mongo,application A". * * List of Tasks: * * - name: application A * dependsOn: * - mongo * * - name: storage * * - name: mongo * dependsOn: * - storage * * - name: memcache * * - name: application B * dependsOn: * - memcache * * The Java program is expected to be executed succesfully. */ import java.io.*; import java.util.*; import org.junit.*; import org.junit.runner.*; public class Solution { private static List<String> getTaskWithDependencies(List<Task> tasks, String dependsOn) { //初始化一个resultString StringBuilder resultString = new StringBuilder(); for (int i = 0; i < tasks.size(); i++) { System.out.println(tasks.get(i).getName()); } //筛选出必须有name = dependsOn的每个人物自己 Task task = tasks.stream().filter(x -> dependsOn.equalsIgnoreCase(x.getName())) .findAny().get(); //如果非空 if (task.getDependsOn() != null && !task.getDependsOn().isEmpty()) { for (String newDependsOn : task.getDependsOn()) { //递归一下，递归栈越深的放前面。storage先append了，然后mongo List<String> res = getTaskWithDependencies(tasks, newDependsOn); //用逗号分隔结果 for (String ele : res) { resultString.append(ele).append(","); System.out.println(""); System.out.println("resultString = " + resultString); System.out.println(""); } } } //最后加上application A本身 resultString.append(dependsOn); System.out.println("resultString after append = " + resultString); return Arrays.asList(resultString.toString().split(",")); } public static void main(String[] args) { JUnitCore.main("Solution"); } @Test public void testGetTaskDependenciesForApplicationA() { Assert.assertEquals( Arrays.asList( "storage", "mongo", "application A" ), getTaskWithDependencies(TaskList.getTasks(), "application A") ); } } /** * Definition of a Task */ class Task { private final String name; private final List<String> dependsOn; Task(String name) { this(name, new ArrayList<>()); } Task(String name, List<String> dependsOn) { this.name = name; this.dependsOn = dependsOn; } public String getName() { return this.name; } public List<String> getDependsOn() { return this.dependsOn; } } class TaskList { public static List<Task> getTasks() { List<Task> tasks = new ArrayList<>(); tasks.add(new Task("application A", Arrays.asList("mongo"))); tasks.add(new Task("storage")); tasks.add(new Task("mongo", Arrays.asList("storage"))); tasks.add(new Task("memcache")); tasks.add(new Task("application B", Arrays.asList("memcache"))); return tasks; } }
打印的log：
JUnit version 4.13.2 .application A storage mongo memcache application B application A storage mongo memcache application B application A storage mongo memcache application B resultString after append = storage resultString = storage, resultString after append = storage,mongo resultString = storage, resultString = storage,mongo, resultString after append = storage,mongo,application A Time: 0.015 OK (1 test)
使用Stream的filter进行过滤，eg只保留男性。
Stream<Person> personStream = collection.stream().filter( person -> "男".equals(person.getGender())//只保留男性 );
教程：https://blog.csdn.net/qq_33829547/article/details/80279488