如何用递归方式移除列表首尾最大值并处理有序列表？

需求说明 #

• 判断列表是否有序，若有序则返回false
• 若列表无序：
  • 仅当最大值位于列表开头或结尾时，将其移除，然后递归执行该操作
  • 若最大值在列表中间，则输出当前列表
• 示例：
  • 输入[1,2,3,4]（有序），返回false
  • 输入[9,1,2,3,4,6,22]，处理后得到[1,2,3,4,6]

当前Java实现代码 #

public class Solution {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();

        list.add(9);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(22);
        var r = find132pattern(list);

        
    }

    
   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();

    Integer maxNum = Collections.max(list);

    Integer maxPos = list.indexOf(maxNum);

    
    if(result == "sorted"){
        return false;
    }else if(result == "not sorted" && maxPos == end || maxPos == start){
        list.remove(maxPos);
        find132pattern(list);
    }else {
        System.out.println(list);
    }
        
    
 return false;
}
    
}

// find an element

当前代码存在的问题 #

• 字符串比较错误：Java中用==比较字符串会判断引用而非内容，应该用equals()方法，否则会导致有序/无序的判断逻辑失效。
• 最大值位置判断错误：列表最后一个元素的索引是list.size()-1，原代码中end = list.size()，导致maxPos == end永远不成立，无法识别结尾的最大值。
• 递归逻辑不完整：递归调用后未处理返回值，且直接修改原列表可能引发意外问题。
• 重复最大值处理遗漏：list.indexOf(maxNum)仅返回第一个最大值的位置，若列表存在多个最大值且首尾、中间都有，会出现判断错误。

修正后的递归实现代码 #

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

public class Solution {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(9);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(22);
        processList(new ArrayList<>(list)); // 传入列表副本，避免修改原数据
    }

    public static void processList(List<Integer> list) {
        // 判断列表是否为严格递增有序
        boolean isSorted = true;
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i - 1) > list.get(i)) {
                isSorted = false;
                break;
            }
        }

        if (isSorted) {
            System.out.println(false);
            return;
        }

        // 判断最大值是否在首尾
        Integer maxNum = Collections.max(list);
        boolean maxAtStart = list.get(0).equals(maxNum);
        boolean maxAtEnd = list.get(list.size() - 1).equals(maxNum);

        if (maxAtStart || maxAtEnd) {
            // 移除首尾的最大值
            if (maxAtStart) {
                list.remove(0);
            } else {
                list.remove(list.size() - 1);
            }
            // 递归处理剩余列表
            processList(list);
        } else {
            // 最大值在中间，输出当前列表
            System.out.println(list);
        }
    }
}

代码说明 #

• 有序判断优化：遍历过程中只要发现降序元素就标记为无序，提前终止循环，提升效率。
• 逻辑错误修复：用布尔值直接判断有序状态，避免字符串比较问题；修正首尾索引判断逻辑，准确识别结尾的最大值。
• 递归逻辑优化：传入列表副本操作，避免修改原数据；递归流程清晰，符合需求中的循环处理规则。
• 多最大值处理：直接判断首尾元素是否等于最大值，无论列表中有多少个最大值，只要首尾存在就执行移除操作。

内容的提问来源于stack exchange，提问作者Aliayub Ali