Transcript Linked Structures, Singly and Doubly Linked Lists

Linked Structures, LinkedSet
•
•
•
•
•
•
References as Links
Linear Linked Lists and Non-linear Structures
Managing Linked Lists
Data Encapsulation Separate from Linking
Doubly Linked Lists
Reading: L&C : 4.1-4.3
1
References as Links
• A linked structure is a data structure that
uses object reference variables to create
links between objects
• Declaring an object reference variable
Object obj = new Object();
• A diagram of an object reference variable
Object reference variable
An object of Object class
obj
2
References as Links
• A self-referential Person class that contains
a pointer to another Person class object
public class Person
{
// attributes of a “person”
private String name;
private String address;
// link (or pointer) to another Person object
private Person next;
// next Person in list
3
References as Links
• A self-referential Person class that contains
a pointer to another Person class object
// constructor, accessor, and mutator methods
public Person(. . .) // parameters are attributes
{
// set the attributes
next = null;
}
public Person(Person next, . . .) {
this.next = next;
}
public void setNext(Person next) {
this.next = next;
}
public Person getNext() {
return next;
4
Linked Lists
• A null terminated linked list of Person
objects can be used to represent people
waiting in line starting at the “front”
• Beginning of a linked list of Person objects
private Person front;
• A diagram of a linked list
front
Person next;
Person next;
Person next;
5
null
Linked Lists
• Unlike an array which has a fixed size, a
linked list is considered to be a dynamic
structure
• The amount of memory used grows and
shrinks as objects are added to the list or
deleted from the list
• The Java compiler and virtual machine
allocate memory for each individual object
as it is created (via the new operator) and
free memory as each object is garbage
6
collected
Linear/Non-Linear Linked Structures
• A linked list is considered to be a linear
structure since it can be visualized as a line
• Some linked structures are non-linear, e.g.
entry
7
Managing Singly Linked Lists
• The order in which references are changed
is crucial to maintaining a linked list
• Can insert a new Person in three places:
– at the front
– In the middle
– at the end
• Can delete an existing Person in three
places:
– At the front
– In the middle
8
Inserting Objects in a Linked List
• Create new Person object and link at front
Person newPerson = new Person(. . .);
newPerson.setNext(front);
front = newPerson;
newPerson = null;
1
Person next;
newPerson
2
4
Person next;
front
3
Person next;
9
Inserting Objects in a Linked List
• Create new Person object and link after the
current Person object (current could be at end)
Person newPerson = new Person(. . .);
newPerson.setNext(current.getNext());
current.setNext(newPerson);
newPerson = null;
1
newPerson
current
front
Person next;
Person next;
2
4
Person next;
Person next;
3
10
Inserting Objects in a Linked
List
• How about inserting an element at the
end? Let's do it together.
11
Removing Objects from a Linked List
• Remove Person object at front
Person removed = front;
front = front.getNext());
removed.setNext(null);
removed
1
3
Person next;
front
Person next;
Person next;
2
12
Removing Objects from a Linked List
• Remove Person object after current Person
object (removed object could be at end)
Person removed = current.getNext();
current.setNext(removed.getNext());
removed.setNext(null);
current
removed
1
front
Person next;
Person next;
2
Person next;
3
13
Removing Objects from a Linked
List
• How about removing an object from the
end?
14
Elements without Links
• It is desirable to have a generic link class
that can be used to link any type of objects
of any class encapsulating the “real” data
• Class LinearNode<T> does that this way
front
LinearNode next;
T element;
LinearNode next;
T element;
LinearNode next;
T element;
Object of type T
Object of type T
Object of type T
15
null
Elements without Links
• Code for Linear Node<T>
public class LinearNode<T>
{
private LinearNode<T> next;
private T element;
public LinearNode()
{
next = null;
element = null;
}
// create an empty node
16
Elements without Links
• Code for LinearNode<T>
public LinearNode(T element)
{
next = null;
this.element = element;
}
public LinearNode<T> getNext()
{
return next;
}
public void setNext(LinearNode<T> next)
{
this.next = next;
}
17
Elements without Links
• Code for LinearNode<T>
public T getElement()
{
return element;
}
public void setElement(T element)
{
this.element = element;
}
}// end class LinearNode<T>
18
Elements without Links
• Using the LinearNode class to create a linked
list of three Person objects
int size = 3;
LinearNode<Person> front =
new LinearNode<Person>();
LinearNode<Person> current = front;
for(int i = 1; i < 3; i++) {
LinearNode<Person> newNode = new
LinearNode<Person>();
current.setNext(newNode);
current = newNode;
}
19
Doubly Linked Lists
• Each DoubleNode object has a reference to
next DoubleNode and previous DoubleNode
public class DoubleNode<T>
{
private DoubleNode<T> next;
private DoubleNode<T> prev;
private T element;
front
null
DoubleNode<T> next
DoubleNode<T> prev
T element
DoubleNode<T> next
DoubleNode<T> prev
T element
Object of type T
Object of type T
20
null
back
Doubly Linked Lists
• To Add a DoubleNode object to the list, your
code must set both the DoubleNode next
and prev variables.
• To delete a DoubleNode object from the list,
your code must bypass the DoubleNode
links in both directions.
21