Question

我一直在研究这种递归方法，但似乎无法弄清楚。我的方法：我决定创建列表的副本，然后为递归调用删除副本的最后一个元素。如果最后一个项目（副本列表中的最后一个项目是我试图遍历列表的方式）大于给定的int，我也将从实际列表中将其删除。

public MyList<Integer> reduceMyList(MyList<Integer> m, int e) {

MyList<Integer> res = new MyDynamicList<Integer>();

for (int i = 0; i < m.length(); i++) {

    res.addElement(i, m.getElement(i));
}

int scenario = 0;

if (m.length() <= 1) {

    scenario = 1;
} else {

    scenario = 2;
}

switch (scenario) {

case 1:
    if(res.length() == 0){
        System.out.println();
        break;
    }       

case 2:



    if (e <= res.getElement(res.length() - 1)) {

        m.removeElement(res.length() - 1);


    }
    reduceMyList(m, e);

    res.removeElement(res.length() - 1);

    break;
}
return m;
}

Answer 1

 public MyList<Integer> reduceMyList(MyList<Integer> m, int e) {
    if (m.size() == 0)
        return new MyDynamicList<>();

    MyList<Integer> subList = m.subList(0, m.size() - 1);// get the list without the last element
    Integer lastInteger = m.get(m.size() - 1);
    MyList<Integer> reducedList = reduceMyList(subList, e); // recursive call on sublist
    if (lastInteger <= e)
        reducedList.add(lastInteger);
    return reducedList;
}

这里您有解决问题的方法。希望它会有用。

Answer 2

您的代码中发生了很多有趣的事情。首先，似乎您正在使用类型作为变量（MyList，MyDynamicList），而您没有给我们定义（它们看起来像只是扩展了一些List）。尽管可以，但是您可能不需要定义这些内容。其次，没有理由为此使用递归。但是，如果您确实愿意，则可以在此过程中递归，测试和删除一项。它实际上只是将递归更改为迭代，并且毫无意义（更不用说效率低下了）：

import java.util.*;

public class MyList extends ArrayList<Integer> {
    public void reduce(int e)
    {
        reduceAt(size()-1, e);
    }

    private void reduceAt(int pos, int e)
    {
        if (pos < 0) {
            return;
        }
        if (get(pos) < e) {
            this.remove(pos);
        }
        reduceAt(pos - 1,  e);
    }
}

使用递归的另一种方法是在递归的每个级别复制列表，并将其传递到下一个级别，然后返回最终列表。那会更加低效。

要迭代地进行，您可以使用如下方法：

// iterating backward as that's more efficient when removing items
public void reduceIter(int e) {
    for (int i=size()-1; i >= 0; i--) {
        if (get(i) < e) {
            remove(i);
        }
    }
}

给出您的评论和对这个问题的回答，如果您要通过删除然后重新添加原始列表中的项目来递归，则您的功能可能如下所示（请注意，您的解决方案不会删除以下内容：该问题的标题要求您输入原始列表中的值-会在该值下方生成一个新的项目列表）

public MyList<Integer> reduceMyList(MyList<Integer> m, int min) {

    if (m.length() == 0) {
        // not sure why you are printing, but here it is
        System.out.println();
        return new MyDynamicList<Integer>();
    }

    int value = m.getElement(0);
    m.removeElement(0);

    MyList<Integer> res = reduceMyList(m, min);
    if (value < min)
    {
        res.addElement(0, value);
    }

    m.addElement(0, value);
    return res;
}

Answer 3

我意识到我需要从列表的最前面删除，而且我已经太麻烦了，这很糟糕。我使用了一个新列表来存储小于给定int的元素的值，并将其返回。

public MyList<Integer> reduceMyList(MyList<Integer> m, int e) {

    MyList<Integer> res = null;
    res = new MyDynamicList<Integer>();

    int scenario = 0;

    if (m.length() == 0) {
        scenario = 1;

    }

    else {
        scenario = 2;
    }

    switch (scenario) {

    case 1:

         System.out.println();
        break;
    case 2:

        int e0 = m.getElement(0);
        m.removeElement(0);

        res = reduceMyList(m, e);

        if (e0 < e) {

            res.addElement(0, e0);
        }
        m.addElement(0, e0);
    }
    return res;
}

我将如何递归地删除未排序列表中小于给定int的所有元素？

3 个答案: