Arete Zafiriou - Student.cs.uwaterloo.ca

CS 234 – Lecture #8 May 30,2013
Linked structures
Python List (review)
1. Adjustable size (it may require allocation of a new array)
L = [None]*100000
2. Constant time access
L[i] - O(1)
3. Insertions and Deletions may take linear time, O(n)
Example:
L.pop(i)
0 1 2 3 i
Linked structures
1. Adjustable size (memory allocated when needed)
- memory space allocated for linked structures may not be
contiguous
2. Random access is not linear in the worst case O(n)
3. Insertions and Deletions may become constant time O(1)
Linked Structures
1. They are used to store a collection of items
2. Linked structures may be appropriate in certain cases
3. Linked structures are created using Nodes.
Data type
link
4. Each node contains some data and one or more links to other
nodes.
Linked Structure (singly linked list)
- A linked list is one in which nodes are linked together in a linear
order
9
17 52 4
head
tail

head – reference to the first node in the list
tail – last node in the list
link in the tail is a None reference
Most nodes have no names or references.
They are referenced by the link in the preceding node.
Head – should be referenced by an external variable
- entry point to the list
- null head reference indicates an empty list
The Basic operations
1. List traversal
2. Search for an item
3. Insert an item
4. Delete an item
…
Traversing a List
curNode
9 17 52 4
We can traverse this list by creating a temporary reference
curNode = head
9 14 17 52
create a linked list
LL = Node(9, Node(14,Node(17,Node(52,None))))
N = Node(23)
23
Traverse the list by advancing the temporary reference
curNode = curNode._next
Repeat again

Until Curnode == None, you have reached the end of the list
23
9 14 17
Searching for an item in SLL
Traverse the list
Produce true if the item is in the list
Produce false otherwise
Inserting items in a SLL
Insert(27)
Node
17
head
Beginning of the list
head
New node
27
17
newNode._next = head
head = newNode
1. newNode._next=head
head = newNode
2. head=newNode
newNode._next = head
Inserting in the middle of the list
9
17 14 52
1
2
curNode 27
newNode

1) NewNode._next = curNode._next
curNode._next = newNode
Insert at the end of the list as an exercise.
Removing an item from SLL
Search for the item that we want to remove
remove(17) predNode._next = curNode.next
curNode._next = None
9 14 17 52
head predNode curNode
deleting the head of the SLL
9 14 17 52
preNode
head
curNode
head = head._next
curNode._next = None
We need to update the head in this case
ADT sequence
Data: linear collection of items
Operations:
Sequence()
__repr__
__getItem__
len
append
insert
extend
pop
remove
reverse
Implement this ADT using SLL

Python List
__getItem__(self,index)
L[i]
Variations of Linked Lists
Circularly linked lists
SLL
entry
9 14
17
52
Doubly Linked lists
9 14 17 52
Forward and Backward traversals
Issues:
- Efficiency of Operations
- Memory requirements
Linked Structures do not have to be linear
15
71
55
21
57
17
91
52