使用循环算法从多个列表中选择数据的有效方法答案

【问题标题】：Efficient way to choose data from several Lists with round robin algorithm使用循环算法从多个列表中选择数据的有效方法
【发布时间】：2017-09-23 10:31:29
【问题描述】：

我需要从几个列表中创建一个包含所有其他列表的值的单个结果列表，方法是使用循环算法选择数据。

list1 = val1_1,val1_2 .. 
list2 = val2_1,val2_2 .. 
list3 = val3_1,val3_2 ..
//rr choosing
result = val1_1,val2_1,val3_1,val1_2,val2_2,val3_2,val1_3...

每个列表中的值的数量可能不同。我该怎么做？

【问题讨论】：

标签： java list multidimensional-array round-robin

【解决方案1】：

您可以使用从单个列表派生的Iterators 中的Queue。从队列中获取下一个迭代器，从迭代器中获取下一个元素，如果不为空则添加回队列。

List<String> lst1 = new ArrayList<>(Arrays.asList("a", "b", "c"));
List<String> lst2 = new ArrayList<>(Arrays.asList("A", "B"));
List<String> lst3 = new ArrayList<>(Arrays.asList("1", "2", "3", "4"));

Queue<Iterator<String>> iters = new LinkedList<>(Stream.of(lst1, lst2, lst3)
        .map(List::iterator).collect(Collectors.toList()));

List<String> result = new LinkedList<>();
while (! iters.isEmpty()) {
    Iterator<String> iter = iters.poll();
    if (iter.hasNext()) {
        result.add(iter.next());
        iters.add(iter);
    }
}
System.out.println(result); // [a, A, 1, b, B, 2, c, 3, 4]

【讨论】：

【解决方案2】：

如果要创建 一维列表，其中填充来自锯齿状二维列表的列的数据，可以使用两个嵌套的 for 循环：首先是按列，然后按行。如果您事先不知道最大行的长度，即列数，您可以迭代直到至少在一行中仍然存在这些列。

// input data
List<List<String>> lists = Arrays.asList(
        Arrays.asList("a1", "b1", "c1"),
        Arrays.asList("a2", "b2"),
        Arrays.asList("a3", "b3", "c3", "d3"));

// result list
List<String> listRobin = new ArrayList<>();

// iteration over the columns of a 2d list until
// the columns are still present at least in one row
for (int col = 0; ; col++) {
    // whether the columns are still present
    boolean max = true;
    // iteration over the rows, i.e. lists
    for (List<String> list : lists) {
        // if column is present
        if (col < list.size()) {
            // take value from this column
            listRobin.add(list.get(col));
            // columns are still present
            max = false;
        }
    }
    // if there are no more columns
    if (max) break;
}

// output
System.out.println(listRobin);
// [a1, a2, a3, b1, b2, b3, c1, c3, d3]

^{另见：

• Join lists in java in round robin fashion

•How do you rotate a 2D array 90 degrees without using a storage array?}

【讨论】：

【解决方案3】：

具有相同长度的列表

public static void main(String[] args) {
    String[][] values = new String[][] {
        { "1_1", "1_2", "1_3" },
        { "2_1", "2_2", "2_3" },
        { "3_1", "3_2", "3_3" }
    };

    for (int count = 0; count < values.length * values[0].length; count++) {
        System.out.println(values[count % values.length][count / values[0].length]);
    }
}

表达式：

count % values.length

在所有行之间旋转，而表达式：

count / values[0].length

在多次迭代后增加一。

不同长度的列表

public static void main(String[] args) {
    String[][] values = new String[][] {
        { "1_1", "1_2", "1_3" },
        { "2_1", "2_2" },
        { "3_1", "3_2", "3_3", "3_4" }
    };

    for (int count = 0, maxLen = 0;; count++) {
        int row = count % values.length;
        int col = count / values[0].length;
        maxLen = Math.max(values[row].length, maxLen);
        if (values[row].length > col) {
            System.out.println(values[row][col]);
        } else if (row + 1 == values.length && col >= maxLen) break;
    }
}

为具有相同长度的列表提供的解决方案的差异是：

仅当当前列表定义了计算列时才获取值。
在迭代值时收集所有列表的最大长度。
如果不存在定义当前计算列的列表，则停止。

【讨论】：