COMP 213 Advanced Object-oriented Programming Lecture 13 Linked - - PowerPoint PPT Presentation

COMP 213

Advanced Object-oriented Programming Lecture 13 Linked Lists.

Linked Lists

• The array and the linked list are the two primary building blocks for the

more complex data structures.

• Difference: underlying layout of the data in memory & way of accessing

Linked Lists

• The array and the linked list are the two primary building blocks for the

more complex data structures.

• Difference: underlying layout of the data in memory & way of accessing

Linked Lists

• The array and the linked list are the two primary building blocks for the

more complex data structures.

• Difference: underlying layout of the data in memory & way of accessing

We call this small separate block of memory a “node”

Linked Lists

• The linked lists in the Collections library are sufficient for many applications.
• We need to understand how they work, both to appreciate their limitations,

and also to be able to build custom linked list classes when needed.

Linked Lists

• The linked lists in the Collections library are sufficient for many applications.
• We need to understand how they work, both to appreciate their limitations,

and also to be able to build custom linked list classes when needed.

Linked Lists

• The array structure allows us to access any element directly via its index.
• The linked list structure seems very limited, as its nodes can only be

accessed in a sequential manner.

• So why bother using Linked Lists?

Linked Lists

• The array structure allows us to access any element directly via its index.
• The linked list structure seems very limited, as its nodes can only be

accessed in a sequential manner.

• So why bother using Linked Lists?

Why Linked Lists?

• The size of an array is fixed. The size of a linked list varies. The nodes of a linked list can be

allocated on an “as needed” basis. When no longer needed, the nodes can be returned to the memory manager.

• For some operations a linked list is a more efficient implementation approach than an

array, e.g., to place an element into the front of a collection:

Why Linked Lists?

• The size of an array is fixed. The size of a linked list varies. The nodes of a linked list can be

allocated on an “as needed” basis. When no longer needed, the nodes can be returned to the memory manager.

• For some operations a linked list is a more efficient implementation approach than an

array, e.g., to place an element into the front of a collection:

Why Linked Lists?

• The size of an array is fixed. The size of a linked list varies. The nodes of a linked list can be

allocated on an “as needed” basis. When no longer needed, the nodes can be returned to the memory manager.

• For some operations a linked list is a more efficient implementation approach than an

array, e.g., to place an element into the front of a collection:

Creating our Linked List Class

• To create a linked list we need to know how to do two things:
• allocate space for a node dynamically, and
• allow a node to link to, or reference, another node.
• Java supplies an operation for dynamically allocating space, an operation we

have been using for all of our objects —the new operation.

• How can we allow a node to reference another node?

Creating our Linked List Class

• To create a linked list we need to know how to do two things:
• allocate space for a node dynamically, and
• allow a node to link to, or reference, another node.
• Java supplies an operation for dynamically allocating space, an operation we

have been using for all of our objects —the new operation.

• How can we allow a node to reference another node?

Creating our Linked List Class

• To create a linked list we need to know how to do two things:
• allocate space for a node dynamically, and
• allow a node to link to, or reference, another node.
• Java supplies an operation for dynamically allocating space, an operation we

have been using for all of our objects —the new operation.

• How can we allow a node to reference another node?

Creating our Linked List Class

• To create a linked list we need to know how to do two things:
• allocate space for a node dynamically, and
• allow a node to link to, or reference, another node.
• Java supplies an operation for dynamically allocating space, an operation we

have been using for all of our objects —the new operation.

• How can we allow a node to reference another node?

Self-referencing our Linked List Class

• Essentially a node in a linked list is an object that holds some important

information, e.g., a string, plus a link to another node.

• That other node is the exact same type of object —it is also a node in the

linked list.

• When we define our node class, we must allow the objects created from it to

reference node class objects. We call this type of class a self-referential class.

Self-referencing our Linked List Class

• Essentially a node in a linked list is an object that holds some important

information, e.g., a string, plus a link to another node.

• That other node is the exact same type of object —it is also a node in the

linked list.

• When we define our node class, we must allow the objects created from it to

reference node class objects. We call this type of class a self-referential class.

Self-referencing our Linked List Class

• Essentially a node in a linked list is an object that holds some important

information, e.g., a string, plus a link to another node.

• That other node is the exact same type of object —it is also a node in the

linked list.

• When we define our node class, we must allow the objects created from it to

reference node class objects. We call this type of class a self-referential class.

Self-referential class: A class that includes an instance variable or variables that can hold a reference to an object of the same class.

Creating our Linked List Class

• We include in the class definition two instance variables:
• one that holds the important information that the linked list is maintaining (e.g., a

string), and

• one that is a reference to an object of its same class.

Example: The LLStringNode Class

public class LLStringNode { private String info; // information stored in list private LLStringNode link; // reference to a node ... }

Example: The LLStringNode Class

public class LLStringNode { private String info; // information stored in list private LLStringNode link; // reference to a node ... } Instance variable info to hold a reference to the string represented by the node.

Example: The LLStringNode Class

public class LLStringNode { private String info; // information stored in list private LLStringNode link; // reference to a node ... } Instance variable link to hold a reference to another LLStringNode object.

Example: The LLStringNode Class

public class LLStringNode { private String info; // information stored in list private LLStringNode link; // reference to a node ... } Instance variable link to hold a reference to another LLStringNode object. That other LLStringNode can hold a reference to a String (info) and a reference to another LLStringNode object, …

Example: The LLStringNode Class

public class LLStringNode { private String info; // information stored in list private LLStringNode link; // reference to a node ... } Instance variable link to hold a reference to another LLStringNode object. That other LLStringNode can hold a reference to a String (info) and a reference to another LLStringNode object, … Chain ends when a LLStringNode holds the value null in its link.

Example of LLStringNode linked list

The LLStringNode Class

public class LLStringNode { ... public LLStringNode(String info) { this.info = info; link = null; } ... }

The LLStringNode Class

public class LLStringNode { ... public LLStringNode(String info) { this.info = info; link = null; } ... }

E.g., LLStringNode node1 = new LLStringNode(“basketball”); results in:

node1

How to represent an empty linked list?

• Declare a variable of the class LLStringNode.
• Do not instantiate with the new operation.
• Then, the value held in the string node variable is null:

LLStringNode theList;

How to represent an empty linked list?

• Declare a variable of the class LLStringNode.
• Do not instantiate with the new operation.
• Then, the value held in the string node variable is null:

LLStringNode theList;

How to represent an empty linked list?

• Declare a variable of the class LLStringNode.
• Do not instantiate with the new operation.
• Then, the value held in the string node variable is null:

LLStringNode theList;

The LLStringNode Class (cont.)

public class LLStringNode { ... public void setInfo(String info) { this.info = info; } public String getInfo(){ return info; } public void setLink(LLStringNode link) { this.link = link; } public LLStringNode getLink() { return link; } }

node1

Example

LLStringNode node1 = new LLStringNode(“basketball”); LLStringNode node2 = new LLStringNode(“baseball”); node1.setLink(node2); results in:

Example

LLStringNode node1 = new LLStringNode(“basketball”); LLStringNode node2 = new LLStringNode(“baseball”); node1.setLink(node2); results in:

node1 node2

Standard Linked List Operations

• Traversal: go through the list and display the information of each node.
• Insertion: insert a new node in the list –where?
• Removal: remove a node from the list.

Traversal

• We need some way to keep track of our current position in the list.
• We need to use a variable, currNode, that can reference the current node
• f the list.

Traversal

• We need some way to keep track of our current position in the list.
• We need to use a variable, currNode, that can reference the current node
• f the list.

With an array we use an index variable; that will not work here because a linked list is not indexed.

Traversal

• We need some way to keep track of our current position in the list.
• We need to use a variable, currNode, that can reference the current node
• f the list.

Pseudocode for Traversal

Set currNode to first node on the list while (currNode is not pointing off the end of the list) display the information at currNode change currNode to point to the next node on the list

Java code for traversal

LLStringNode currNode = letters; //letters is the name of our linked list while (currNode is not pointing off the end of the list) display the information at currNode change currNode to point to the next node on the list

Java code for traversal

LLStringNode currNode = letters; //letters is the name of our linked list while (currNode is not pointing off the end of the list) display the information at currNode change currNode to point to the next node on the list

Java code for traversal

LLStringNode currNode = letters; //letters is the name of our linked list while (currNode is not pointing off the end of the list) System.out.println(currNode.getInfo( )) ; change currNode to point to the next node on the list

Java code for traversal

LLStringNode currNode = letters; //letters is the name of our linked list while (currNode is not pointing off the end of the list) System.out.println(currNode.getInfo( )) ; change currNode to point to the next node on the list

Java code for traversal

LLStringNode currNode = letters; //letters is the name of our linked list while (currNode is not pointing off the end of the list) System.out.println(currNode.getInfo( )) ; currNode = currNode.getLink();

Java code for traversal

LLStringNode currNode = letters; //letters is the name of our linked list while (currNode is not pointing off the end of the list) System.out.println(currNode.getInfo( )) ; currNode = currNode.getLink();

Java code for traversal

LLStringNode currNode = letters; //letters is the name of our linked list while (currNode != null){ System.out.println(currNode.getInfo( )) ; currNode = currNode.getLink(); }

Java code for traversal

LLStringNode currNode = letters; //letters is the name of our linked list while (currNode != null){ System.out.println(currNode.getInfo( )) ; currNode = currNode.getLink(); } Does this code still work for empty linked lists? Always double-check when dealing with linked lists!

Traversal on our linked list

Traversal on our linked list

Traversal on our linked list

Traversal on our linked list

Traversal on our linked list

Insertion

We need to consider 3 cases:

• insertion at the beginning of the list,
• insertion in the middle of the list, and
• insertion at the end of the list.

Insertion at the beginning

Insertion at the beginning

Insertion at the beginning

newNode.setLink(letters); letters = newNode; // the order of these lines of //code matters! What happens //if you reverse them?

Insertion in the middle

Insertion in the middle

Insertion in the middle

newNode.setLink(letters.getLink()); letters.setLink(newNode);

Insertion at the end

Insertion at the end

Insertion at the end

LLStringNode currNode = letters; while (currNode.getLink() != null) { currNode = currNode.getLink(); } currNode.setLink(newNode);

Summary

• Linked Lists
• Self-referencing a node class to create a linked list
• Traversal & Insertion in a Linked List
• Next: Propositional Logic