以递归方式将列表中的元素与以下内容进行比较

Question

嗨， 更新：感谢您的所有建议

假设，这个练习就像一个rebus， 我有一个用缺点和零的概念制作的数字列表，

List l = new Cons(**3**, new Cons(**2**,new Cons(**1**, new
Cons(**4**, new Cons(**1**, new Nil())))));

我想递归地计算其中有多少紧跟着一个较小的数字。

例如

[5,0,5,3].count() == 2, [5,5,0].count() == 1

count()方法由我制作(它不能有任何参数)，其余的都是默认的，我不能制作和其他方法或使用已经定义的方法，如 add()，size()..."NEXT"必须在当前 elem 之后具有下一个值，但我无法获得解决方案。

欢迎任何解决方案。

abstract class List {
public abstract boolean empty();
public abstract int first();
public abstract int count();
}
class Cons extends List {
private int elem;
private List next;
public Cons(int elem, List next) {
this.elem = elem;
this.next = next;
}
public boolean empty(){
return false; 
}
public int first(){
return elem;
}
@Override
public int count() {
if(elem>NEXT) {
return 1 + next.count();  
}else {
return next.count();      
}
}
```![enter image description here](https://i.stack.imgur.com/kWo0v.jpg)

Answer 1

以下代码将创建一个递归列表，其中包含 N 个元素，N值由在类中称为elements的int数组中找到的元素数量定义RecursiveList。 调用startRecursion()方法以使用定义的元素创建递归列表，并调用count()以获取数组中紧跟较小数字的元素数量。

主类

这是您的应用程序入口点：

public static void main(String[] args) {
int count = RecursiveList.startRecursion().count();
System.out.printf("List has %d recursive elements", count);
}

递归列表类

abstract class RecursiveList {
protected static int index = -1;
protected static int[] elements = new int[]{ 5,2,1,4,3,2,6 };
public static RecursiveList startRecursion() {
return new Cons();
}
public abstract boolean empty();
public abstract int count();
public abstract Integer getElement();
public static int incIndex() {
return index += 1;
}
}

缺点类

public class Cons extends RecursiveList {
private static int result;
private final Integer elem;
private final RecursiveList prev;
private final RecursiveList next;
private Cons(Cons parent) {
prev = parent;
elem = incIndex() < elements.length ? elements[index] : null;
System.out.printf("Creating new Cons with element %d(%d)%n", elem, index);
next = elem != null ? new Cons(this) : null;
}
Cons() {
this(null);
}
public boolean empty() {
return false;
}
@Override
public /*@Nullable*/ Integer getElement() {
return elem;
}
@Override
public int count() {
if (elem != null)
{
if (prev != null && elem < prev.getElement())
result += 1;
if (next != null) {
return next.count();
}
}
return result;
}
}

编辑

好的，这就是您实际寻找的答案。这完全符合您提供的对此练习施加的限制。该解决方案使用纯Java，类及其任何方法或字段声明都没有以任何方式修改，也没有添加这样的新元素。我只在练习说你应该的地方添加了实现。

主类

public static void main(String[] args) {
List l = new Cons(3, new Cons(2,new Cons(1, new
Cons(4, new Cons(1, new Nil())))));
assert l.count() == 3;
l = new Cons(5, new Nil());
assert l.count() == 0;
l = new Cons(5, new Cons(5, new Cons(0, new Nil())));
assert l.count() == 1;
l = new Cons(5, new Cons(0, new Cons(5, new Cons(3, new Nil()))));
assert l.count() == 2;
System.out.println("All tests completed successfully!");
}

缺点类

import java.util.NoSuchElementException;
public class Cons extends List {
private int elem;
private List next;
public Cons(int elem, List next) {
this.elem = elem;
this.next = next;
}
public boolean empty()
{ return false; }
public int first()
{ return elem; }
public int count()
{
try {
if (first() > next.first()) {
return 1 + next.count();
}
else return next.count();
}
catch (NoSuchElementException e) {
return 0;
}
}
}

无类

import java.util.NoSuchElementException;
public class Nil extends List {
public boolean empty()
{ return true; }
public int first()
{ throw new NoSuchElementException(); }
public int count()
{
throw new IllegalAccessError();
}
}

Answer 2

public int NEXT(){
if(next!=null)
return next.first()
else 
throw new Exception("No next element")
}