Java树结构遍历：按类型查找部门的递归与迭代实现

import java.util.List;
import java.util.Optional;
import java.util.function.Predicate;

public interface Department {
    String getName();
    String getType();

    // 初始尝试中的默认方法，用于匹配单个部门
    default Optional<Department> getMatchingDepartment(Predicate<Department> predicate) {
        if (predicate.test(this)) {
            return Optional.of(this);
        }
        return Optional.empty();
    }
}

public interface Company extends Department {
    List<Department> getDepartments();

    // 初始尝试中的默认方法，仅遍历直接子部门
    default Optional<Department> getMatchingDepartment(Predicate<Department> predicate) {
        // 首先检查当前Company自身是否匹配
        if (predicate.test(this)) {
            return Optional.of(this);
        }
        // 然后尝试在其直接子部门中查找第一个匹配项
        return getDepartments().stream()
                .map(department -> department.getMatchingDepartment(predicate))
                .filter(Optional::isPresent)
                .map(Optional::get)
                .findFirst();
    }
}

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

public class OrganizationSearch {

    // 假设 Concern 类中包含一个根部门列表
    private List<Department> rootDepartments;

    public OrganizationSearch(List<Department> rootDepartments) {
        this.rootDepartments = rootDepartments;
    }

    /**
     * 公共入口方法：通过递归查找所有指定类型的部门。
     * @param type 要查找的部门类型。
     * @return 匹配指定类型的所有部门列表。
     */
    public List<Department> findDepartmentByTypeRecursive(String type) {
        ArrayList<Department> result = new ArrayList<>();
        // 从根部门开始递归遍历
        findDepartmentByTypeRecursiveImpl(type, rootDepartments, result);
        return result;
    }

    /**
     * 私有辅助方法：执行实际的递归遍历逻辑。
     * @param type 要查找的部门类型。
     * @param departments 当前正在遍历的部门列表。
     * @param result 用于收集匹配部门的结果列表。
     */
    private void findDepartmentByTypeRecursiveImpl(String type, List<Department> departments, List<Department> result) {
        if (departments == null || departments.isEmpty()) {
            return; // 递归终止条件：当前列表为空
        }

        for (Department current : departments) {
            // 检查当前部门是否匹配指定类型
            if (type.equals(current.getType())) {
                result.add(current);
            }
            // 如果当前部门是Company，则继续递归遍历其子部门
            if (current instanceof Company) {
                findDepartmentByTypeRecursiveImpl(type, ((Company) current).getDepartments(), result);
            }
        }
    }
}

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

public class OrganizationSearch {

    private List<Department> rootDepartments;

    public OrganizationSearch(List<Department> rootDepartments) {
        this.rootDepartments = rootDepartments;
    }

    /**
     * 公共入口方法：通过迭代查找所有指定类型的部门。
     * @param type 要查找的部门类型。
     * @return 匹配指定类型的所有部门列表。
     */
    public List<Department> findDepartmentByTypeIterative(String type) {
        ArrayList<Department> result = new ArrayList<>();
        // 使用ArrayList模拟栈，存储待处理的部门
        ArrayList<Department> stack = new ArrayList<>();
        stack.addAll(rootDepartments); // 将所有根部门压入栈中

        // 当栈不为空时，持续进行遍历
        while (!stack.isEmpty()) {
            // 弹出栈顶元素（最后一个元素）
            Department current = stack.remove(stack.size() - 1);

            // 检查当前部门是否匹配指定类型
            if (type.equals(current.getType())) {
                result.add(current);
            }

            // 如果当前部门是Company，则将其所有子部门压入栈中
            // 注意：为了保持DFS顺序，通常会将子部门逆序压入栈，
            // 但在这里，由于我们只是收集所有匹配项，顺序不严格要求，
            // 只要最终所有子部门都被访问即可。
            if (current instanceof Company) {
                // 将子部门添加到栈中，它们将在后续循环中被处理
                // 为了保持与递归相似的遍历顺序（左子树优先），可以逆序添加
                List<Department> subDepartments = ((Company) current).getDepartments();
                for (int i = subDepartments.size() - 1; i >= 0; i--) {
                    stack.add(subDepartments.get(i));
                }
                // 或者直接 stack.addAll(subDepartments); 如果顺序不重要，但可能会改变DFS的访问顺序
            }
        }
        return result;
    }
}