如何在Java中查找可变长度列表中的最大值,其中可变长度嵌套列表是逐个索引的?

rvpgvaaj  于 2023-02-07  发布在  Java
关注(0)|答案(3)|浏览(145)

我有一个List<List<Integer>>,它有任意数量的可变长度List<Integer>。我需要比较同一索引处的每个值,并确保这些值是排序的,这意味着第一个列表应该小于下一个列表(基于逐个索引值的索引)。
在下面的示例中,将在索引i = 0处的列表之间比较每个索引,值都是 * int 5 *,因此继续。对于i = 1,值都是3,因此继续。对于i = 2listA较大,因为它有一个附加整数,其中其他整数为空,应返回false。

List<List<Integer>> listOfLists = List.of(List.of(5, 3, 2),  // A
                                          List.of(5, 3),     // B
                                          List.of(5, 3));    // C

再举一个例子,这里,它们的顺序不正确,因为listB在最后一个索引上失败,因为ListAlistC的值不是null,所以listB较小。

List<List<Integer>> listOfLists = List.of(List.of(4, 3, 2, 1),   // A
                                          List.of(4, 3, 2),      // B
                                          List.of(4, 3, 2, 1));  // C

在本例中,它们是按顺序排列的。

List<List<Integer>> listOfLists = List.of(List.of(4, 3),        // A
                                          List.of(4, 3, 1),     // B
                                          List.of(5, 3, 2, 1),  // C
                                          List.of(5, 4, 3));    // D

我尝试了很多方法。我试着用Comparator创建一个自定义的比较方法,嵌套的for循环,递归等等。我一直遇到IndexOutOfBOundsExceptions的问题,这仍然是一种令我难以置信的。我已经能够排序列表或找到列表的最大值,并将它们与其他列表进行比较,但不能同时保持顺序。
我觉得将同一索引中的每个值都推到堆栈上,然后比较它们是一个很好的解决方案,但是我在实现它时遇到了麻烦。
最终结果是我需要确定List<List<Integer>>是否按照从小到大的正确顺序;否则,return false。最后一个示例为真,其他示例为假。

编辑

我想出了这个办法,似乎很有效。

public class ListTest {

    public static void main(String... args) {
        List<List<Integer>> listOfLists = List.of(List.of(3, 2, 1),     // A
                                                  List.of(4, 3, 1),     // B
                                                  List.of(5, 4, 3));    // C

        boolean correctOrder = true;
        int max = getMaxLength(listOfLists);

        Stack<Integer> stack = new Stack<>();

        for (int i = 0; i < max; i++) {
            for (int j = 0; j < listOfLists.size(); j++) {
                try {
                    stack.push(listOfLists.get(j).get(i));
                } catch(IndexOutOfBoundsException ex) {
                    stack.push(0);
                }
            }

            if (!isSorted(stack)) {
                correctOrder = false;
                break;
            }
        }

        System.out.println(correctOrder);
    }

    public static boolean isSorted(Stack<Integer> stack) {
        int temp = stack.pop();

        while (!stack.isEmpty()) {
            int compare = stack.pop();

            if (temp < compare)
                return false;

            temp = compare;
        }
        return true;
    }

    public static int getMaxLength(List<List<Integer>> list) {
        int maxLength = 0;

        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).size() > maxLength) {
                maxLength = list.get(i).size();
                System.out.println(maxLength);
            }
        }

        return maxLength;
    }
}
0s7z1bwu

0s7z1bwu1#

所以你需要一个比较器。这很简单。只需要创建两个独立的比较器:首先应该按大小排序列表,其次按内容排序。

public static Comparator<List<Integer>> createComparator() {
    Comparator<List<Integer>> sortBySizeAsc = Comparator.comparingInt(List::size);
    Comparator<List<Integer>> sortByContentAsc = (one, two) -> {
        Iterator<Integer> it1 = one.iterator();
        Iterator<Integer> it2 = two.iterator();

        while (it1.hasNext() && it2.hasNext()) {
            int res = Integer.compare(it1.next(), it2.next());

            if (res != 0)
                return res;
        }

        return 0;
    };
    return sortBySizeAsc.thenComparing(sortByContentAsc);
}
baubqpgj

baubqpgj2#

你可以根据你的订单定义来排序你的列表的副本,并检查副本和原始列表是否相等。(如果你的列表很大,这可能不是有效的方法)。

static boolean areListsInOrder(List<List<Integer>> listOfLists){
    //a comparator to sort your lists comparing each value index wise, then comparing by list size
    Comparator<List<Integer>> comp = (list1,list2) -> IntStream.range(0, Math.min(list1.size(), list2.size()))
                                                               .map(i -> list1.get(i).compareTo(list2.get(i)))
                                                               .dropWhile( i -> i == 0).findFirst()
                                                               .orElse(Integer.compare(list1.size(), list2.size()));

    //copy your list and sort
    List<List<Integer>> copy = new ArrayList<>(listOfLists);
    copy.sort(comp);

    //check if the sorted and original are equal
    return copy.equals(listOfLists);
}
vhmi4jdf

vhmi4jdf3#

据我所知,你想达到什么目的,下面应该是解决办法:

boolean checkListsOrder(List<List<Integer>> listOfLists) {
    int maxSize = 0;
    for (List<Integer> singleList : listOfLists)
        maxSize = maxSize > singleList.size() ? maxSize : singleList.size();

    Map<Integer, Integer> checkIfAllValuesEqualsAndWrongOrdered = new HashMap<>();
    for (int i = 0; i < listOfLists.size(); i++)
        checkIfAllValuesEqualsAndWrongOrdered.put(i, 0);

    for (int j = 0; j < maxSize; j++) {
        TreeMap<Integer, Integer> orderOfValues = new TreeMap<>();
        for (int i = 0; i < listOfLists.size(); i++) {
            if (j < listOfLists.get(i).size()) {
                orderOfValues.put(i, listOfLists.get(i).get(j));
            }
        }

        Map.Entry<Integer, Integer> previousEntry = orderOfValues.firstEntry();
        Map.Entry<Integer, Integer> nextEntry = orderOfValues.higherEntry(previousEntry.getKey());
        while (nextEntry != null) {
            if (previousEntry.getValue() > nextEntry.getValue())
                return false;
            else if (previousEntry.getValue() == nextEntry.getValue() && listOfLists.get(previousEntry.getKey()).size() > listOfLists.get(nextEntry.getKey()).size()) {
                if (checkIfAllValuesEqualsAndWrongOrdered.get(nextEntry.getKey()) + 1 == listOfLists.get(nextEntry.getKey()).size() - 1)
                    return false;
                else
                    checkIfAllValuesEqualsAndWrongOrdered.put(nextEntry.getKey(), checkIfAllValuesEqualsAndWrongOrdered.get(nextEntry.getKey()) + 1);
            }
            previousEntry = nextEntry;
            nextEntry = orderOfValues.higherEntry(nextEntry.getKey());
        }

    }

    return true;
}

相关问题