рекурсивно сравнить элемент списка со следующим

Question

Привет , Обновление: спасибо за все ваши предложения

при условии, что это упражнение похоже на ребус, У меня есть список чисел, сделанных с концепцией Минусы и Ноль,

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 (), размер()... «СЛЕДУЮЩИЙ» должен иметь следующее значение после текущего элемента , но я не могу найти решение.

Любые решения приветствуются.

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 которых определяется размером количества элементов, найденных в массиве int, называемым elementsв RecursiveList классе.Вызовите метод startRecursion(), чтобы создать рекурсивный список с определенными элементами, и вызовите count(), чтобы получить количество элементов в массиве, за которыми сразу следует меньшее число .

Основной класс

Это точка входа вашего приложения:

public static void main(String[] args) {

    int count = RecursiveList.startRecursion().count();
    System.out.printf("List has %d recursive elements", count);
}

Класс RecursiveList

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")
}