LINKED LIST’S EXAMPLES Salim Malakouti

Linked List? 523 Pointer Node ValuePointer

Node Class  public class Node {  /**  * Data  */  private T value;  /**  * Pointer to the next Node  */  private Node next;  public Node(T value, Node next) {  this.setValue(value);  this.setNext(next);  }  …  }

Comprehension Questions

Question 1  If we just want to iterate over the list and print all values, which one is faster why?  Array  Linked List?

Answer  Array  Because all elements are beside each other. There is no need for scanning the file.

Algorithmic Questions

How to add a new value to the list? Question 1

 /**  * This function simply adds a new node to the list by adding it to the  * beginning.  *  value  */  public void add(T value) {  Node tmp = getHead();  setHead(new Node<>(value));  getHead().setNext(tmp);  }

How to clear the Linked List? Question 2

Clear  /**  * This function simply clears the list  */  public void clear() {  setHead(null);  }

How to find the size? Question 3

Size  /**  * Computes the size of the list.  *   */  public int size() {  Node current = getHead();  int size = 0;  while (current != null) {  current = current.getNext();  size++;  }  return size;  }

Size Recursive  /**  * Computes the size of the list but using a recursive function.  *   */  public int sizeRecursive() {  return sizeR(head);  }  /**  * The inner part of the recursive size  head   */  private int sizeR(Node head) {  if (head == null)  return 0;  else  return sizeR(head.getNext()) + 1;  }

How to get the last value? Question 4

Get Tail  /**  * This function returns the last element.  *   */  public Node getTail() {  Node current = getHead();  while (current.getNext() != null) {  current = current.getNext();  }  return current;  }

Get Tail Recursive  public Node getTailRecursive() {  return tailR(head);  }  /**  * Inner function for finding tail recursively  node   */  private Node tailR(Node node) {  if (node.getNext() == null)  return node;  return tailR(node.getNext());  }

How to append to lists? Question 5

Append  /**  * Append the input list to the end of this list.  *  l  */  public void append(LinkedList l) {  Node tail = getTail();  if (tail == null) {  head = l.getHead();  } else {  tail.setNext(l.getHead());  } 

How to check if a specific value is in the list? Question 6

Has Value  /**  * This function checks to see if there is a node with value equal to the  * input.  *  value  */  public boolean hasValue(T value) {  Node current = getHead();  while (current != null) {  if (current.getValue().equals(value)) {  return true;  }  current = current.getNext();  }  return false;  }

How to find the ith element? Question 7

Get ith  /**  * This function returns the ith item in the list.  */  public T get(int index) {  Node current = getHead();  int i = 0;  while (current != null) {  if (i == index)  return current.getValue();  current = current.getNext();  i++;  }  return null;  }

How to remove a specific element? Question 8

Remove  /**  * This functions removes nodes in the list equal to the input. Only one at  * a time.  *  value  */  public void remove(T value) {  Node pre = null;  Node current = getHead();  while (current != null) {  if (current.getValue().equals(value)) {  if (pre != null) {  pre.setNext(current.getNext());  } else {  setHead(current.getNext());  }  break;  }  pre = current;  current = current.getNext();  }

How to reverse the list? Question 9

Reverse  /**  * This function simply reverses the list  */  public void reverse() {  Node next = getHead();  Node pre = null;  Node tmp = null;  while (next != null) {  tmp = next;  next = next.getNext();  tmp.setNext(pre);  pre = tmp;  }  setHead(tmp);  }

How to insert in ith position? Question 10

Insert in ith position  public void insert(int index, T value) {  Node current = getHead();  Node pre = null;  int i = 0;  while (current != null) {  if (i == index) {  if (pre != null) {  pre.setNext(new Node(value, current));  } else {  setHead(new Node(value, current));  }  pre = current;  current = current.getNext();  i++;  }