COMP2230 Introduction to Algorithmics Lecture 4

A/Prof Ljiljana Brankovic

Lecture Overview
Data Structures, revision Text, Chapter 3, Sections 3.1-3.4 Next Lecture:

Data Structures, revision Text, Chapter 3, Sections 3.5-3.6 Searching, Text, Chapter 4

Data Structures - Revision

Most algorithms operate on data . Typically, an algorithm takes data as input, manipulates them, and produces data as output. Data structure is a structure (organisation, arrangement) of data, or, more specifically, related data items used by an algorithm. An abstract data type (ADT) comprises both data and functions that operate on data. We shall define some abstract data types by listing the functions that operate on them. Abstract means that an implementation is irrelevant and not specified.

Some Fundamental Data Structures

Linear data Structures: Arrays Linked Lists Stacks Queues Graphs general Trees general Binary Trees Heaps Sets (Disjoint Sets)

Arrays
An one-dimensional array is a sequence of n items each having an index between 0 and n-1 associated with it. All data items are of the same data type (e.g. integers). In an array, an element (data item) can be accessed directly by specifying its index; thus, arrays provide constant time access to elements. However, inserting or deleting an element in an array, takes (n).
a[0] a[1] a[2] ... a[n-1]

Linked Lists
Unlike an array, a linked list provides a constant time insertion and deletion anywhere in the list, but in the worst case it takes (n) time to access an element.

Linked Lists
A linked list can be implemented as a list of nodes, where each node has a field data and a field next , which references the next node in the list. A list also contains a variable start that references the first node in the list. The next field in the last node in null.

start

13

-4

87

Linked Lists
Inserting in a linked list :
start 13 -4 87

20

Algorithm 3.3.1 Inserting in a Linked List

This algorithm inserts the value val after the node referenced by pos . The operator, new, is used to obtain a new node. Input Parameters: val ,pos Output Parameters: None insert(val,pos) { temp = new node temp. data = val temp. next = pos.next pos.next = temp }

Algorithm 3.3.2 Deleting in a Linked List

This algorithm deletes the node after the node referenced by pos.

Input Parameters: pos Output Parameters: None delete(pos) { pos.next = pos.next.next }

Algorithm 3.3.3 Printing the Data in a Linked List

This algorithm prints the data in each node in a linked list. The first node is referenced by start. Input Parameters: start Output Parameters: None print (start) { while (start != null) { println(start .data) start = start .next } }

Stacks
A stack is an abstract data type (ADT) that has the following functions:
stack_init(): initialize stack (make it empty) empty(): return true if the stack is empty and return false if the stack is not empty push(val): add the item val to the stack pop(): remove the item most recently added to the stack top(): return the item most recently added to the stack but do not remove it

Implementing stacks using arrays

Note that stack is a Last In First Out structure (LIFO). Variable t is used to denote the top of the stack. When an item is pushed onto the stack, t is incremented and the item is put in the cell at index t. When an item is popped off the stack, t is decremented.

Example
Starting from empty stack:
s.push(16) s.push(5) s.push(32) s.pop()
t
16 5 33 16

16 5 33

Algorithm 3.2.2 Initializing a Stack

This algorithm initializes a stack to empty. An empty stack has t = -1. Input Parameters: None Output Parameters: None stack_init() { t = -1 }

Algorithm 3.2.3 Testing for an Empty Stack

This algorithm returns true if the stack is empty or false if the stack is not empty. An empty stack has t = -1. Input Parameters: None Output Parameters: None empty () { return t == -1 }

Algorithm 3.2.4 Adding an Element to a Stack

This algorithm adds the value val to a stack. The stack is represented using an array data . The algorithm assumes that the array is not full. The most recently added item is at index t unless the stack is empty, in which case, t = -1. Input Parameters: val Output Parameters: None push( val) { t = t + 1 data[ t] = val }

Algorithm 3.2.5 Removing an Element From a Stack

This algorithm removes the most recently added item from a stack. The algorithm assumes that the stack is not empty. The most recently added item is at index t. Input Parameters: None Output Parameters: None pop() { t = t 1 }

Algorithm 3.2.6 Returning the Top Element in a Stack

This algorithm returns, but does not remove, the most recently added item in a stack. The algorithm assumes that the stack is not empty. The stack is represented using an array data . The most recently added item is at index t. Input Parameters: None Output Parameters: None top() { return data[t ] }

Example 3.2.7 One

This algorithm returns true if there is exactly one element on the stack. The code uses the abstract data type stack. Input Parameter: s (the stack) Output Parameters: None one(s ) { if (s .empty()) return false val = s.top() s.pop () flag = s. empty() s.push(val) return flag }

Queues

A queue is very similar to a stack; the only difference is that when an item is deleted from a queue, then the least recently added item is deleted, not the most recently added as in a stack First In First Out - FIFO.

Queues
The functions on a queue are: queue_init(): initialize the queue (make it empty) empty(): return true if the queue is empty and return false if the queue is not empty enqueue(val): add the item val to the queue dequeue(): remove the item least recently added to the queue front(): return the item least recently added to the queue but do not remove it

Queues
Queue can also can be implemented using arrays.
Variables r and f are used to denote the rear and the front of a queue.

For an empty queue, r=f=-1. When an item is added to an empty queue, both r and f are set to 0 and the item is put in the cell at index 0. When an item is added to non empty queue, r is incremented and the item is put in the cell at index r. If r is the index of the last cell in the array, it is set to 0.

Queues
When an item is deleted from the front of a queue, f gets incremented. If f is the index of the last cell in the array, it is set to 0. When an item is deleted from a queue and queue becomes empty, both r and f are set to 1.

Queues
Starting from an empty queue:
7 55 13 2

rf
28

r
7 247 13

f
2

1. q.enqueue(28) 2. q.enqueue(55) 3. q.enqueue(13) 4. q.dequeue() 5. q.enqueue(2) 6. q.enqueue(7) 7. q.dequeue() 8. q.dequeue() 9. q.enqueue(247) 10. q.dequeue() 11. q.dequeue() 12. q.dequeue()

rf
28 55 13

f
2

247 13

f
28 55

r
13

f
7

r
247 13 2

r
28 55 13

f
7 55 13

f2 r
2

rf
7 247 13 2

rf

Algorithm 3.2.10 Initializing a Queue

This algorithm initializes a queue to empty. An empty queue has r = f = -1. Input Parameters: None Output Parameters: None queue _init() { r = f = - 1 }

Algorithm 3.2.11 Testing for an Empty Queue

This algorithm returns true if the queue is empty or false if the queue is not empty. An empty queue has r = f = -1. Input Parameters: None Output Parameters: None empty () { return r == - 1 }

Algorithm 3.2.12 Adding an Element to a Queue

This algorithm adds the value val to a queue. The queue is represented using an array data of size SIZE . The algorithm assumes that the queue is not full. The most recently added item is at index r (rear), and the least recently added item is at index f (front). If the queue is empty, r = f = -1. Input Parameters: val Output Parameters: None enqueue(val) { if (empty ()) r = f = 0 else { r = r + 1 if (r == SIZE ) r = 0 } data[ r] = val }

Algorithm 3.2.13 Removing an Element From a Queue

This algorithm removes the least recently added item from a queue. The queue is represented using an array of size SIZE . The algorithm assumes that the queue is not empty. The most recently added item is at index r (rear), and the least recently added item is at index f (front). If the queue is empty, r = f = -1. Input Parameters: None Output Parameters: None dequeue() { // does queue contain one item? if (r == f) r = f = -1 else { f = f + 1 if (f == SIZE ) f = 0 } }

Algorithm 3.2.14 Returning the Front Element in a Queue

This algorithm returns, but does not remove, the least recently added item in a queue. The algorithm assumes that the queue is not empty. The queue is represented using an array data . The least recently added item is at index f (front). Input Parameters: None Output Parameters: None front () { return data[f ] }

Using a linked list to implement a stack

Algorithm 3.3.4 Initializing a Stack
This algorithm initializes a stack to empty. The stack is implemented as a linked list. The start of the linked list, referenced by t, is the top of the stack. An empty stack has t = null.

Input Parameters: None Output Parameters: None stack_init() { t = null }

Algorithm 3.3.5 Testing for an Empty Stack

This algorithm returns true if the stack is empty or false if the stack is not empty. An empty stack has t = null. Input Parameters: None Output Parameters: None empty () { return t == null }

Algorithm 3.3.6 Adding an Element to a Stack

This algorithm adds the value val to a stack. The stack is implemented using a linked list. The start of the linked list, referenced by t, is the top of the stack. Input Parameters: val Output Parameters: None push( val) { temp = new node temp. data = val temp. next = t t = temp }

Algorithm 3.3.7 Removing an Element From a Stack

This algorithm removes the most recently added item from a stack. The stack is implemented using a linked list. The start of the linked list, referenced by t, is the top of the stack. The algorithm assumes that the stack is not empty. Input Parameters: None Output Parameters: None pop() { t = t .next }

Algorithm 3.3.8 Returning the Top Element in a Stack

This algorithm returns, but does not remove, the most recently added item in a stack. The stack is implemented using a linked list. The start of the linked list, referenced by t, is the top of the stack. The algorithm assumes that the stack is not empty. Input Parameters: None Output Parameters: None top() { return t. data }

Adjacency Lists for Graphs

Linked lists can be used to represent graphs.
1 2 1 2 3 4 5
1 2 3 3 4 1 1 4 5 5 2 5

3 4

Algorithm 3.3.10 Computing Vertex Degrees Using Adjacency Lists

This algorithm computes the degree of each vertex in a graph. The graph is represented using adjacency lists; adj [i] is a reference to the first node in a linked list of nodes representing the vertices adjacent to vertex i. The next field in each node, except the last, references the next node in the list. The next field of the last node is null. The vertices are 1, 2, . . . . Input Parameter: adj Output Parameters: None degrees1( adj) { for i = 1 to adj. last { count = 0 ref = adj [i] while (ref != null) { count = count + 1 ref = ref .next } println(vertex + i + has degree + count) } }

Algorithm 3.3.10 Computing Vertex Degrees Using Adjacency Lists

The Algorithm runs in time (n+m), where n is the number of vertices and m number of edges in the graph.

Algorithm 3.3.11 Computing Vertex Degrees Using an Adjacency Matrix

This algorithm computes the degree of each vertex in a graph. The graph is represented using an adjacency matrix am, where am[i][j] is 1 if there is an edge between i and j, and 0 if not. The vertices are 1, 2, . . . . Input Parameter: am Output Parameters: None degrees2( am) { for i = 1 to am.last { count = 0 for j = 1 to am.last if (am[i][j] == 1) count = count + 1 println(vertex + i + has degree + count) } }

Algorithm 3.3.11 Computing Vertex Degrees Using an Adjacency Matrix

The Algorithm runs in time (n2), where n is the number of vertices in the graph.

Binary Trees
A binary tree is a rooted tree where each node has either:
No children One child Two children.

A child can be either a left child or a right child. To traverse a binary tree means to visit each node in the tree in some prescribed order.

Binary Trees
Example:
1

4 6

Binary Trees
Preorder traversal of a binary rooted tree: If root is empty stop. Visit root Execute preorder on the binary tree rooted at the left child of the root Execute preorder on the binary tree rooted at the right child of the root 1
2 3

4 6

Algorithm 3.4.3 Preorder

This algorithm performs a preorder traversal of the binary tree with root root. Input Parameter: root Output Parameters: None preorder( root ) { if (root != null) { // visit root preorder( root .left) preorder( root .right) } }

This algorithm returns the number of nodes in the binary tree with root root. Input Parameter: root Output Parameters: None count_nodes(root) if (root == null ) return 0 count = 1 // count root count = count + count_nodes(root. left ) // add in nodes in left subtree count = count + count_nodes(root. right) // add in nodes in right subtree return count }

Algorithm 3.4.5 Counting Nodes in a Binary Tree

Inorder traversal of a binary rooted tree: If root is empty stop. Execute inorder on the binary tree rooted at the left child of the root Visit root Execute inorder on the binary tree rooted at the right child of the root Postorder traversal of a binary rooted tree: If root is empty stop. Execute postorder on the binary tree rooted at the left child of the root Execute postorder on the binary tree rooted at the right child of the root Visit root

Algorithm 3.4.9 Inorder

This algorithm performs an inorder traversal of the binary tree with root root. Input Parameter: root Output Parameters: None inorder(root) { if (root != null) { inorder(root. left ) // visit root inorder(root. right) } }

Algorithm 3.4.10 Postorder

This algorithm performs a postorder traversal of the binary tree with root root. Input Parameter: root Output Parameters: None postorder (root) { if (root != null) { postorder (root.left) postorder (root.right) // visit root } }

Algorithm 3.4.14 Inserting Into a Binary Search Tree

This algorithm inserts the value val into a binary search tree with root root. If the tree is empty, root = null. The algorithm returns the root of the tree containing the added item. We assume that new node creates a new node with data field data and reference fields left and right. Input Parameter: root ,val Output Parameters: None BSTinsert (root,val) { // set up node to be added to tree temp = new node temp. data = val temp. left = temp. right = null if (root == null) // special case: empty tree return temp BSTinsert_recurs( root ,temp) return root } ...

... BSTinsert_recurs( root ,temp) { if (temp. data root.data) if (root. left == null ) root. left == temp else BSTinsert_recurs( root .left,temp) else if (root. right == null) root. right == temp else BSTinsert_recurs( root .right,temp) }

Algorithm 3.4.15 Deleting from a Binary Search Tree, Special Case

This algorithm deletes the node referenced by ref from a binary search tree with root root. The node referenced by ref has zero children or exactly one child. We assume that each node N in the tree has a parent field, N.parent. If N is the root, N.parent is null. The algorithm returns the root of the tree that results from deleting the node.

Input Parameter: root ,ref Output Parameters: None BSTreplace(root,ref) { // set child to refs child, or null, if no child if (ref.left == null) child = ref.right else child = ref.left if (ref == root) { if (child != null) child .parent = null return child } if (ref.parent.left == ref) // is ref left child? ref.parent.left = child else ref.parent.right = child if (child != null) child .parent = ref.parent return root }

Algorithm 3.4.16 Deleting from a Binary Search Tree

This algorithm deletes the node referenced by ref from a binary search tree with root root. We assume that each node N in the tree has a parent field, N.parent. If N is the root, N.parent is null. The algorithm returns the root of the tree that results from deleting the node. Input Parameter: root ,val Output Parameters: None BSTdelete (root,ref) { // if zero or one children, use Algorithm 3.4.15 if (ref.left == null || ref.right == null) return BSTreplace (root,ref) // find node succ containing a minimum data item in refs succ = ref.right // right subtree while (succ.left != null) succ = succ.left // move succ to ref , thus deleting ref ref.data = succ.data // delete succ return BSTreplace (root,succ) }