Lecture2 - Data Structures

8/14/2019 Lecture2 - Data Structures

1/89

COMP2230 Introduction toAlgorithmics

Lecture 2

A/Prof Ljiljana Brankovic


2/89

Lecture Overview

Data Structures - Text, Section 2.4


3/89

Data Structures - Revision Most algorithms operate on data.

Typically, an algorithm takes data as input, manipulates them,and produces data as output.

Data structureis a structure (organisation, arrangement) ofdata, or, more specifically, related data items used by an

algorithm.

An abstract data type (ADT)comprises both dataand functionsthat operate on data. We shall define some abstract data typesby listing the functions that operate on them.

Abstractmeans that an implementation is irrelevant and notspecified.


4/89

Some Fundamental Data Structures Linear data Structures:

Arrays

Linked Lists Stacks Queues

Graphs general

Trees general

Binary Trees

Heaps

Sets (Disjoint Sets)


5/89

Arrays An one-dimensional array is a sequence of n items

each having an index between 0 and n-1 associatedwith it.

All data items are of the same data type (e.g.integers).

In an array, an element (data item) can be accesseddirectly by specifying its index; thus, arrays provideconstant time access to elements.

However, inserting or deleting an element in an arrayrequires moving every other element

a[0] a[1] . . . a[n-1]a[2]


6/89

Linked Lists

Unlike an array, a linked list provides a constanttime insertion and deletion anywhere in thelist, but in the worst case it must traverse

every other element to access a particularelement.


7/89

Linked Lists

A linked list can be implemented as a list of nodes,where each node has a field dataand a field next,which references the next node in the list.

A list also contains a variable start that referencesthe first node in the list.

The nextfield in the last node in null.

13 -4 87start


8/89

Linked Lists

Inserting in a linked list :

13 -4 87start

20


9/89

Algorithm 3.3.1 Inserting in a LinkedList

This algorithm inserts the value valafter the node referenced by pos. Theoperator, new, is used to obtain a new node.

Input Parameters: val,posOutput Parameters: Noneinsert(val,pos) {

temp= new nodetemp.data= valtemp.next= pos.nextpos.next= temp

}


10/89

Algorithm 3.3.2 Deleting in a LinkedList

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

Input Parameters: posOutput Parameters: Nonedelete(pos) {

pos.next= pos.next.next}


11/89

Algorithm 3.3.3 Printing the Data in aLinked List

This algorithm prints the data in each node in a linked list. The first node isreferenced by start.

Input Parameters: startOutput Parameters: Noneprint(start) {

while (start!= null) {println(start.data)start= start.next

}}


12/89

StacksA 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 valto the stack

pop():remove the item most recently added to the stack

top():return the item most recently added to the stack but donot remove it


13/89

Implementing stacks using arrays

Note that stack is a Last In First Out structure(LIFO).

Variable tis used to denote the top of the stack.

When an item is pushed onto the stack, tisincremented and the item is put in the cell at index t.

When an item is popped off the stack, t isdecremented.


14/89

Example

Starting from empty stack:s.push(16)

s.push(5)

s.push(32)s.pop()

t

16

t

16 5 33

t

16 5 33

t


15/89

Algorithm 3.2.2 Initializing a Stack

This algorithm initializes a stack to empty. An empty stack has t= -1.

Input Parameters: NoneOutput Parameters: Nonestack_init() {

t= -1

}


16/89

Algorithm 3.2.3 Testing for an EmptyStack

This algorithm returns true if the stack is empty or false if the stack is notempty. An empty stack has t= -1.

Input Parameters: NoneOutput Parameters: Noneempty() {

return t== -1}


17/89

Algorithm 3.2.4 Adding an Element to aStack

This algorithm adds the value valto a stack. The stack is represented usingan array data. The algorithm assumes that the array is not full. The mostrecently added item is at index tunless the stack is empty, in which case,t= -1.

Input Parameters: val

Output Parameters: Nonepush(val) {t= t+ 1data[t] = val

}


18/89

Algorithm 3.2.5 Removing an ElementFrom a Stack

This algorithm removes the most recently added item from a stack. Thealgorithm assumes that the stack is not empty. The most recently addeditem is at index t.

Input Parameters: NoneOutput Parameters: None

pop() {t= t1}


19/89

Algorithm 3.2.6 Returning the TopElement in a Stack

This algorithm returns, but does not remove, the most recently added itemin a stack. The algorithm assumes that the stack is not empty. The stack isrepresented using an array data. The most recently added item is at index t.


top() {return data[t]}


20/89

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: Noneone(s) {

if (s.empty())return falseval= s.top()s.pop()flag= s.empty()s.push(val)

return flag}


21/89

Queues

A queue is very similar to a stack; the only

difference is that when an item is deletedfrom a queue, then the least recently addeditem is deleted, not the most recently addedas in a stack First In First Out - FIFO.


22/89

QueuesThe functions on a queue are:

queue_init():initialize the queue (make it empty)

empty():return true if the queue is empty and return false ifthe queue is not empty

enqueue(val):add the item valto the queue

dequeue():remove the item least recently added to the queue

front():return the item least recently added to the queue butdo not remove it


23/89

Queues

Queue can also can be implemented using arrays.

Variables r and f are used to denote the rear and the frontof a queue.

For an empty queue, r=f=-1.

When an item is added to an empty queue, both r and f areset to 0 and the item is put in the cell at index 0.

When an item is added to non empty queue, r is incrementedand the item is put in the cell at index r. If r is the index ofthe last cell in the array, it is set to 0.


24/89

Queues

When an item is deleted from the front of aqueue, f gets incremented. If f is the index of thelast cell in the array, it is set to 0.

When an item is deleted from a queue and queuebecomes empty, both r and f are set to 1.


25/89

Queues

Starting from anempty queue: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

rf

28

f

28 55 13

r

f

28 55 13

r

28 55 13

r

2

f

7 55 13

r

2

f

7 55 13

r

2

f

7 247 13

r

2

f

7 247 13

r

2

f

7 247 13

rf

2

7 247 13

rf

2


26/89

Algorithm 3.2.10 Initializing a Queue

This algorithm initializes a queue to empty. An empty queue has r= f= -1.

Input Parameters: NoneOutput Parameters: Nonequeue_init() {

r= f= - 1

}


27/89

Algorithm 3.2.11 Testing for an EmptyQueue

This algorithm returns true if the queue is empty or false if the queue is notempty. An empty queue has r= f= -1.

Input Parameters: NoneOutput Parameters: Noneempty() {

return r== - 1}


28/89

Algorithm 3.2.12 Adding an Element toa Queue

This algorithm adds the value valto a queue. The queue is representedusing an array dataof size SIZE. The algorithm assumes that the queue isnot full. The most recently added item is at index r(rear), and the leastrecently added item is at index f(front). If the queue is empty, r= f= -1.

Input Parameters: val

Output Parameters: Noneenqueue(val) {if (empty())

r= f= 0else {

r= r+ 1

if (r== SIZE)r= 0}data[r] = val

}


29/89

Algorithm 3.2.13 Removing an ElementFrom a Queue

This algorithm removes the least recently added item from a queue. Thequeue is represented using an array of size SIZE. The algorithm assumesthat 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 isempty, r= f= -1.

Input Parameters: NoneOutput Parameters: Nonedequeue() {

// does queue contain one item?if (r== f)

r= f= -1

else {f= f+ 1if (f== SIZE)

f= 0}

}


30/89

Algorithm 3.2.14 Returning the FrontElement in a QueueThis algorithm returns, but does not remove, the least recently added itemin a queue. The algorithm assumes that the queue is not empty. The queueis represented using an array data. The least recently added item is at indexf(front).

Input Parameters: None

Output Parameters: Nonefront() {

return data[f]}

U i li k d li i l


31/89

Using a linked list to implement astack

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 thestack. An empty stack has t= null.


Output Parameters: Nonestack_init() {

t= null}


32/89

Algorithm 3.3.5 Testing for an EmptyStackThis algorithm returns true if the stack is empty or false if the stack is notempty. An empty stack has t= null.


empty() {return t== null}


33/89

Algorithm 3.3.6 Adding an Element to aStack

This algorithm adds the value valto a stack. The stack is implementedusing a linked list. The start of the linked list, referenced by t, is the top ofthe stack.

Input Parameters: valOutput Parameters: None

push(val) {temp= new nodetemp.data= valtemp.next= tt= temp

}


34/89

Algorithm 3.3.7 Removing an ElementFrom a Stack

This algorithm removes the most recently added item from a stack. Thestack 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 thestack is not empty.


Output Parameters: Nonepop() {t= t.next

}


35/89

Algorithm 3.3.8 Returning the TopElement in a Stack

This algorithm returns, but does not remove, the most recently added itemin a stack. The stack is implemented using a linked list. The start of thelinked list, referenced by t, is the top of the stack. The algorithm assumesthat the stack is not empty.


Output Parameters: Nonetop() {return t.data

}


36/89

Adjacency Lists for Graphs

Linked lists can be used to represent graphs.

1 2

5 4

3

1

2

3

4

5

3 4 5

4 5

1 5

1 2

1 2 3


37/89

Algorithm 3.3.10 Computing VertexDegrees Using Adjacency Lists

This algorithm computes the degree of each vertex in a graph. The graph isrepresented using adjacency lists; adj[i] is a reference to the first node in alinked list of nodes representing the vertices adjacent to vertex i. The nextfield in each node, except the last, references the next node in the list. Thenextfield of the last node is null. The vertices are 1, 2, . . . .

Input Parameter: adjOutput Parameters: Nonedegrees1(adj) {

for i= 1 to adj.last{count= 0ref= adj[i]while (ref!= null) {

count= count+ 1ref= ref.next

}println(vertex + i+ has degree + count)

}

}


38/89

Algorithm 3.3.10 Computing VertexDegrees Using Adjacency Lists

The Algorithm must look at all n and m, where n is thenumber of vertices and m number of edges in the graph.


39/89

Algorithm 3.3.11 Computing VertexDegrees Using an Adjacency Matrix

This algorithm computes the degree of each vertex in a graph. The graph isrepresented using an adjacency matrix am, where am[i][j] is 1 if there is anedge between iandj, and 0 if not. The vertices are 1, 2, . . . .

Input Parameter: amOutput Parameters: None

degrees2(am) {for i= 1 to am.last{

count= 0for j= 1 to am.last

if (am[i][j] == 1)count= count+ 1

println(vertex + i+ has degree + count)}

}


40/89

Algorithm 3.3.11 Computing VertexDegrees Using an Adjacency Matrix

The Algorithm must look at every vertex per vertex, so

n2

operations where n is the number of vertices in thegraph.


41/89

Binary Trees

A binary tree is a rooted tree where each node haseither: 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 inthe tree in some prescribed order.


42/89

Binary Trees

Example:

1

2

4

3

5

6 7


43/89

Binary Trees

Preorder traversalof 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

4

3

5

67


44/89

Algorithm 3.4.3 Preorder

This algorithm performs a preorder traversal of the binary tree with root

root.

Input Parameter: rootOutput Parameters: Nonepreorder(root) {

if (root!= null) {// visit rootpreorder(root.left)preorder(root.right)

}}


45/89

Algorithm 3.4.5 Counting Nodes in aBinary Tree

This algorithm returns the number of nodes in the binary tree with root

root.

Input Parameter: rootOutput Parameters: Nonecount_nodes(root)

if (root== null )return 0count= 1 // count rootcount= count+ count_nodes(root.left)

// add in nodes in left subtreecount= count+ count_nodes(root.right)

// add in nodes in right subtreereturn count

}


46/89

Inorder traversalof a binary rooted tree:


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 traversalof a binary rooted tree:


Execute postorder on the binary tree rooted at the left child of theroot

Execute postorder on the binary tree rooted at the right child of theroot

Visit root


47/89

Algorithm 3.4.9 Inorder

This algorithm performs an inorder traversal of the binary tree with root

root.

Input Parameter: rootOutput Parameters: Noneinorder(root) {

if (root!= null) {inorder(root.left)// visit rootinorder(root.right)

}}


48/89

Algorithm 3.4.10 Postorder

This algorithm performs a postorder traversal of the binary tree with root

root.

Input Parameter: rootOutput Parameters: Nonepostorder(root) {

if (root!= null) {postorder(root.left)postorder(root.right)// visit root

}}


49/89

Algorithm 3.4.14 Inserting Into a BinarySearch TreeThis algorithm inserts the value valinto a binary search tree with root root.

If the tree is empty, root= null. The algorithm returns the root of the treecontaining the added item. We assume that new nodecreates a new nodewith data field dataand reference fields leftand right.

Input Parameter: root,valOutput Parameters: None

BSTinsert(root,val) {// set up node to be added to treetemp= new nodetemp.data= valtemp.left= temp.right= nullif (root== null) // special case: empty tree

return tempBSTinsert_recurs(root,temp)return root

}


50/89

BSTinsert_recurs(root,temp) {if (temp.data root.data)

if (root.left== null )root.left== temp

elseBSTinsert_recurs(root.left,temp)

elseif (root.right== null)

root.right== tempelse

BSTinsert_recurs(root.right,temp)}


51/89

Algorithm 3.4.15 Deleting from a BinarySearch Tree, Special CaseThis algorithm deletes the node referenced by reffrom a binary search treewith root root. The node referenced by ref has zero children or exactly onechild. We assume that each node Nin the tree has a parent field, N.parent.If Nis the root, N.parentis null. The algorithm returns the root of the treethat results from deleting the node.


52/89

Input Parameter: root,refOutput Parameters: NoneBSTreplace(root,ref) {

// set child to refs child, or null, if no childif (ref.left== null)

child= ref.rightelse

child= ref.leftif (ref== root) {

if (child!= null)child.parent= null

return child}if (ref.parent.left== ref) // is refleft child?

ref.parent.left= child

elseref.parent.right= child

if (child!= null)child.parent= ref.parent

return root}

l h 4 l f B


53/89

Algorithm 3.4.16 Deleting from a BinarySearch Tree

Input Parameter: root,valOutput Parameters: None

BSTdelete(root,ref) {// if zero or one children, use Algorithm 3.4.15if (ref.left== null || ref.right== null)

return BSTreplace(root,ref)// find node succcontaining a minimum data item in refssucc= ref.right // right subtree

while (succ.left!= null)succ= succ.left

// move succto ref, thus deleting refref.data= succ.data// delete succreturn BSTreplace(root,succ)

}

This algorithm deletes the node referenced by reffrom a binary search treewith root root. We assume that each node Nin the tree has a parent field,N.parent. If Nis the root, N.parentis null. The algorithm returns the root ofthe tree that results from deleting the node.


54/89

Priority Queues

A priority queue is an abstract data type that allows: insertion of items with specified priorities, and deletion of an item with the highest priority

Example:Suppose we insert items with priorities 20, 389, 12 and7 into initially empty priority queue. After deleting and item,the priority queue contains 20,12,7and after inserting 67 it contains

20,12,7,67.


55/89

Heaps

A heap is a binary tree where all levels except possibly the lastlevel are completely filled in; the nodes in the last level are atthe left.

LEVEL

0

1

2

3


56/89

Binary MaxheapsIn a binary maxheap a value of each

node is greater or equal to thevalues of its children.

LEVEL

0

1

2

3

104

71 24

66

5

27

2532 18

23 8

22

104 71 24 66 27 23 8 5 32 25 18 22

1 2 3 4 5 6 7 8 9 10 11 12

1

2 3

4 5 67

89 10 11 12


57/89

Algorithm 3.5.6 Largest

This algorithm returns the largest value in a heap. The array vrepresents the

heap.

Input Parameter: vOutput Parameters: Noneheap_largest(v) {

return v[1]}


58/89

Deleting from a Heap

8

104

71 24

66

5

27

2532 18

23 8

22

22

71 24

66

5

27

2532 18

23 8

71

22 24

66

5

27

2532 18

23

71

66 24

22

5

27

2532 18

23 8

71

66 24

32

5

27

2522 18

23 8


59/89

Algorithm 3.5.7 Siftdown

The array vrepresents a heap structure indexed from 1 to n.

The left and right subtrees of node i are heaps.

Aftersiftdown(v, i, n) is called, the subtree rooted at iis a heap.


60/89

Input Parameter: v,t,nOutput Parameters: vsiftdown(v,i,n) {

temp= v[i]// 2 * i ntests for a left childwhile (2 * i n) {

child= 2 * i// if there is a right child and it is// bigger than the left child, move childif (child< n&& v[child+ 1] > v[child])

child= child+ 1// move child up?if (v[child] > temp)

v[i] = v[child]else

break // exit while loopi= child}// insert original v[i] in correct spotv[i] = temp

}


61/89

Algorithm 3.5.9 Delete

This algorithm deletes the root (the item with largest value) from a heap

containing nelements. The array vrepresents the heap.

Input Parameters: v,nOutput Parameters: v,nheap_delete(v,n) {

v[1] = v[n]n= n- 1siftdown(v,1,n)

}

Complexity: takes lg(n) operations


62/89

Algorithm 3.5.10 Insert

This algorithm inserts the value valinto a heap containing nelements. The

array vrepresents the heap.

Input Parameters: val,v,nOutput Parameters: v,nheap_insert(val,v,n) {

i= n = n + 1// iis the child and i/2 is the parent.// If i> 1, iis not the root.while (i> 1 && val> v[i/2]) {

v[i] = v[i/2]i= i/2

}v[i] = val}

Complexity?


63/89

Algorithm 3.5.12 Heapify

This algorithm rearranges the data in the array v, indexed from 1 to n, so

that it represents a heap.

Input Parameters: v,nOutput Parameters: vheapify(v,n) {

// n/2 is the index of the parent of the last nodefor i= n/2 downto 1siftdown(v,i,n)

}

Complexity?


64/89

Algorithm 3.5.12 HeapifyComplexity? n operations

Proof:The shiftdownis applied to all the nodes except the leaves.For a node at the level h-1the shiftdowntakes at most 1 step.In general, for a node at level i, the shiftdowntakes at most h-i

steps.There are2iinternal nodes on level i, i


65/89


221

h

i

i

i

total1/2 1/22 1/23 . . . 1/2h


66/89


On the other hand, there are n/2 internal nodes (non-leaves) in the heap, therefore the best-case complexityis still n

Note that this proves not only that the worst casecomplexity is n, but also the best and average casecomplexity.


67/89

Indirect Heaps

66 12 312 25 8 109 7 18

1 2 3 4 5 6 7 8

2 8 1 7 5 3 6 4

312

66 109

18 8 7 25

12

3 1 6 8 5 7 4 2

key

into

outof


68/89

Algorithm 3.5.15 Increase

This algorithm increases a value in an indirect heap and then restores the

heap. The input is an index iinto the keyarray, which specifies the value tobe increased, and the replacement value newval.

Input Parameters: i,newval


69/89

p ,Output Parameters: Noneincrease(i,newval) {

key[i] = newval// pis the parent index in the heap structure// cis the child index in the heap structurec= into[i]p= c/2while (p 1) {

if (key[outof[p]] newval)

break // exit while loop// move value at pdown to coutof[c] = outof[p]into[outof[c]] = c// move pand cupc= p

p= c/2}// put newvalin heap structure at index coutof[c] = iinto[i] = c

}


70/89

Algorithm 3.5.16 Heapsort

This algorithm sorts the array v[1], ... , v[n] in nondecreasing order. It uses

the siftdownand heapifyalgorithms (Algorithms 3.5.7 and 3.5.12).

Input Parameters: v,nOutput Parameter: vheapsort(v,n) {

// make vinto a heapheapify(v,n)for i = ndownto 2 {

// v[1] is the largest among v[1], ... , v[i].// Put it in the correct cell.swap(v[1],v[i])

// Heap is now at indexes 1 through i- 1.// Restore heap.siftdown(v,1,i- 1 )

}}


71/89

Disjoint setsWe consider nonempty pairwise disjoint sets, where each set has

an element marked as a representative element of the set.Sets X and Y are disjointiff

X Y=

Example:

The sets{1} {2,4,3} {5,6,7}Are nonempty pairwise disjoint sets. The mark element is each set

is represented in bold & underlined.


72/89

Disjoint sets

The operations:

makeset(i) constructs the set {i}

findset(i) returns the marked member ofthe set to which i belongs

union(i,j) replaces the set containing I andthe set containing j with their union.

Example:


73/89

Example:

makeset(1)makeset(2)

makeset(3)

makeset(4)

makeset(5)makeset(6)

makeset(7)

We have

{1}, {2},{3},{4}, {5},{6},{7}

union(2,4)union(2,3)

union(5,6)

union(6,7)

We have

{1} {2,4,3} {5,6,7}

findset(2) returns 4.

Disjoint sets


74/89

Disjoint setsWe represent the disjoint-set abstract data type as an arbitrary

tree with the marked element as a root.

Note that such a tree is not necessarily binary.

Example: Sets {1} {2,4,3} {5,6,7}may be represented as follows (note that there is more than one

way to represent these sets):

1 4

2 3

6

5

7


75/89

Algorithm 3.6.4 Makeset, Version 1

This algorithm represents the set {i} as a one-node tree.

Input Parameter: iOutput Parameters: Nonemakeset1(i) {

parent[i] = i}


76/89

Algorithm 3.6.5 Findset, Version 1

This algorithm returns the root of the tree to which i belongs.

Input Parameter: iOutput Parameters: Nonefindset1(i) {

while (i!= parent[i])i= parent[i]

return i}


77/89

Algorithm 3.6.6 Mergetrees, Version 1

This algorithm receives as input the roots of two distinct trees and

combines them by making one root a child of the other root.

Input Parameters: i,jOutput Parameters: Nonemergetrees1(i,j) {

parent[i] = j}


78/89

Algorithm 3.6.8 Union, Version 1

This algorithm receives as input two arbitrary values iandjand constructs

the tree that represents the union of the sets to which iandjbelong. Thealgorithm assumes that iandjbelong to different sets.

Input Parameters: i,jOutput Parameters: Noneunion1(i,j) {

mergetrees1(findset1(i), findset1(j))}


79/89

Q: What is a height of a tree constructed by previousalgorithms?

A: At most n-1, where n is the number of elements in the set.

It is more desirable for a tree representing a disjoint set to have asmaller height as then algorithms findset and union would bemore efficient.

The following algorithms guarantee that the height of a tree with n

nodes is at mostlg n

.

l k


80/89


This algorithm represents the set {i} as a one-node tree and initializes its

height to 0.


parent[i] = iheight[i] = 0

}

l h F d


81/89


This algorithm returns the root of the tree to which i belongs.


while (i!= parent[i])i= parent[i]

return i}

l h 3 6 11 M V 2


82/89



combines them by making the root of the tree of smaller height a child ofthe other root. If the trees have the same height, we arbitrarily make theroot of the first tree a child of the other root.

Input Parameters: i,jOutput Parameters: None

mergetrees2(i,j) {if (height[i] < height[j])

parent[i] = jelse if (height[i] > height[j])

parent[j] = ielse {

parent[i] = jheight[j] = height[j] + 1

}}

Al i h 3 6 12 U i V i 2


83/89






Can we do better than this?


84/89

Can we do better than this?

We can apply the so-called path compression in the findsetalgorithm. When executing findset(i), we make every node onthe path from i to the root a child of the root (except, ofcourse, the root itself).

Example:

1

2

3

4

5

6

7

8

1

2

3

5

4

678

Original tree The tree after findset(7)is called


85/89

The following algorithms incorporate path compression.

Note that the algorithms use rank instead ofheight. As the path compression can potentiallydecrease the height if the tree, this parameter doesnot necessarily denote the height of the tree. It

rather denotes an upper bound on its height, which wecall rank.

Al ith 3 6 16 M k t V i 3


86/89


This algorithm represents the set {i} as a one-node tree and initializes its

rank to 0.


parent[i] = irank[i] = 0

}

Al ith 3 6 17 Fi d t V i 3


87/89


This algorithm returns the root of the tree to which i belongs and makes

every node on the path from i to the root, except the root itself, a child ofthe root.


root= iwhile (root!= parent[root])root= parent[root]

j= parent[i]while (j!= root) {

parent[i] = root

i= jj= parent[i]

}return root

}

Al ith 3 6 18 M t V i 3


88/89



combines them by making the root of the tree of smaller rank a child of theother root. If the trees have the same rank, we arbitrarily make the root ofthe first tree a child of the other root.

Input Parameters: i,jOutput Parameters: None

mergetrees3(i,j) {if (rank[i] < rank[j])

parent[i] = jelse if (rank[i] > rank[j])

parent[j] = ielse {

parent[i] = jrank[j] = rank[j] + 1

}}

Al ith 3 6 19 U i V i 3


89/89






Lecture2 - Data Structures

Documents

Transcript of Lecture2 - Data Structures