在 Java 中使用多维 ArrayList 反转 ArrayList 的子集

Question

我正在尝试使用多维列表中提供的索引来反转列表中的子列表。我没有太多使用多维 lists/arrays 的经验。我不明白为什么这不起作用。

/*
   Given a List<Integer> list and List<List<Integer>> operations
   reverse the sublist and print out the list after all the operations have been done.
   Ex: [5, 3, 2, 1, 3]
       [[0,1], [1, 3]]
*/

import java.util.*;
public class ReverseParameters {
   public static void main(String[] args) {
       List<Integer> list = Arrays.asList(5, 3, 2, 1, 3);
       List<List<Integer>> operations = new ArrayList<>(2);
       for(int i= 0; i < 3; i++){
           operations.add(new ArrayList<>());
       }
       operations.get(0).add(1);
       operations.get(1).add(3);

       subList(list, operations);
   }
   public static void subList (List<Integer> list, List<List<Integer>> operations) {
       System.out.println(list);
       int vertCount = operations.size();
       for (int i = 0; i < vertCount; i++) {
           int edgeCount = operations.get(i).size();
           for (int j = 0; j < edgeCount; j++) {
               int startInd = i;
               int endInd = operations.get(i).get(j);
               int shift = endInd - startInd;
               int right = Math.min(i + shift - 1, list.size() - 1);
               int temp = 0;
               while (startInd < right) {
                   temp = list.get(startInd);
                   list.set(startInd, list.get(right));
                   list.set(right, temp);
                   startInd+=1;
                   right-=1;
               }
               System.out.println();
               System.out.printf(" %d %d%n", startInd, endInd);
               System.out.println();
           }
       }
       System.out.println(list);
   }
}

使用 [[0,1], [1, 3]] 作为索引的这段代码的输出是：

[5, 2, 3, 1, 3]

但应该是：

[3, 1, 2, 5, 3]

有人可以帮我指明正确的方向吗？

Answer 1

您使用不必要的变量使您的代码过于复杂，这使得查找问题变得困难。请看一个更简单的代码和解释：

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(5, 3, 2, 1, 3);
    List<List<Integer>> operations = new ArrayList<>(2);
    // Initialize your operations
    operations.add(Arrays.asList(0,1));
    operations.add(Arrays.asList(1,3));
    subList(list, operations);
}
public static void subList (List<Integer> list, List<List<Integer>> operations) {
    // You just iterate over the operations
    for (List<Integer> operation : operations) {
        // For each operation, store left and right indexes.
        int left = operation.get(0);
        int right = operation.get(1);
        // Iterate until both indexes find each other
        while (left < right) {
            // Swap left and right elements in input list
            int aux = list.get(left);
            list.set(left, list.get(right));
            list.set(right, aux);

            // Now you move your indexes
            ++left;
            --right;
        }
    }
    System.out.println(list);
}

请注意，根据问题的要求，您可能还需要验证操作索引是否在列表边界内，这样您就不会得到 ArrayIndexOutOfBoundsException。所以要始终小心边缘情况。

Answer 2

可以这么简单地完成。

public class Main
{
    public static void main(String[] args)
    {
        //Given a List<Integer> list and List<List<Integer>> operations
        //reverse the sublist and print out the list after all the operations have been done.
        //Ex: [5, 3, 2, 1, 3] 
        //    [[0,1], [1, 3]]
        //Target: [3, 1, 2, 5, 3]
        
        //Steps:
        // 0  1  2  3  4 (Indices)
        //###############
        //[5, 3, 2, 1, 3]
        //[3, 5, 2, 1, 3] // Swap index of 0 and 1.
        //[3, 1, 2, 5, 3] // Swap index of 1 and 3.
        
        List<Integer> list = Arrays.asList(5, 3, 2, 1, 3);
        
        List<List<Integer>> listOfList = new ArrayList<List<Integer>>(2);
        listOfList.add(Arrays.asList(0, 1));
        listOfList.add(Arrays.asList(1, 3));
        
        for(int i=0; i < listOfList.size(); ++i) {
            final int indexA = listOfList.get(i).get(0); //[0 , [1
            final int indexB = listOfList.get(i).get(1); // 1],  3]
            
            //Swap the indices.
            final int tmpValue = list.get(indexA);
            list.set(indexA, list.get(indexB));
            list.set(indexB, tmpValue);
        }
        
        System.out.println(list);
        //[3, 1, 2, 5, 3]
    }
}

Answer 3

您可以通过List.subList() , and reverse by Collections.reverse()获得子集。

static void reverseSubsets(List<Integer> list, List<List<Integer>> subsets) {
    for (List<Integer> subset : subsets)
        Collections.reverse(list.subList(subset.get(0), subset.get(1) + 1));
}

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(5, 3, 2, 1, 3);
    List<List<Integer>> subsets = List.of(List.of(0, 1), List.of(1, 3));
    reverseSubsets(list, subsets);
    System.out.println(list);
}

输出：

[3, 1, 2, 5, 3]

注： toIndex in List.subList(int fromIndex, int toIndex) 是子列表的独占高端。所以你必须在 subset.get(1).

上加 1

在 Java 中使用多维 ArrayList 反转 ArrayList 的子集

Reverse subset of ArrayList using multidimensional ArrayList in Java

java

reverse

list

multidimensional-array

sublist