Linked Lists

About This Presentation

Title:

Linked Lists

Description:

Finding a particular 'box car' in a linked list isn't as easy. You have to board the first 'box car' in the list, and go through them in order ... – PowerPoint PPT presentation

Number of Views:44

Avg rating:3.0/5.0

Slides: 84

Provided by: paulc1

Category:

more less

Transcript and Presenter's Notes

Title: Linked Lists

1
Linked Lists

A Linked List holds a collection of objects
An Array can also hold a collection of objects
You could have an array of Strings for example,
or a Linked List of Strings
While in some ways they are similar, there are
some important differences

2
Linked Lists vs Arrays

Think of an Array like the mailboxes in an
apartment buildinga series of identical boxes
identified by a number
Think of Linked Lists like a traina series of
box cars each one hooked up to the next

3
Linked Lists vs Arrays

When you create an array it has a fixed size. You
cannot add or remove "mail boxes"
A Linked List is more flexible. Just like a
train, you can add or remove as many "box cars"
as you want, anywhere in the train

4
Linked Lists vs Arrays

Arrays are fast and easy to accessif you know
the index of the "mail box" you want, you can
immediately access it.
Finding a particular "box car" in a linked list
isn't as easy. You have to board the first "box
car" in the list, and go through them in order to
find the one you are looking for.

5
A Linked List of Strings
"one"
"three"
"two"
"end"
"head"

Each "box car" holds a String, and a handle to
the next "box car" in the list
We call each "box car" a node

6
A Linked List of Strings
"one"
"three"
"two"
"end"
"head"

To make a list from scratch, we'd need a class to
represent each node
class Node
???

7
A Linked List of Strings
"one"
"three"
"two"
"end"
"head"

Each node has a String and a handle to the next
node
class Node
String sWord
Node next

8
A Linked List of Strings
"one"
"three"
"two"
"end"
"head"

We'll need a constructor, and good style says the
members should be public or private
class Node
private String sWord
private Node next
public Node(String sW, Node n)
sWord sW
next n

9
A Linked List of Strings
"one"
"three"
"two"
null
"head"

The first node in a list is commonly called the
head
To indicate the end of a list, the handle of the
last node is null

10
A Linked List of Strings
"one"
"three"
"two"
null
"head"

To build my first list, I'll start with the end
node and work forwards
Node three new Node("three",null)

11
A Linked List of Strings
"one"
"three"
"two"
null
"head"

To build my first list, I'll start with the end
node and work forwards
Node three new Node("three",null)
Node two new Node("two",three)

12
A Linked List of Strings
"one"
"three"
"two"
null
"head"

To build my first list, I'll start with the end
node and work forwards
Node three new Node("three",null)
Node two new Node("two",three)
Node head new Node("one",two)

13
A Linked List of Strings
"one"
"three"
"two"
null
"head"

Normally, we don't have a "name" for each node,
just the handle in the previous node
Node three new Node("three",null)
Node two new Node("two",three)
Node head new Node("one",two)

14
A Linked List of Strings
"one"
"three"
"two"
null
"head"

Normally, we don't have a "name" for each node,
just the handle in the previous node
Node three new Node("three",null)
Node two new Node("two",three)
Node head new Node("one",
new Node("two",three))

15
A Linked List of Strings
"one"
"three"
"two"
null
"head"

Normally, we don't have a "name" for each node,
just the handle in the previous node
Node three new Node("three",null)
Node two new Node("two",three)
Node head new Node("one",
new Node("two",
new Node("three",null)))

16
A Linked List of Strings
"one"
"three"
"two"
null
"head"
temp

Now let's write some code that displays the
contents of all the nodes to the screen
Node head new Node("one",
new Node("two",
new Node("three",null)))
Node temp head
while(temp ! null)
System.out.println(temp.sWord)
temp temp.next

17
A Linked List of Strings
"one"
"three"
"two"
null
"head"
temp

Now let's write some code that displays all the
contents of all the nodes to the screen
Node head new Node("one",
new Node("two",
new Node("three",null)))
Node temp head
while(temp ! null)
System.out.println(temp.sWord)
temp temp.next

18
A Linked List of Strings
"one"
"three"
"two"
null
"head"
temp

Now let's write some code that displays all the
contents of all the nodes to the screen
Node head new Node("one",
new Node("two",
new Node("three",null)))
Node temp head
while(temp ! null)
System.out.println(temp.sWord)
temp temp.next

19
A Linked List of Strings
"one"
"three"
"two"
null
"head"
temp

The problem with the following code is that sWord
and next are private
Node temp head
while(temp ! null)
System.out.println(temp.sWord)
temp temp.next

20
A Linked List of Strings

Node temp head
while(temp ! null)
System.out.println(temp.getWord())
temp temp.getNext()
. . .
class Node
private String sWord
private Node next
public Node(String sW, Node n)
sWord sW
next n
public String getWord()return sWord
public Node getNext()return next

21
Why temp? What would be the output of the
following code?

Node head new Node("one",
new Node("two",
new Node("three",null)))
while(head ! null)
System.out.println(head.getWord())
head head.getNext()
while(head ! null)
System.out.println(head.getWord())
head head.getNext()

22
Fill in the blanks so that the following
application produces the indicated output

public class LinkedListDemo
public static void main(String args)
Node head ____________________
_________________________
___________________________
____________________________
Node temp head
while(________________)
_____________________________
_____________________________
/ sample output
apple
banana
coconut

23
Writing a Linked List class

The code to create, display, and add and removes
nodes of a linked list is usually encapsulated in
a class
class LinkedList
???

24
Writing a Linked List class

Every list has a head, and we'll need a
constructor
class LinkedList
private Node head
public LinkedList()???

25
Writing a Linked List class

A new list should be empty
class LinkedList
private Node head
LinkedList()head null

26
Writing a Linked List class
head
null

Since we're starting with an empty list, we'll
need a way to add Nodes. It's easiest to add
nodes at the Front of the list
class LinkedList
private Node head
LinkedList()head null
public void addFront(???)
???

27
Writing a Linked List class
head
null
"one"

To add a node at the front, there are two steps
The new nodes next handle is "hooked up" to the
same place as head
class LinkedList
private Node head
LinkedList()head null
public void addFront(???)
???

28
Writing a Linked List class
head
null
"one"

To add a node at the front, there are two steps
The new nodes next handle is "hooked up" to the
same place as head
Head is "hooked up" to the new node
class LinkedList
private Node head
LinkedList()head null
public void addFront(???)
???

29
Writing a Linked List class
head
null
"one"

To add a node at the front, there are two steps
The new nodes next handle is "hooked up" to the
same place as head
Head is "hooked up" to the new node
To get this to work, we'll need a setNext()
method in the Node class
class Node
private String sWord
private Node next
public Node(String sW, Node n)
sWord sW
next n
public String getWord()return sWord
public Node getNext()return next
public void setNext(Node n)next n

30
Writing a Linked List class
head
null
"one"

To add a node at the front, there are two steps
The new nodes next handle is "hooked up" to the
same place as head
class LinkedList
private Node head
LinkedList()head null
public void addFront(Node newNode)
newNode.setNext(head)

31
Writing a Linked List class
head
null
"one"

To add a node at the front, there are two steps
The new nodes next handle is "hooked up" to the
same place as head
Head is "hooked up" to the new node
class LinkedList
private Node head
LinkedList()head null
public void addFront(Node newNode)
newNode.setNext(head)
head newNode

32
An alternative to passing the node as an
argument, is to just pass the data

class LinkedList
private Node head
LinkedList()head null
public void addFront(String sWord)
Node newNode new Node(sWord,null)
newNode.setNext(head)
head newNode

33
We can actually do this with one line

class LinkedList
private Node head
LinkedList()head null
public void addFront(String sWord)
head new Node(sWord,head)

34
Removing a Node

Before we can remove a node, we have to find it
We traverse the list, moving from one node to the
next until we find the one we want to delete
Then we rearrange the handles to "skip over" the
target node

35
Removing a Node
"one"
"three"
"two"
null
"head"

Let's say we want to delete node "three"

36
Removing a Node
"one"
"three"
"two"
null
"head"

Let's say we want to delete node "three"
"two's" next handle should skip over "three"

37
Removing a Node
"one"
"three"
"two"
null
"head"

Let's say we want to delete node "three"
"two's" next handle should skip over "three"
So what we are really looking for is the node
whose next handle is "hooked up" to three

38
Removing a Node
"one"
"three"
"two"
null
"head"
temp

Let's say we want to delete node "three"
"two's" next handle should skip over "three"
Node temp head
while(temp.getNext() ! null
!temp.getNext().getWord().equals("three")
)
temp temp.getNext()
if(temp.getNext() ! null)
temp.setNext(temp.getNext().getNext())

39
Removing a Node
"one"
"three"
"two"
null
"head"
temp

Let's say we want to delete node "three"
"two's" next handle should skip over "three"
Node temp head
while(temp.getNext() ! null
!temp.getNext().getWord().equals("three")
)
temp temp.getNext()
if(temp.getNext() ! null)
temp.setNext(temp.getNext().getNext())

40
Removing a Node
"one"
"three"
"two"
null
"head"
temp

Let's say we want to delete node "three"
"two's" next handle should skip over "three"
Node temp head
while(temp.getNext() ! null
!temp.getNext().getWord().equals("three")
)
temp temp.getNext()
if(temp.getNext() ! null)
temp.setNext(temp.getNext().getNext())

41
Removing a Node
null
"head"

What if head is null?
Node temp head
while(temp.getNext() ! null
!temp.getNext().getWord().equals("three")
)
temp temp.getNext()
if(temp.getNext() ! null)
temp.setNext(temp.getNext().getNext())

42
Removing a Node
null
"head"

What if head is null? What happens if you put a
null handle in front of a dot?
Node temp head
while(temp.getNext() ! null
!temp.getNext().getWord().equals("three")
)
temp temp.getNext()
if(temp.getNext() ! null)
temp.setNext(temp.getNext().getNext())
An empty list is a special case

43
Deleting a node at the front

Deleting a node at the front is also a special
casewe need to change head
Luckily, it's pretty simple
head head.getNext()

Before
"one"
"three"
"two"
null
"head"
After
"one"
"three"
"two"
null
"head"
44
Writing a "remove" method

When you write a "remove" method, you search the
list for a node whose next handle is "hooked up"
to the value to remove
There are three possibilities (special cases)
The list is empty
The node to remove is the first node in the list
If neither case 1 or 2, you need to traverse the
list to see if the node is in the list

45
Writing a "remove" method

public void remove(String sTarget)
//check if list is empty
if(head null)
??
//remove first node?
else if(head.getWord().equals(sTarget))
??
else
//traverse the list

46
Practice Quiz Question What is the output?

public class LinkedListDemo
public static void main(String args)
LinkedList list new LinkedList()
list.addFront(new Node("cat",null))
list.addFront(new Node("dog",null))
list.addFront(new Node("mouse",null))
list.addFront(new Node("horse",null))
list.display()
list.mystery1()
list.display()
list.mystery2()
list.display()
class LinkedList
private Node head
public LinkedList()head null
public void addFront(Node newNode)

47
Real Life use of Linked Lists

A computer programmer at Northrop "One of the
biggest lists was when our aircraft entered an
area where there were threats or
targets-of-opportunity. As threats were
encountered, eliminated, and passed-by, they were
added, and removed from the list."

48
Real Life use of Linked Lists

FAT - the File Allocation Table in MS-DOS used a
linked-list concept to keep track of which disk
sectors are occupied by a file.
An OS can track memory usage in "blocks" or
"pages" that are either allocated to a task and
linked together in a linked list, or are
available and appear in a linked-list containing
free blocks.
An UNDO stack in a graphics program is likely to
use something akin to a linked-list to keep track
of a long chain of undo-able events.

49
Recursive List methods