Linked lists

Classes and their Members

A class is a new kind of data type.

Each of your classes includes various data, such as integers characters and so on.

In addition, a class has the ability to include two other items: Constructors and Methods.

A constructor is designed to provide initial values to a class’ data. It initializes instance variables.

Before any constructor begins its work, all instance variables are assigned Java default values. (numbers default value is zero).
The constructor’s name must be the same as the name of the class.
A constructor does not have any return value. If you write void you will get a compiler error.
No arguments constructor initializes instance variables to its default value, if there is no specified value.

Methods

A method does computations that access the classes’ instance variables. Classes tend to have two kinds of methods.

Accessor methods. Give information about an object without altering the object.
Modification methods. May change the status of an object.

Creating Objects

Once you have created the class (constructor, instance variables and methods) you may create objects of this class.

Use the word "new", and give it a name

ObjectClass objectName = new ObjectClass(arguments);

Calling a method always involves 4 steps.

Name of the newly created object. This will be the reference to it.
Place a single period.
Name of the method.
Parameter list.

When a program has several objects of the same type, each object has its own copies of the instance variables.

Linked lists (our text page 70 – 90)

Again, lets take a look at memory. It is like a pool.

Look at the array, once again.

Look at the vector

Linked lists have

Different Shapes
Offer different navigation rules

Memory building blocks
Custom made to order.

Building and Manipulating linked lists

Whenever a program builds and manipulates a linked list, the nodes are accessed though one or more references to nodes. Typically a program includes a reference to the last and the first node of the list.

Null Reference

Sometimes a reference variable does not refer to anything. This is a null reference, and the value of the variable is called Null.

The null reference and linked lists

The null reference is a special JAVA value that can be used for any reference variable that has nothing to refer to.
The null reference occurs in the link part of the final node of a linked list.
A program that maintains a head and a tail reference may set these references to null, which indicates that the list is empty (has no nodes).

Null Pointer Exception

When a variable is no longer needed it is a good idea to set it to null, allowing JAVA to economize memory resources. JAVA does automatic garbage collection. (draw this as old stuff floating in a swimming pool.)

Null Pointer exception in linked lists.

When a reference variable is null, it is a programming error to activate one of its methods or try to access one of its instance variables.

General Rule:

Never activate a method of the null reference.
Never try to access an instance variable of the null reference.

In both cases the result will be a NullPointerException.

Page 70 in the text.

The Node Class:
The following are examples given by your book, however the book assumes that the Node Class and the List class are in the same JAVA file. In our class examples/exercises we won't assume this. You won't do this for your homework either. However these examples from the book are very understandable and make it easier for the student to understand linked lists for the first time.
Constructor

Public Node(classOfTheObject initialData, Node initialLink)

initialData contains the initial data of this new node

initialLink is a reference to the node after this new node. The reference may be null to indicate that there is no node after this node.

Special names in this methods:

data. This is the data of the node that activated the method.

link. This is the link of the node that activated the method.

Because the link refers to a node, we can also use the names link.data and link.link.

link.data means: Go to the node that links refers to and use the data instance variable.

Link.link means: Go to the node that link refers to and use the link instance variable.

getData()

Accessor method to get the data of this node.

getLink()

Accessor method to get a reference to the next node after this node.

setData()

Modification method to set the data in this node.

setLink();

Modification made to set the reference to the next node after this node.

Adding a New Node at the Head of the Linked List

Suppose that the head is the head reference of a linked list. Then this statement adds a new node at the front of the list with the specified data:

head = new Node(newData, head);

This statement works correctly even if we start with an empty list(in which case the reference is null) Explain with drawings.

Removing a Node from the head of a Linked List

Suppose that head is the head reference of a linked list. Then this statement removes a node from the front of the list:

head = head.getLink();

This statement works correctly even when the list has just one node (in which case the head reference becomes null).

Adding a new node that is not the head

Suppose that selection is a reference to a node of a linked list. Activating the following method adds a new node after the cursor node with element as the new data:

selection.addNodeAfter(element);

The implementation of addNodeAfter needs only one statement to accomplish its work:

link = new Node(element, link);

Removing a Node that is not the head

Suppose that selection is a reference to a node of a linked list. Activating the following method removes the node after the selection node:

Selection.removeNodeAfter();

The implementation of removeNodeAfter needs only one statement to accomplish its work.

link = link.link;

Watch out for the possible NullPointerException with removeNodeAfter. This may happen if the tail node activates removeNodeAfter method. How can we solve this?

Things that we can do with linked lists:

Computing the list length

Traversing the list

Looking for a specific element in the list

Find a node by its position in a linked list

Copying a linked list

Append one list to another

Count occurrences of a given element

Assignment statements with reference variables

If t1 and t2 are reference variables, the assignment t1 = t2 is allowed.

If t1 is null then the assignment also makes t2 null.

If t1 is not null then the assignment changes t2 so that it refers to the same object that t1 already refers to. At this point changes to that object can be made to that one object through either t1 or t2.

* Think of x = 5; y=x; y++; now x = 5 and y = 6; In primitive data types it clones automatically. Objects are different, you need to do the trick manually.

Test for equality with reference variables

For reference variables t1 and t2, the test (t1 == t2) is true if both references are null, or if t1 and t2 refer to the same object but not for two different objects that happen to have the same vales for their instance variables.