four -->
two --> four -->
two --> four --> six -->
two --> four --> six --> nine -->
Length: 4
Length: 4
two removed
four --> six --> nine -->
four removed
six --> nine -->
nine removed
six -->
six removed
List is empty
Length: 0
Length: 0

private field
————–
private field is invisible and inacessable to other classes.
Reasons:
1. To prevent data to be corrupted by other classes.
2. You can improve the implementation without causing the other classes to fail.

public class Evil{
public void tamper(){
Date d = new Date(10,10,2010); // this step is possible
// these are not going to work!
d.day =2000;
d.setMonth(56);
}
}

Interfaces
————
The interface of a class is made up of two things:
1. prototype for public methods and
2. the descriptions of the method behaviour.

Abstract Data Types(ADT)
——————————
ADT is a class(s) that has a well defined interface, but whose implementation details are firmly hidden from other classes.

Invarient
———-
Invarient is a fact about a data structure that is always true. (assuming there are no bugs). For example the “Date” object always represents a valid date.
Not all classes are ADTs. Some are just store data(no invarients).

The SList ADT
—————–

Another advantage of having a seperate SList class is that it enforces two invarients:
1. “size” is always correct.
2. list is never circularly linked.

Both of these goals are accomplised through simple Java mechanisms. Only the SList methods can change the lists.

SList ensures this:
1. The fields of the SList class are private. The “head” and “size” are private.
2. No method of SList returns an SListNode.

Inserting or deleting the item from the end of the list takes a lot of time in traversals.

public class DListNode{
int item;
DListNode next; // reference to the next node in list
DListNode prev;// referencet to the previous node in the list
}
public class DList{
private DListNode head; // points to start of the list
private DListNode tail; // points to the end of the list
}

Sentinel
———
A special node that does not represent an item. It is to be noted that the sentinel node does not store an item.

Circularly linked Doubly linked list
————————————

// no changes here
public class DListNode{
int item;
DListNode next; // reference to the next node in list
DListNode prev;// referencet to the previous node in the list
}
// changes here
public class DList{
private DListNode head; // head will point to the sentinel
private int size; // keeps track of the size of the list excluding the sentine.
}

DList invarients with sentinel:
——————————–
1. For any DList data structure d, d.head will never be null.
2. For any DListNode x, x.next is never null.
3. For any DListNode x, x.perv is never null.
4. For any DListNode x, if x.next is == y, then y.perv ==x.
5. For any DListNode x, x.prev ==y, then y.next ==x.
6. A DLists “size” field is number of DListNodes, NOT COUNTING sentinel. The sentinel is always hidden.
7. In empty DLists, the sentinels next and prev point to itselfs.

Advantages over arrays
————————-
1. Inserting an item in the middle of the linked list takes constant amount of time if you have a reference to previous node.
2. Moreover, the list can keep growing until the memory runs out.

Inserting a new item after “this”

public void insertAfter(int item){
next = new ListNode(item, next); // the later "next" is the older value on whatever object we can like l2
}
l2.insertAfter(2);

The last statement creates a new node with the item value 2 and the next parameter is the next value of l2( old ) which points to l3. Now the new “next” value is assigned to the newly created node.

Disadvantages
—————
1. Finding the nth item of the linked list takes time propotional to the length of the list n, number of items in the list. With arrays you can do this in constant time.

A List Class
————-
There are 2 problems with SListNodes:
1. Insert new item at the begining of the list.

x = new SListNode("Soap", x); // problem when two references to same node

2. How do you represent an empty list?

x = null; // runtime error if you try to call any method on x

Solutions
———-
1. Seperate SList class that maintains the head of the list.

public class SList{
private SListNode head; // points to the beginning of the linked list
private int size; // keeps track of the number of SListNodes
public SList(){ // initialisation
head = null; // the idea of an empty list.
size = 0;
}
public void insertFront(Object item){ // we now insert it here and not in SListNode
head = new SListNode(item, head);
size++;
}
}