Java 检查一行整数是否递减的递归方法：返回true/false

我必须用Java编写一个递归方法，如果一行是降序的，则返回true，否则返回false

这是我尝试过的，但无法正常工作：

ArrayList<Integer> getallen = new ArrayList();
        getallen.add(500);
        getallen.add(400);
        getallen.add(300);
        getallen.add(200);
        getallen.add(100);
        getallen.add(0);

        System.out.println(isDescending(getallen));
    }

public static boolean isDescending(ArrayList<Integer> getallen) {
    if (getallen.size() >= 2) {
        if (getallen.get(0) < getallen.get(1)) {
            return false;
        } else if (getallen.size() > 0) {
            getallen.remove(0);
            return isDescending(getallen);
        } else {
            return true;
        }
    } else {
        return false;
    }
}

ArrayList getallen=new ArrayList（）；
加上（500）；
加上（400）；
加上（300）；
加上（200）；
加上（100）；
getallen.add（0）；
系统输出打印LN（isDescending（getallen））；
}
公共静态布尔isDescending（ArrayList getallen）{
如果（getallen.size（）>=2）{
if（getallen.get（0）0）{
getallen.remove（0）；
返回isDescending（getallen）；
}否则{
返回true；
}
}否则{
返回false；
}
}

我认为如果大小小于2，则您可能会遇到不必要的情况，您只能假设为真

尝试：

publicstaticbooleanisdescending（arraylistgetallen）{
如果（getallen.size（）>=2）{
if（getallen.get（0）

如果我必须给它打分，它会得到一个大X

• 在stackoverflow上被欺诈地询问
• 效率非常低（尝试在包含一百万个元素的列表上运行此测试，然后意识到删除

  ArrayList

  中的元素0会导致所有元素下移）

相反，请考虑：

public static boolean isDescending(List<Integer> getallen) {
    return isDescending(getallen, 0);
}

public static boolean isDescending(List<Integer> getallen, int from) {
    return from >= getallen.size() - 1
            || getallen.get(from) < getallen.get(from + 1)
            && isDescending(getallen, from + 1);
}

publicstaticbooleanisdescending（List-getallen）{
返回isDescending（getallen，0）；
}
公共静态布尔isDescending（列表getallen，int from）{
从>=getallen.size（）返回
||getallen.get（from）

对数递归深度的更有效方法如何？只是作为练习

public static void main(String[] args) {
    List<Integer> getallen = new ArrayList<Integer>();        
    getallen.add(500);
    getallen.add(400);
    getallen.add(300);
    getallen.add(200);
    getallen.add(100);
    getallen.add(0);

    System.out.println(isDescending(getallen));
}

public static boolean isDescending(List<Integer> getallen) {
    return isDescending(getallen, 0, getallen.size());
}

private static boolean isDescending(List<Integer> getallen, 
        int start, int end) {
    if (end - start <= 1)
        return true;
    if (end - start == 2) {
        return getallen.get(start) > getallen.get(start + 1);
    }
    int middle = (start + end - 1) / 2 + 1;
    return (getallen.get(middle - 1) > getallen.get(middle)) && 
            isDescending(getallen, start, middle) && 
            isDescending(getallen, middle, end);
}

publicstaticvoidmain（字符串[]args）{
List getallen=new ArrayList（）；
加上（500）；
加上（400）；
加上（300）；
加上（200）；
加上（100）；
getallen.add（0）；
系统输出打印LN（isDescending（getallen））；
}
公共静态布尔isDescending（列表getallen）{
返回isDescending（getallen，0，getallen.size（））；
}
私有静态布尔值isDescending（List getallen，
整数开始，整数结束）{
if（end-start-getallen.get（start+1）；
}
中间整数=（开始+结束-1）/2+1；
return（getallen.get（中间-1）>getallen.get（中间））&
isDescending（getallen、start、middle）和
isDescending（getallen，中间，末端）；
}

什么不起作用？你的问题是基本情况。

什么是descending

应该在长度为1的列表上返回？@Tunaki-我不认为这也有什么问题。他检查的列表是递减的，大小的列表不能称为递减。因此，else块应该很好。@RamanShrivastava实际上，他删除了每个递归调用中的第一个元素都是。因此，最后，他得到一个长度为1的列表，并且总是返回false。@Tunaki-长度为1的列表应该只返回true，我想。它应该做什么还不是很清楚。当我创建一个带有数字的ArrayList时：500、400、300、200、100、0、5；出于某种原因它返回true。500、400、300、200，100，0；返回false，但它不应该返回false。谢谢！这帮了我的忙。我只想添加几乎相同的解决方案：）顺便说一句。当我使用列表集合时，调用

remove（0）

抛出一个

unapprovedOperationException

（NetBeans 8.0.2，Java 8.0.45），所以我使用了

subSet（）

传递参数以进行进一步递归。@Andrewmcoist一个

ArrayList

将永远不会在

remove

方法中抛出

UnsupportedOperationException

。您确定没有使用由

数组返回的列表。asList（…）

？我知道在删除ArrayList的第一个元素时，所有元素都会向下移动，但我不明白为什么它对此方法很重要。该方法的目的是检查元素是否按降序排列。你能给我解释一下吗？@MJM这不是功能问题，而是效率问题。在

ArrayList

中，下移所需的步骤与列表的长度相同。因此，您的算法具有二次时间复杂度（列表长度），而最佳算法（如我的算法）具有线性复杂度。当数据变得庞大时，这一点非常重要。请注意，

LinkedList

没有相同的缺点（删除需要固定的时间），因此这已经可以改进您的解决方案。@MJM作为该方法的副作用修改列表的另一个缺点是该列表可能会被共享。之后，所有别名都将有一个空列表。

public static void main(String[] args) {
    List<Integer> getallen = new ArrayList<Integer>();        
    getallen.add(500);
    getallen.add(400);
    getallen.add(300);
    getallen.add(200);
    getallen.add(100);
    getallen.add(0);

    System.out.println(isDescending(getallen));
}

public static boolean isDescending(List<Integer> getallen) {
    return isDescending(getallen, 0, getallen.size());
}

private static boolean isDescending(List<Integer> getallen, 
        int start, int end) {
    if (end - start <= 1)
        return true;
    if (end - start == 2) {
        return getallen.get(start) > getallen.get(start + 1);
    }
    int middle = (start + end - 1) / 2 + 1;
    return (getallen.get(middle - 1) > getallen.get(middle)) && 
            isDescending(getallen, start, middle) && 
            isDescending(getallen, middle, end);
}