Question

我将如何重新排列给定整数数组的元素，以使每个最大严格升序子数组的元素颠倒？

例如，给定数组{5，7，10，4，2，7，8，1，3}，执行此方法后，数组的元素将为{10，7，5，4， 8、7、2、3、1}。

我的尝试仅按降序对整数进行排序。如何使这些嵌套循环标识最大的严格升序子数组？我相信外循环应该不得不反复查找当前升序的结尾，而内循环则将子数组反转到该点。

public class MyClass {
  public static void main(String args[]) {

    int[] arr = {5, 7, 10, 4, 2, 7, 8, 1, 3};

    for (int i=0; i<arr.length-1; i++) {

        if (arr[i] < arr[i+1]) {
            int t = arr[i+1];
            arr[i+1] = arr[i];
            arr[i] = t;
        }
        for (int j=0; j<arr.length-1; j++) {

            if (arr[j] < arr[j+1]) {
                int t = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = t;
            }
        }
    }
    String result = Arrays.toString(arr);
    System.out.println(result); // [10, 8, 7, 7, 5, 4, 3, 2, 1]
  }
}

Answer 1

我明白了您为什么使用嵌套循环。但是我认为您需要跟踪起点和终点，而不仅仅是交换。这是我使用堆栈解决的方法：

public static void main(String[] args) {
    System.out.println(Arrays.toString(reverseAscendingSubArray(new int[]{5, 7, 10, 4, 2, 7, 8, 1, 3})));
}

private static int[] reverseAscendingSubArray(int[] arr) {
    Stack<Integer> stack = new Stack<>();
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        if (i == 0 || arr[i - 1] < arr[i]) {
            stack.push(arr[i]);
        } else {
            for (int j = stack.size(); j > 0; j--) {
                result[i - j] = stack.pop();
            }
            stack.push(arr[i]);
        }
    }
    if (!stack.empty()) {
        for (int j = stack.size(); j > 0; j--) {
            result[arr.length - j] = stack.pop();
        }
    }
    return result;
}

输出

[10, 7, 5, 4, 8, 7, 2, 3, 1]

说明

我一直将元素推入堆栈，直到当前元素大于上一个元素为止。一旦得到比以前小的东西，我就会从堆栈中弹出所有元素并将它们写入新数组。按下并弹出会反转元素。

Answer 2

您可以尝试按照以下代码使用冒泡排序。

public static void reverseAscendingSubarrays(int[] items){
        int start = -1;
        int stop = -1;
        for (int i = 0; i < items.length; i++){
            if (i != items.length - 1){
                if (items[i] <= items[i + 1]){
                    if (start == -1) {
                        start = i;
                    }
                }
                else {
                    if (start != -1) {
                        stop = i;
                    }
                }
            }
            else{
                if (start != -1){
                    stop = i;
                }
            }
            if (start != -1 && stop != -1){
                //sort array from start to stop (uses bubble sort - inefficient for large arrays)
                for (int n = 0; n < stop - start + 1; n++)
                    for (int j = start; j < stop; j++){
                        if (items[j] < items[j+1]){
                            //swap
                            int temp = items[j];
                            items[j] =items[j+1];
                            items[j+1] = temp;
                        }
                    }
                start = -1;
                stop = -1;
            }
        }
    }

给定一个整数数组，反转每个最大严格递增子数组

2 个答案: