Java 在不断缩小的LispList中递归查找INT的索引

这里是计算机科学二年级的学生，作为递归练习的一部分，我们得到了一些用LispLists来解决的任意问题。我已经走到一半了，所以如果有人能给我指出正确的方向而不给我明确的答案，那就太好了

我需要在LispList列表中找到intToFind的每个实例的位置，以检查-唯一的条件是：

• 不能使用其他参数
• 它必须递归地完成

对于所有没有遇到LispLists的人，它们没有索引，您可以调用它们的唯一方法是：

• .isEmpty（）返回布尔值
• .head（）返回第0个位置的元素
• .tail（）返回所有非头部元素的LispList
• .cons（value）增加了“头部”位置的价值-将所有其他位置向下移动

我以前写过一个方法，叫做：

• recursiveCountLength（list）返回传递的LispList长度的整数

我一直在测试的列表是：[2,3,4,2,5,12,2,5]，所以我要寻找的结果是[0,3,6]——有了这个结果，下面是我到目前为止得到的结果（解释我在尝试什么）：

publicstaticlisplist
递归位置（LispListToCheck、int intToFind）
{
if（listToCheck.isEmpty（））返回listToCheck；
否则{
//对整个阵列进行一次检查，
//“在备份过程中”执行其他所有操作
LispList positions=recursivePositions（listToCheck.tail（），intToFind）；
//获取当前长度和当前头部
int currentInt=listToCheck.head（）；
int currentLength=recursiveCountLength（listToCheck）；
//如果找到匹配项，请将列表的当前长度添加到列表中
if（currentInt==intToFind）返回positions.cons（currentLength）；
其他返回位置；
}
}

我目前的理论是，从列表的原始长度（在本例中为8）中减去我们正在寻找的int的每次相遇时的数组长度（在本例中为2）将得到索引

• 2首先发生在长度为8的情况下（8-8=索引为0，因此现在索引为[0]）
• 2接下来发生的是长度为5的情况（8-5=索引为3，因此现在索引为[0,3]）
• 2最后发生在长度为2时（8-2=索引为6，因此现在索引为[0,3,6]）

---

唯一的问题是我不知道如何得到一个静态的“8”-这让我得出结论，我正在以完全错误的方式处理这个问题。这里有人给我一些建议吗？非常感谢您的帮助。

澄清一下：

LispList

只是一个单链接列表（区别于Java

LinkedList

，后者是双链接的）

通常，您会使用一个助手，将信息带入递归调用中，例如当前位置和已找到的位置（当前部分结果）

---

对于第一个版本实现

reverse（）

，对于第二个版本实现

addToEach（int）

，留给读者作为练习。

您至少需要3个参数。非常确定添加更多参数是可以的，因为他允许helper方法（因为否则您可以让您的方法调用具有更多参数的helper方法）

最简单的递归方式：

public static LispList<Integer> positions(LispList<Integer> list, Integer key, Integer position){
    if (list.isEmpty()) return  LispList.empty();

    if (list.head().equals(key)) return positions(list.tail(), key, position+1).cons(position);

    return positions(list.tail(), key, position+1);
}

公共静态LispList位置（LispList列表、整数键、整数位置）{
if（list.isEmpty（））返回LispList.empty（）；
if（list.head（）.equals（key））返回位置（list.tail（），key，position+1）.cons（position）；
返回位置（list.tail（），键，位置+1）；
}

您编写的方法实际上是“一个附加参数”，只是作为函数而不是深度跟踪整数实现。你可以使用它吗？你应该用它吗？你会得到一份职位列表。对于每个递归步骤，我都会更新这个返回的列表。这不是用“真正的”Lisp写的，而是用某种“纯粹的”Lisp。。。

LispList<Integer> positions (final int item, final LispList<Integer> list) {
    return positionsAux( item, list, 0, new LispList<Integer>() );
}

private LispList<Integer> positionsAux (final int item,
                                        final LispList<Integer> list,
                                        final int position,
                                        final LispList<Integer> result) {
    if (list.isEmpty()) {
        return result.reverse();
    }
    if (list.head().intValue() == item) {
        result = result.cons(position);
    }
    return positionsAux( item, list.tail(), position + 1, result );
}

LispList<Integer> positions (final int item, final LispList<Integer> list) {
    if (list.isEmpty()) {
        return new LispList<Integer>();
    }
    final LispList<Integer> tailResult = positions( item, list.tail() );
    final LispList<Integer> result = tailResult.addToEach( 1 );
    if (list.head().intValue() == item) {
        return result.cons( 0 );
    } else {
        return result;
    }
}

public static LispList<Integer> positions(LispList<Integer> list, Integer key, Integer position){
    if (list.isEmpty()) return  LispList.empty();

    if (list.head().equals(key)) return positions(list.tail(), key, position+1).cons(position);

    return positions(list.tail(), key, position+1);
}