23/1

Linked List -
Inserting in order

Reading: Savitch, Chapter 10
23/2
Objectives
To learn how to insert elements in order in a
linked list
To learn what a doubly-linked list is
23/3
Ordered lists
Nodes ordered by the key
Example: list of student nodes
possible keys = name, mark
Use key values to insert new nodes into
correct positions
23/4
Insertion in an ordered list
Ahmed
67
Kim
84
Pablo
56
head
null
new_name new_mark Louise
75
23/5
Ahmed
67
Kim
84
Pablo
56
head
null
new_name
new_mark
Louise
75
new_node
Insertion in an ordered list (ctd)
23/6
Ahmed
67
Kim
84
Pablo
56
head
null
new_name
new_mark
Louise 75
new_node
Louise
75
null
Insertion in an ordered list (ctd)
23/7
Ahmed
67
Kim
84
Pablo
56
head
null
new_name
new_mark
Louise 75
new_node
Louise
75
??
p
Insertion in an ordered list (ctd)
23/8
Ahmed
67
Kim
84
Pablo
56
head
null
new_name
new_mark
Louise
75
new_node
Louise
75
??
p
Insertion in an ordered list (ctd)
23/9
Ahmed
67
Kim
84
Pablo
56
head
null
new_name
new_mark
Louise 75
new_node
Louise
75
??
p
Insertion in an ordered list (ctd)
23/10
Ahmed
67
Kim
84
Pablo
56
head
null
new_name
new_mark Louise
75
new_node
Louise
75
??
p
Insertion in an ordered list (ctd)
23/11
Ahmed
67
Kim
84
Pablo
56
head
null
new_name new_mark Louise
75
new_node
Louise
75
p
Insertion in an ordered list (ctd)
23/12
Ahmed
67
Kim
84
Pablo
56
head
null
new_name new_mark Louise 75
new_node
Louise
75
p
?
Insertion in an ordered list (ctd)
23/13
Insertion in an ordered list (ctd)
Problem
when inserting into an ordered list, the position
to insert is only determined by the item after
this position in the list!
Solutions
look one ahead in the list
keep a trailing pointer
use a doubly-linked list
23/14
Looking one ahead in the list
Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75
null
Test:
while (((p.next).name).compareTo(new_node.name)) <0)
p = p.next;

Insertion:
new_node.next = p.next; p.next = new_node;
p
23/15
Looking one ahead in the list
Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75

Test:
while (((p.next).name).compareTo(new_node.name)) <0)
p = p.next;

Insertion:
new_node.next = p.next; p.next = new_node;
p
23/16
Looking one ahead in the list
Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75

Test:
while (((p.next).name).compareTo(new_node.name)) <0)
p = p.next;

Insertion:
new_node.next = p.next; p.next = new_node;
p
23/17
Using a trailing pointer
new_node
Louise
75

null
Test:
while ((p.name).compareTo(new_node.name) < 0)
{ previous = p; p = p.next; }

Insertion:
new_node.next = p; previous.next = new_node;

Ahmed
67
Kim
84
Pablo
56
head
null
p previous
23/18
Problem ?
What assumption was made in the previous
four slides in the while loop?

How could this be a problem?

How would you make it safe?
23/19
Doubly-linked list
Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75
p
null

null
null
23/20
Doubly-linked list

Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75
p
??
??
null
p.prev.next = new_node; new_node.next = p;
new_node.prev = p.prev; p.prev = new_node;
23/21
Doubly-linked list

Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75
p
null
null
null
p.prev.next = new_node; new_node.next = p;
new_node.prev = p.prev; p.prev = new_node;
23/22
Doubly-linked list

Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75
p
null
null
p.prev.next = new_node; new_node.next = p;
new_node.prev = p.prev; p.prev = new_node;
23/23
Doubly-linked list

Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75
p
null
p.prev.next = new_node; new_node.next = p;
new_node.prev = p.prev; p.prev = new_node;
23/24
Doubly-linked list

Ahmed
67
Kim
84
Pablo
56
head
null
new_node
Louise
75
p
null
p.prev.next = new_node; new_node.next = p;
new_node.prev = p.prev; p.prev = new_node;
23/25
Doubly-linked list
Ahmed
67
Kim
84
Louise
75
head
new_node
Pablo
56
p
null
p.prev.next = new_node; new_node.next = p;
new_node.prev = p.prev; p.prev = new_node;
null
23/26
Doubly linked lists
class NewStudentNode {
private String name;
private int mark;
private NewStudentNode next, prev;
public NewStudentNode(String _n, int _m) {
name = _n; mark = _m;
next = null; prev = null;
}
... ...
}

JAVA declaration
23/27
Doubly linked lists

public class DoublyLinkedList {
private NewStudentNode head, tail;
public void insertInOrder(String new_name, int new_mark) {...}
public void remove(int _mark); {...}
public void traversal() {...}
... ...
}
23/28
Doubly-linked lists
Access in forwards and backwards
directions
Uses more space
Requires more code when inserting and
deleting nodes
23/29
Insertion in order: special cases
(Singly linked lists)
insert in an empty list
insert at the front of the list
insert at the end of the list
23/30
void insertInOrder(Node item)
{
if (head == null)
head = item;
else if (head.data > item.data) {
item.next = head;
head = item;
}
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
}
Insert
spec
cases
(ctd)
23/31
head item
56
null
if (head == null) // empty list
head = item;


null
Insert
special
cases
(ctd)
23/32
head item
56
null
if (head == null) // empty list
head = item;

null
Insert
special
cases
(ctd)
23/33
head item
56
null
if (head == null) // empty list
head = item;
Insert
special
cases
(ctd)
23/34
56
head item
34
null
else if (head.data > item.data) { // insert at front of list
item.next = head;
head = item;
}
null
Insert
special
cases
(ctd)
23/35
56
head item
34
null
else if (head.data > item.data) { // insert at front of list
item.next = head;
head = item;
}
null
Insert
special
cases
(ctd)
23/36
56
head item
34
null
else if (head.data > item.data) { // insert at front of list
item.next = head;
head = item;
}
Insert
special
cases
(ctd)
23/37
56
head item
34
null
else if (head.data > item.data) { // insert at front of list
item.next = head;
head = item;
}
Insert
special
cases
(ctd)
23/38
34 56 84
head
null
item
67
null
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/39
34 56 84
head
null
item
67
null
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/40
34 56 84
head
null
item
67
p
null
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/41
34 56 84
head
null
item
67
p
null
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/42
34 56 84
head
null
item
67
p
null
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/43
34 56 84
head
null
item
67
p
null
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/44
34 56 84
head
null
item
67
p
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/45
34 56 84
head
null
item
67
p
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/46
34 56 84
head
null
67
else {
Node p = head;
while ((p.next != null) && ((p.next).data < item.data))
p = p.next;

item.next = p.next;
p.next = item;
}
Insert
special
cases
(ctd)
23/47
Class exercise: ordered insertion
Problem
work through the method insertInOrder for a
list with items 34, 56 and 84, if the new item is
101
does the algorithm work?