Removing and returning item at index Linked List

Question

package linkedList.list;

import linkedList.node.ListNode;

public interface LinkedList<N extends ListNode<T>,T>
{
   
    public boolean isEmpty();

    
    public int size();

   
    public String toString();

    
    public T[] toArray(Class<? extends T> cl);

    
    public LinkedList<N,T> fromArray(T[] array) throws ListAccessError;
}

package linkedList.list;

import linkedList.node.ListNode;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;

public abstract class BasicList<N extends ListNode<T>,T> implements LinkedList<N,T> {

    N root;

    int size;

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    public N getRoot() {
        return root;
    }

   
    public void setRoot(N newRoot) {
        root = newRoot;
    }

   
    public T[] toArray(Class<? extends T> cl) {
        T[] array = (T[]) Array.newInstance(cl,size());
        ListNode<T> node = getRoot();
        for (int index = 0; index < size(); index++) {
            array[index] = node.getValue();
            node = node.getNext();
        }
        return array;
    }

   
    public String toString() {
        if (isEmpty()) {
            return "[]";
        } else {
            ListNode<T> currentNode = getRoot();
            StringBuilder string = new StringBuilder("[" + currentNode.getValue());
            while ((currentNode = currentNode.getNext()) != null) {
                string.append("," + currentNode.getValue());
            }
            string.append("]");
            return string.toString();
        }
    }

   
    public String toString(int n) {
        if (isEmpty()) {
            return "[]";
        } else {
            ListNode<T> currentNode = getRoot();
            StringBuilder string = new StringBuilder("[" + currentNode.getValue());
            int added = 0;
            while (added < n && (currentNode = currentNode.getNext()) != null) {
                string.append("," + currentNode.getValue());
                added++;
            }
            if (currentNode != null) {
                string.append(",...");
            }
            string.append("]");
            return string.toString();
        }
    }
}

package linkedList.list;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader;
import jdk.nashorn.internal.ir.IfNode;
import linkedList.node.ListNode;
import linkedList.node.SingleLinkNode;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class SingleLinkList<T> extends BasicList<SingleLinkNode<T>,T> implements List<T> {

    public SingleLinkList<T> fromArray(T[] array) throws ListAccessError {
        for (int index = array.length-1; index >= 0; index--) {
            add(0,array[index]);
        }
        return this;
    }

    ListNode<T> getNode(int index) throws ListAccessError {
        // Is the list empty?  If so, cannot access the node.
        if (isEmpty()) {
            throw new ListAccessError("Cannot get node.  List is empty.");
        }
        // Is the given index negative?  If so, this is an error.
        if (index < 0) {
            throw new ListAccessError("Cannot get node.  Negative index.");
        }

        ListNode<T> currentNode = getRoot(); // start at the root
        while (index != 0 && currentNode != null) { // walk along the list (if haven't reached the end by hitting null node)
            currentNode = currentNode.getNext(); // by gettting next node in the list
            index--; // and reducing index by one
        }
        // Reached the end of the list (by hitting null node)?  If so, cannot access the required node.
        if (currentNode == null) {
            throw new ListAccessError("Cannot get node.  Not enough nodes in the list.");
        }
        // Successfully found node by walking through until index was zero.
        return currentNode;
    }

    public T get(int index) throws ListAccessError {
        return getNode(index).getValue();
    }

    @Override
    public void add(int index, T value) throws ListAccessError {
        if (index > size() || index < 0) {
            throw new ListAccessError("Index bigger than size.");
        }

        SingleLinkNode<T> newNode = new SingleLinkNode<T>(value);
        SingleLinkNode<T> current = getRoot();

        if(index==0) {
            setRoot(newNode);
            newNode.setNext(current);
            size++;
        } else {
            while(--index > 0) {
                current = current.getNext();
            }
            newNode.setNext(current.getNext());
            current.setNext(newNode);
            size++;
        }
    }

    @Override
    public T remove(int index) throws ListAccessError {
        if (index >= size() || index < 0) {
            throw new ListAccessError("Index out of bounds");
        }
        if (isEmpty()) {
            throw new ListAccessError("List is empty cannot remove from list");
        }

        SingleLinkNode<T> current = getRoot();
        SingleLinkNode<T> nextItem = getRoot().getNext();
        

        return null;
    }
}
package linkedList.node;

public class SingleLinkNode<T> implements ListNode<T>
{

  private T value;

  private SingleLinkNode<T> next;

  public SingleLinkNode(T value) {
    this.value = value;
    next = null;
  }

  public SingleLinkNode(T value, SingleLinkNode<T> next) {
    this.value = value;
    this.next = next;
  }

  public T getValue() {
    return value;
  }

  @Override
  public void setValue(T value) {
    this.value = value;
  }

  public SingleLinkNode<T> getNext() {
    return next;
  }

  @Override
  public void setNext(ListNode<T> node) {
    next = (SingleLinkNode<T>) node;
  }

  public String toString() {
    return value + (getNext() != null ? "=>" + getNext() : "");
  }
}

I have just implemented the add method which takes the index and the value and inserts it into that position in the List. However when researching how to remove at the index I am unable to find anything that removes the node with just the given index. Any help is welcome and thanks in advance for any solutions!

Answer 1

When removing a node from a linked list at I position all you need to do is

1. Get to the node at i-1, let's name it 'n1'
2. Get the node n2=n1.next.next
3. Make n1.next =n2

You simply remove the "link" to the requested node at i and it's no longer part of the linked list.

Answer 2

Firstly, you have to check if this it is 0-th index you have to remove, so you have to shift root. Then for removing node at i-th root, all you have to do this:

nodeBeforeI.setNext(nodeBeforeI.getNext().getNext()); 

The complete code:

public T remove(int index) throws ListAccessError {
        if (index >= size() || index < 0) {
            throw new ListAccessError("Index out of bounds");
        }
        if (isEmpty()) {
            throw new ListAccessError("List is empty cannot remove from list");
        }

        SingleLinkNode<T> current = getRoot();
        SingleLinkNode<T> removed;
        if (index == 0){
            removed = current;
            setRoot(current.getNext()); // setting root to root.next
        }else{
            for (int i = 0; i < index -1; i++){
                current = current.getNext();
            }
            removed = current.getNext();
            current.setNext(current.getNext().getNext()); 
        }
        

        return removed.getValue();
    }