Question

我很难解决下一个问题。我有一个对象列表（在Java中），该对象将数据存储在以下字段中：

Master Dependent
100    101
101    102
105    107
111    112
110    111

并且我需要根据它们在“主”和“受抚养者”之间的关系对它们进行分组，并设置它们的级别。我需要找到..纯母版，这是从属字段中从未出现过的母版。

期望的结果将是：

Master Dependent Level
100    101       1
101    102       2

105    107       1

110    111       1
111    112       2

我尝试使用递归函数进行求解，但是我无法达到水平。

示例功能：

localitem =依赖

public List<TransferPolicyItem> defineConsistencyPairs(Integer pairNo, String item, List<TransferPolicyItem> transferPolicyItemList){
    for(TransferPolicyItem transferPolicyItem : transferPolicyItemList) {
        if (item.equals(transferPolicyItem.getLocalItem().getId())
                && !transferPolicyItem.getConsistencyChecked()
                && transferPolicyItem.getMasterItemId() != null) {

            transferPolicyItem.setConsistencyChecked(true);
            transferPolicyItem.setConsistencyPair(pairNo);
            defineConsistencyPairs(pairNo, transferPolicyItem.getMasterItemId(), transferPolicyItemList);

        } else if (item.equals(transferPolicyItem.getMasterItemId())
                && !transferPolicyItem.getConsistencyChecked()) {

            transferPolicyItem.setConsistencyChecked(true);
            transferPolicyItem.setConsistencyPair(pairNo);
            defineConsistencyPairs(pairNo, transferPolicyItem.getLocalItem().getId(), transferPolicyItemList);
        }
    }
    return transferPolicyItemList;
}

Answer 1

递归是解决此问题的一种非常技术。同样，依赖主控并不是考虑这些价值的最佳方法。相反，将它们视为父母（孩子），并将您的水平视为一代。认识到一行中的父母可以是前一行中的孩子。
这是一个非递归解决方案：

按父ID对输入进行排序。这解决了（111，112）出现在（110，111）之前的数据流中的问题。
遍历输入数据并创建第二个集合，该集合跟踪给定id的生成。子代是父代+1（从0开始父代）。
遍历输入数据并为（父，子）关系分配子代（子代的级别）。

以下是步骤：

Initial Input
Parent  Child
100     101
101     102
105     107
111     112
110     111

Sort the input:
Parent  Child
100     101
101     102
105     107
110     111
111     112

Assign generation:
Value  Generation
100    0
101    1
102    2
105    0
107    1
110    0
111    1
112    2

Assign Generation to the relationship:
Parent  Child  Generation
100     101    1
101     102    2
105     107    1
110     111    1
111     112    2

Answer 2

一个更简单的解决方案是将所有对放置在地图上，找到根（没有父节点的节点），然后使用递归（实际上很好：它可能比迭代慢一些，但我肯定会发现更多可读）以分配级别。

使用Java风格的伪代码：

parents = new Map<Integer, Integer>()
children = new Map<Integer, Integer>()
for each pair A, B,
   children.put(A, B) 
   parents.put(B, A) 

parents.removeAll(children); // single result is the root
root = parents.iterator().next(); 

levels = new Map<Integer, Integer>()
levels.put(root, 0);
assignLevels(root, children, levels)

与

assignLevels(node, children, levels):
   level = levels.get(node) + 1
   for each child C:
       levels.put(C, level)
       assignLevevels(C, children, levels) // recursion

建立配对元素级别或查找主元素的递归算法

2 个答案: