February 2010

Master of Computer Application (MCA) – Semester 2

MC0068 – Data Structures using C

Assignment Set

1. Describe the theory of:

A) Strictly Binary Tree

B) Complete Binary TreeAns –

A) Strictly binary tree

If the outdegree of every node in a tree is either 0 or 2, then the tree is said to be strictly binary tree i.e., each node can have maximum two children or empty left and empty right child.

Example :

A binary tree is said to be strictly binary if every non-leaf node has non-empty left and right subtrees. Fig shows a strictly binary tree.

A Strictly binary tree

B) Complete binary tree

A strictly binary tree in which the number of nodes at any level i is 2 i-1, then the tree is said to be a complete binary tree. The tree shown in figure below is a strictly binary tree and at the same time it is a complete binary tree.

Example:

A Complete Binary tree

In a complete binary tree, the total number of nodes at level 0 is 1 i.e., 2°

Number of nodes at level 1 is 2 i.e., 21

Number of nodes at level 2 is 4 i.e., 22

Number of nodes at level 3 is 8 i.e., 23

……………………………………

……………………………………

……………………………………

Number of nodes at the last level d is 2d.

It is clear from the figure that all the nodes in the final level d are leaf nodes and the total number of leaf nodes is 2d. In a complete binary tree, we can easily find the number of non-leaf nodes. Now, let us find the number of non-leaf nodes in a complete binary tree. Total number of nodes in the complete binary tree =

2° + 21 + 22 + ………….2d.

Summation of this series is given by

S = a( rn- 1) 1( r- 1)

where a = 1, n = d+ 1 and r = 2

So, total number of nodes nt = 2d+1- 1

Nodes at level d are all leaf nodes. So, number of non-leaf nodes is given by 2d+1 – 1 –2d

which is equal to 2d – 1.

2. Describe with sample code snippets the following operations on Binary

Search Trees (BST):

A) Insertion

B) SearchingAns –

A) Insertion

Creating a binary search tree is nothing but repeated insertion of an item into the existing tree. So, we concentrate on how to insert an item into the tree. In a BST (Binary Search Tree), items towards left subtree of a node temp will be less than info(temp) and the items in the right subtree are greater or equal to info(temp).

Consider the BST shown in above figure. Suppose the node pointed to by temp (with item 140) has to be inserted. The item 140 is compared with root node i.e., 100. Since it is greater, the right subtree of root node has to be considered. Now compare 140 with 200 and since it is less, consider the left subtree of the node 200. Now, compare 140 with 150. Since it is less, consider the left subtree of node 150. Since, left subtree of node 150 empty, the node containing the Item 140 has to be inserted towards left of a node 150. Thus, to find the appropriate place and insert an item, the search should start from

the root node. This is achieved by using two pointer variables prev and cur. The pointer variable prev always points to parent of cur node. Initially cur points to root node and prev points to NULL i.e.,

prev = NULL

cur = root

Now, as long as the item is less than info (cur), keep updating the node pointed to by the pointer variable cur towards left. Otherwise, update towards right. The pointer variable prev always points to the parent node and cur points to the child node. Once cur points to NULL, insert the node temp towards left (prev) if item is less than info (prev), otherwise insert towards right. The code corresponding to this can be

prev = NULL; cur = root; /* find the position where to insert */ while ( cur != NULL ){prev = cur; cur = ( item < cur->info ) ? cur->llink : cur->rlink; } if ( item < prev->info) prev->llink = temp;else prev->rlink = temp;

The above steps can be executed provided the tree exists. If the tree is empty initially, then make the node pointed to by temp itself as root node. The complete C function to insert an item into a binary search tree is shown in below example

B) Searching

Start searching from the root node and move downward towards left or right based on whether the item lies towards left subtree or right subtree. This is achieved by comparing this item with root node of an appropriate subtree (left subtree or right subtree). If two items are same then search is successful and address of that node is returned. If the item is less than info (root), search in the left subtree, otherwise search in the right subtree. If item is not found in the tree, finally root points to NULL and return root indicating search is unsuccessful. The iterative function to search for this item is shown in below example.

Example Function to search for an item in BST using iteration

NODE iterative_ search (int item, NODE root){ /* search for the item */ while ( root != NULL && item != root->info ){ root = ( item < root->info ) ? root->llink : root->rlink;} eturn root;} The recursive function to search for an item is shown in below example. Example : Function to search for an item in BST using recursionNODE recursive_ search (int item, NODE root) { if ( root = = NULL ÷÷ item = = root->info ) return root; if ( item < root->info ) return recursive_ search(item, root->llink); return recursive_ search(item, root->rlink);}

3. With the help of a program and a numerical example explain the Depth

First Traversal of a tree.Ans –

3 Depth – First Traversal

In the depth-first traversal, we process all of a vertex’s descendents before we move to an adjacent vertex. This concept is most easily seen when the graph is a tree. In Figure below, we show the preorder traversal, one of the standard depth-first traversals.

In a similar manner, the depth-first traversal of a graph starts by processing the first vertex of the graph. After processing the first vertex, we select any vertex adjacent to the first vertex and process it. As we process each vertex, we select an adjacent vertex until we reach a vertex with no adjacent entries. This is similar to reaching a leaf in a tree. We then back out of the structure, processing adjacent vertices as we go. It should be obvious that this logic requires a stack (or recursion) to complete the traversal.

The order in which the adjacent vertices are processed depends on how the graph is physically stored.

Depth first traversal of a tree

4. Write a program to perform a binary search on an unsorted list of n

integers.Ans –

#include<iostream.h>

#include<conio.h>

void main()

{ clrscr();

int a[50],n,p,s,bsearch(int [],int,int);

void bubsort(int a[],int n)

cout<<"Enter the no. of elements: ";cin>>n;

cout<<"Enter the array...\n";

for (int i=0;i<n;i++) cin>>a[i];

cout<<"Enter the no. to be searched: ";cin>>s;

bubsort(a,n);

p=bsearch(a,n,s);

if (p==-1) cout<<"Sorry, element not found";

else cout<<s<<" was found at position "<<p+1;

getch();

}

void sort(int a[],int n)

{ int t;

for (int i=0;i<n;i++)

{ for (int j=0;j<(n-1)-i;j++)

{ if (a[j]>a[j+1])

{ t=a[j];

a[j]=a[j+1];

a[j+1]=t;

}

}

}

}

int bsearch(int a[],int n,int s)

{ int b=0,m,l=n-1;

while(b<l)

{ m=(b+l)/2;

if (s==a[m]) return(m);

else if(s>a[m]) b=m+1;

else l=m-1;

}

return(-1);

}

5. With the help of a numerical example, explain the working of Insertion

Sort.Ans –

An insertion sort has the advantage that it is simple to understand and simple to implement. Unfortunately, it is rather slow. Given an unsorted array of integer values, an insertion sort visits each element of the array, in turn. As it visits a particular element, it scans the array from the beginning up to the determines where in that segment of the array the current value belongs. It then inserts the current value in that location and shifts every element of the array to the right, up to the present location. It then goes on to the next location (value) in the array. Notice that one index is going from 0 to n and for each such value and another index is scanning the array from 0 to the value of the first index. The result of this is – that this type of sort is O(n2).

This is a naturally occurring sorting method exemplified by a card player arranging the cards dealt to him. He picks up the cards as they are dealt and inserts them into the required position. Thus at every step, we insert an item into its proper place in an already ordered list.

We will illustrate insertion sort with an example below given and presenting the formal algorithm.

Example : Sort the following list using the insertion sort method:

Step 1 1 < 4, Therefore insert before 4

Step 2 3 > 1, 3 Insert between 1 & 4

Step 3 2 > I, 2, Insert between I & 3

Step 4 5 > I, 2,3,4, Insert after 4 (5)

Thus to find the correct position search the list till an item just greater than the target is found. Shift all the items from this point one, down the list. Insert the target in the vacated slot.

6. With your own example explain breadth first traversal technique, and

analyze its complexity.Ans –

Breadth – First Traversal

In the breadth-first traversal of a graph, we process all adjacent vertices of a vertex before going to the next level. Looking at the tree in, Figure 7.7, we see that its breadth-first traversal starts at level 1 and then processes all the vertices in level 2 before going on to process the vertices in level 3.

Breadth-first traversal of a tree

The breadth-first traversal of a graph follows the same concept we begin by picking a starting vertex; after processing it, we process all of its adjacent vertices. After we process all of the first vertex adjacent vertices, we pick the first adjacent vertex and process all of its vertices, then the second adjacent vertex and process all of its vertices and so forth until we are finished.

The breadth-first traversal uses a queue rather than a stack, As we process each vertex, we place all of its adjacent vertices in the queue. Then, to select the next vertex to be processed, we delete a vertex from the queue and process it. Let’s trace this logic through the graph in Figure below.

Breadth-first traversal of a graph

1. We begin by enqueuing vertex A in the queue.

2. We then loop, dequeuing the queue and processing the vertex from the front of the queue. After processing the vertex, we place all of its adjacent vertices into the queue. Thus, at Step 2 in Figure 7.8(b]), we dequeue vertex X, process it, and then place vertices G and H in the queue. We are then ready for Step 3, in which we process vertex G.

3. When the queue is empty, the traversal is complete.

7. Explain the theory regarding the following splay trees:

A) Access Lemma

B) Static Optimality TheoremAns –

: A red-black tree with n internal nodes has height at most 2lg(n+1)

Proof: The tree rooted at any node x contains at least 2bh(x) – 1 internal nodes.

Base case: If the height of x is zero, then x must be a leaf and the tree rooted at x contains at least 20 – 1 = 0 internal nodes.

Inductive hypothesis: Consider a node x that has a positive height and is an internal node with two children. Each child has a black-height of either bh(x) or bh(x) – 1 depending upon whether the child is red or black, respectively. Since the height of a tree rooted at a child of x is less than the height of the tree rooted at x itself, we can apply the inductive hypothesis to conclude that each subtree rooted at a child has at least 2bh(x)-1 –1 internal nodes. Thus the tree rooted at x has at least (2bh(x)-1 –1) + (2bh(x)-1 –1) + 1 = 2bh(x) – 1 internal nodes.

Let h be the height of the tree. According to properties 4 and 5 at least half the node on any path from the root to a leaf, not including the root, must be black. Consequently the black height of the root must be at least h/2.

Thus n ³ 2h/2 – 1 and (n+1) ³ 2h/2

Take the lg of both sides of this inequality and find that

lg(n+1) ³ h/2 or h £ 2lg(n+1)

8. Explain the following in the context of files:

A) Sequential Files

B) Inverted Files

Ans –

A) Sequential files

A sequential file is the most primitive of all file structures. It has no directory and no linking pointers. The records are generally organised in lexicographic order on the value of some key. In other words, a particular attribute is chosen whose value will determine the order of the records. Sometimes when the attribute value is constant for a large number of records a second key is chosen to give an order when the first key fails to discriminate.

The implementation of this file structure requires the use of a sorting routine.

Its main advantages are:

(1) it is easy to implement;

(2) it provides fast access to the next record using lexicographic order.

Its disadvantages:

(1) it is difficult to update – inserting a new record may require moving a large proportion of the file;

(2) random access is extremely slow.

Sometimes a file is considered to be sequentially organised despite the fact that it is not ordered according to any key. Perhaps the date of acquisition is considered to be the key value, the newest entries are added to the end of the file and therefore pose no difficulty to updating.

B) Inverted files

An inverted file is a file structure in which every list contains only one record. Remember that a list is defined with respect to a keyword K, so every K-list contains only one record. This implies that the directory will be such that ni = hi for all i, that is, the number of records containing Ki will equal the number of Ki-lists. So the directory will have an address for each record containing Ki . For document retrieval this means that given a keyword we can immediately locate the addresses of all the documents containing that keyword. For the previous example let us assume that a non-black entry in the field corresponding to an attribute indicates the presence of a keyword and a black entry its absence. Then the directory will point to the file in the way shown in Figure 6.3. The definition of an inverted files does not require that the addresses in the directory are in any order. However, to facilitate operations such as conjunction (’and’) and disjunction (’or’) on any two inverted lists, the addresses are normally kept in record number order. This means that ‘and’ and ‘or’ operations can be performed with one pass through both lists. The penalty we pay is of course that the inverted file becomes slower to update.