/**

******************************************************************************
*
15-111
******************************************************************************
* Recursive implementations of some basic LinkedList operations
*
*
*****************************************************************************/
import java.util.*;
public class LinkedList<AnyType>
{
private Node<AnyType> head;
/**
* Constructs an empty list
*/
public LinkedList()
{
head = null;
}
/**
* Returns true if the list is empty
*
*/
public boolean isEmpty()
{
return head == null;
}
/**
* Inserts a new node at the beginning of this list.
*
*/
public void addFirst(AnyType item)
{
head = new Node<AnyType>(item, head);
}
/**
* Returns the first element in the list.
*
*/
public AnyType getFirst()
{
if(head == null) throw new NoSuchElementException();
return head.data;
}
/**
* Removes the first element in the list.
*
*/
public AnyType removeFirst()
{
AnyType tmp = getFirst();
head = head.next;
return tmp;
}
/**
* Recursively inserts a new node to the end of this list.

*
*/
public void addLast(AnyType item)
{
if( head == null)
addFirst(item);
else
addLast(head, item);
}
private void addLast(Node<AnyType> node, AnyType item)
{
if(node.next != null) addLast(node.next, item);
else
node.next = new Node<AnyType>(item, null);
}
/**
* Returns a string representation
*
*/
public String toString()
{
return toString(head);
}
private String toString(Node node)
{
if(node == null) return "";
else
return node.data + " " + toString(node.next);
}
/**
* Recursively inserts a new node after a node containing the key.
*
*/
public void insertAfter(AnyType key, AnyType toInsert)
{
insertAfter(head, key, toInsert);
}
public void insertAfter(Node<AnyType> node, AnyType key, AnyType toInsert)
{
if(node == null)
return;
else
if(node.data.equals(key))
node.next = new Node<AnyType>(toInsert, node.next);
else
insertAfter(node.next, key, toInsert);
}
/**
* Recursively inserts a new node before a node containing the key.
*
*/
public void insertBefore(AnyType key, AnyType toInsert)
{
head = insertBefore(head, key, toInsert);
}
public Node<AnyType> insertBefore(Node<AnyType> node, AnyType key, AnyType to
Insert)
{

if(node == null)
return null;
else
if(node.data.equals(key))
return new Node<AnyType>(toInsert, node);
else
node.next = insertBefore(node.next, key, toInsert);
return node;
}
/**
* Recursively deletes the first occurrence of an item.
*
*/
public void delete(AnyType x)
{
head = delete(head, x);
}
private Node<AnyType> delete(Node<AnyType> node, AnyType x)
{
if (node == null)
throw new java.util.NoSuchElementException("cannot delete.");
else
if(node.data.equals(x))
return node.next;
else
node.next = delete(node.next, x);
return node;
}
/**
* Recursively deletes a node at specified index
*
*/
public void deleteAt(int p)
{
head = deleteAt(p, head);
}
public Node<AnyType> deleteAt(int p, Node<AnyType> node)
{
if(node == null)
throw new java.util.NoSuchElementException("cannot delete.");
else
if(p == 0)
return node.next;
else
node.next = deleteAt(p-1, node.next);
return node;
}
/**
* Creates a deep copy
*
*/
public LinkedList<AnyType> clone()
{
LinkedList<AnyType> twin = new LinkedList<AnyType>();
twin.head = cloneR(head);
return twin;

}
private Node<AnyType> cloneR(Node<AnyType> p)
{
if(p == null)
return null;
else
return new Node<AnyType>(p.data, cloneR(p.next) );
}
/**
* Removes all nodes greater than keyItem
*
*/
public void removeAllGreaterItems(Comparable<AnyType> keyItem)
{
head = removeAllGreaterItems(head, keyItem);
}
private Node<AnyType> removeAllGreaterItems(Node<AnyType> p, Comparable<
AnyType> key)
{
if(p == null) return null;
else
if(key.compareTo(p.data) < 0)
return removeAllGreaterItems(p.next, key);
else
p.next = removeAllGreaterItems(p.next, key);
return p;
}
/**
* Removes all nodes lesser than keyItem
*
*/
public void removeAllLesserItems(Comparable<AnyType> keyItem)
{
head = removeAllLesserItems(head, keyItem);
}
private Node<AnyType> removeAllLesserItems(Node<AnyType> p, Comparable<AnyTyp
e> key)
{
if(p == null) return null;
else
if(key.compareTo(p.data) > 0)
return removeAllLesserItems(p.next, key);
else
p.next = removeAllLesserItems(p.next, key);
return p;
}
/*******************************************************
*
* The Node class
*
********************************************************/
private static class Node<AnyType>
{
private AnyType data;
private Node<AnyType> next;
public Node(AnyType data, Node<AnyType> next)
{

this.data = data;
this.next = next;
}
}

/*****

Include the main() for testing and debugging *****/

public static void main(String[] args)

{
LinkedList<String> list = new LinkedList<String>();
list.addLast("l");
list.addLast("i");
list.addLast("s");
list.addLast("t");
list.insertBefore("l", "s");
list.delete("s");
System.out.println(list);
}
}