Java中递归实现列表条件性最大元素移除

public class Solution {
    // ... main 方法省略 ...

    public static boolean find132pattern(List<Integer> list) {
        int count = 0;
        String result = ""; // 字符串用于存储排序结果
        for(int i = 0; i < list.size(); i++){
            int prev = i-1;
            int next = list.get(i);
            if(prev > -1){
                prev = list.get(i-1);
                if(prev > next){
                    count+=1; // 统计逆序对
                }
            }
        }
        if(count > 0){
            result+="not sorted";
        }else {
            result+="sorted";
        }

        Integer start = 0;
        Integer end = list.size(); // 这里的end是列表大小，而非最后一个元素的索引

        Integer maxNum = Collections.max(list);
        Integer maxPos = list.indexOf(maxNum);

        // 逻辑判断和递归调用
        if(result == "sorted"){ // 字符串比较应使用 .equals()
            return false;
        }else if(result == "not sorted" && (maxPos == end || maxPos == start)){ // maxPos == end 存在索引越界风险
            list.remove(maxPos);
            find132pattern(list); // 递归调用未处理返回值
        }else {
            System.out.println(list);
        }
        return false; // 最终总是返回false
    }
}

import java.util.List;
import java.util.Collections;
import java.util.ArrayList;

public class ListProcessor {

    /**
     * 递归地从列表中移除最大的元素。
     * 该方法通过一次遍历找到最大元素的索引，然后在递归结束时执行移除操作。
     *
     * @param list 待处理的整数列表。
     * @param currentIndex 当前递归遍历到的索引。
     * @param maxElementIndexFoundSoFar 迄今为止发现的最大元素的索引。
     * @return 移除了最大元素后的列表。
     */
    public static List<Integer> removeBiggestFromListRecursive(List<Integer> list, int currentIndex, int maxElementIndexFoundSoFar) {
        // 基本情况：如果当前索引超出了列表范围，说明已经遍历完整个列表
        if (currentIndex >= list.size()) {
            // 如果列表不为空，则移除在遍历过程中找到的最大元素
            if (!list.isEmpty()) {
                list.remove(maxElementIndexFoundSoFar);
            }
            return list; // 返回修改后的列表
        }
        else {
            // 递归步骤：
            // 比较当前元素与迄今为止找到的最大元素
            if (list.get(currentIndex) > list.get(maxElementIndexFoundSoFar)) {
                // 如果当前元素更大，则更新最大元素的索引
                maxElementIndexFoundSoFar = currentIndex;
            }
            // 递归调用自身，处理下一个元素
            return removeBiggestFromListRecursive(list, currentIndex + 1, maxElementIndexFoundSoFar);
        }
    }

    public static void main(String[] args) {
        List<Integer> myList = new ArrayList<>();
        myList.add(9);
        myList.add(2);
        myList.add(3);
        myList.add(4);
        myList.add(5);
        myList.add(22);

        System.out.println("原始列表: " + myList); // 输出: [9, 2, 3, 4, 5, 22]

        // 调用递归方法移除最大元素
        // 初始调用时，currentIndex从0开始，maxElementIndexFoundSoFar也从0开始（假设列表不为空）
        if (!myList.isEmpty()) {
            myList = removeBiggestFromListRecursive(myList, 0, 0);
        }
        System.out.println("移除最大元素后的列表: " + myList); // 输出: [9, 2, 3, 4