связанного списка получить метод retrieveAt

Question

У меня есть следующее домашнее задание:

Добавить новый метод retrieveAt для класса IntSLList, который принимает позицию индекса целочисленной в качестве параметра.

Метод возвращает информацию внутри узла в позиции индекса. Индекс первого узла равен 0. Если список пуст или индекс недопустим, отобразите сообщение об ошибке.

я реализовал решение, используя следующий код:

public int retrieveAt(int pos){ 
    IntSLLNode tmp; 
    int count = 0; 
    int c; 
    for(tmp = head; tmp != null; tmp = tmp.next){ 
     count++; 
    } 
    if(isEmpty()|| count<pos){ 
     return 0; 
    } else { 
     IntSLLNode tmp1 = head; 
     for(int i = 1; i < pos; i++){ 
      if(tmp1.next == null) 
       return 0; 
      tmp1 = tmp1.next; 
     } 
     return tmp1.info; 
    } 
} 

Оказывается, для просмотра списка правильно, но не получить правильный элемент.

Пример случай, когда это не представляется дать правильный вывод:

IntSLList myn = new IntSLList(); 

myn.addToHead(10); 
myn.addToHead(20); 
myn.addToHead(30); 
myn.addToHead(40); 
myn.addToTail(60); 
myn.printAll(); 

int x = myn.retrieveAt(4); 
if(x == 0) 
    System.out.println("NOT VALID "); 
else 
    System.out.println("elm : " + x); 

Выход есть:

40 
30 
20 
10 
60 
elm : 10 

Answer 1

int x=myn.retrieveAt(4); 

вы получаете элемент вперед, потому что вы использовали магические номер 4. Я бы предложил использовать либо количество элементов в myn, либо выяснить, есть ли у вас более простой способ сделать это при реализации класса IntSLList.

Answer 2

Я не уверен, что делать addToHead (добавить в начале или в конце). Я создал этот небольшой примерный класс, который делает оба, выберите метод, который соответствует вашей терминологии.

Пример отнюдь не полный, не проверяет ошибки и т. Д. Я попытался прочитать ваш код и почувствовал, что для циклов очень запутаны. Возможно, это вас тоже смущает? Вот почему я сделал этот пример, который помещает вас в положение каждого узла, чтобы выяснить, что делать дальше, и работает рекурсивно.

Основные операции, связанные с добавлением элемента: Знаю ли я следующий узел? (это конец цепочки?) Должен ли я передать свое значение на следующий узел или значение, которое было передано мне? (Где необходимо новое значение будет добавлено конец или начало?)

public class Node 
{ 
    private Node next; 
    private Integer value; 

    public Node() 
    { 
    } 

    public void push(Integer value) 
    { 
     if(next != null) 
      next.push(value); 
     else 
     { 
      next = new Node(); 
      this.value = value; 
     } 
    } 

    public void unshift (Integer value) 
    { 
     if(next != null) 
     { 
      next.unshift(this.value); 
     } 
     else 
     { 
      next = new Node(); 
      next.value = this.value; 
     } 
     this.value = value; 
    } 

    public Integer get(int index) 
    { 
     if(index > 0) 
      return next.get(--index); 
     else 
      return value; 
    } 


    public int length() 
    { 
     if(next == null) 
      return 0; 
     else 
      return next.length() + 1; 
    } 

    public static void main(String[] args) 
    { 
     Node pushedList = new Node(); 

     pushedList.push(10); 
     pushedList.push(20); 
     pushedList.push(30); 
     pushedList.push(40); 

     for(int i = 0; i < pushedList.length(); ++i) 
     { 
      System.out.println("pushed element #" + i +": " + pushedList.get(i)); 
     } 

     Node unshiftedList = new Node(); 

     unshiftedList.unshift(10); 
     unshiftedList.unshift(20); 
     unshiftedList.unshift(30); 
     unshiftedList.unshift(40); 

     for(int i = 0; i < unshiftedList.length(); ++i) 
     { 
      System.out.println("unshifted element #" + i +": " + unshiftedList.get(i)); 
     } 

     Node mixedList = new Node(); 

     mixedList.unshift(10); 
     mixedList.push(20); 
     mixedList.unshift(30); 
     mixedList.push(40); 

     for(int i = 0; i < mixedList.length(); ++i) 
     { 
      System.out.println("mixed element #" + i +": " + mixedList.get(i)); 
     } 
    } 
} 

Edit: вот выход я получаю:

pushed element #0: 10 
pushed element #1: 20 
pushed element #2: 30 
pushed element #3: 40 
unshifted element #0: 40 
unshifted element #1: 30 
unshifted element #2: 20 
unshifted element #3: 10 
mixed element #0: 30 
mixed element #1: 10 
mixed element #2: 20 
mixed element #3: 40