MCS-21 ASSIGNMENT (2010-11)

This assignment has three questions, which carry 80 marks. Answer all the questions. Viva-voca carries 20 marks. You may use illustrations and diagrams to enhance the explanations. Please go through the guidelines regarding assignments given in the programme Guide. Ensure that you don’t copy the program from course material or any other source. All the implementations should be in C language.

Question 1:

An alternative linked representation for sparse matrices uses nodes that have the field down, right, row, col and value. Each nonzero entry of the sparse matrix is represented by a node. The zero terms are not explicitly stored. The nodes are linked together to form two circular lists. The first list, the row list, is made up by linking nodes by rows and within rows by columns using the right field. The second list, the column list, is made up by linking nodes via the down field. In this list, nodes are linked by columns and within columns by rows. These two lists share a common header node. In addition, a node is added to contain the dimensions of the matrix.

(a )Write any 5 x 8 Matrix that has exactly nine nonzero terms such that at least one nonzero term appears in each row and each columns. For this sparse matrix, draw the linked representation.

Ans. Matrixes with good number of zero entries are called sparse matrixes. A triangular matrix is a square matrix in which all the elements either above or below the main diagonal are zero.

The triangular matrix is sparse matrix in which all the elements except for the main diagonal on the immediate upper and lower side are zeroes. Tridiagonal matrixes are also sparse matrixes.

Now we will consider the sparse matrix from storage point of view. Suppose that the entire sparse matrix is stored. Then, a considerable amount of memory which stores the matrix consists of zeroes. This is nothing but wastage may count to mega bytes. So, an efficient method of storing sparse matrixes has to be looked into.

0 1 2 3 4 5 6 70 0 0 0 0 0 5 0 01 0 4 0 0 0 0 0 02 0 0 0 0 0 0 9 03 0 0 3 0 0 0 0 04 0 0 0 8 0 0 0 0

1

A common way of representing non zero elements of a sparse matrix always specifies the number of rows, number o0f columns and number of non zero elements in matrix. The number 5 represent the total number of rows sparse matrix. Similarly the number 8 represents the total number of columns in the matrix. The number 8 presents total number of non zero elements in the matrix. Each non zero element is stored from the second row, with the 1st and 2nd elements of the row, indicating the row number and column number respectively in which the element is present in the original matrix. The 3rd element I this row stores the actual value of the non zero element. For example, the 3-tuple representation of the matrix is shown below:-

7 7 90 3 51 1 42 4 93 1 34 0 15 2 8

Program concept: A matrix as input and prints 3 tuple representation which is in sparse matrix is as follows:-

# include <stdio.h>#include <conio.h>Void main(){Int [5][5], rows, columns, i, j;Printf(“enter the order of the matrix. The Orer should be less than 5 x 5:\n”);Scanf(“%d %d”, & rows, & columns);Printf(“Enter elements of the matrix : \n”);For (i = 0; i < rows i i++){For (j=0; j < columns; j++) {Snaf(“%d”, & a[i][j]); }}Printf(“The 3-tuple representation of matrix is :/n”);For (i=0; i<row; i++){For (j=0; j<columns; j++) { If(a[i] [j] != 0)

{Printf(“%d %d %d”, (i+1), (j+1), a[i] [j]);

2

} }}Getch( );}

The Output :- Enter the order of the matrix. The order should be less than 5 x 533Enter the elements of the matrix:-1 2 30 1 00 0 4The 3-tuple representation of the matrix is:1 1 11 2 21 3 32 2 13 3 4

(a) Suppose that an m x n matrix with t non-zero terms is represented as above. How small

must t be so that the above linked scheme uses less space than an m x n array uses?Ans.

(b) Design a suitable external (i.e one that can be used for input and output) representation for a sparse matrix. Your representation should not require explicit input of the zero terms.

Ans. In the array implementation of lists, we will use array to hold the entries and a separate counter to keep track of the number of positions are occupies. A structure will be declared which consist of array and counter.For simplicity, we have taken list entry as integer of course, we can also taken list entry

as structures of employees record of the student record etc. Count 1 2 3 4 5 6 7 8

11 22 33 44 55 66 77

INSERTIONIn An array implementation of list, elements are stored in continuous

locations. To add element to the list at the end, we can add it without any problem. But, suppose if we want to insert the element at the beginning or middle of the list, then we have to rewrite all the elements after the position where the element has to be

3

inserted. We have to shift (n)th element to (n+1)th position, where ‘n’ is number of elements in the list. The (n-1)th element to (n)th

Position and this will continue until the (r)th element to (r+1)th position, where ‘r’ is the position of insertion.

For doing this, the count will be incremented

Before Insertion

Count 1 2 3 4 5 6 7 8

11 22 33 44 55 66 77

Step 1 Count

11 22 33 44 55 66 77 77

Step 2 Count

11 22 33 44 55 66 66 77

Step 3 Count

11 22 33 44 55 55 66 77

Step 4 Count

11 22 33 44 55 66 66 77

Step 5 Count

11 22 33 35 44 55 66 66 77

It will demonstrate the insertion of an elements at desired position.Inserting an element into contiguous list (Linear Array) at specified position.

4

#include <stdio.h>

#include <conio.h>

Void main

{

Type of struct

{

Int data [10];

Int count;

} list;

/ * prototypes of functions * /

Void insert (list * , int, int);

Void create (list *);

Void traverse (list *);

/ * Defination of the insert function * /

Void insert (list * start, int position, int element)

{

Int temp = start = start_ > count ;

If(element !=0)

{

While (temp > position)

{

Start _> data[temp + |]= start_> data[temp];

Temp - -;

}

5

Start _> data[position]= element;

Start _>count ++;

}

}

/*Definition of create function to READ data values into the list */

Void create (list * start)

{

Int i=0, test = 1;

While (test)

{

fflush (stdin);

printf(“input value for :%d”, i);

scanf(“%d”, & start _> data [i]);

if(start _> data [i] ==0)

{

Test = 0;

Else

i++;

}

Start _> count = i;

}

Getch ( );

}

/* OUTPUT FUNCTION TO PRINT ON THE CONSOLE */

6

Void traverse (list * start)

{

Int i;

For (i=0; i< start_>count; i++)

{

Printf(“\n value at the position : %d: %d”, i,

Start _>data[i]);

}

}

/*main function*/

Void main( )

{

Int position, element;

List |;

Create (& |);

Printf(“\n entered list as follows”);

Fflush(stdin);

Traverse(&|);

Fflush(stdin);

Printf(“%d” & position);

Fflush(stdin);

Printf(“/n input the value for the position);

Scanf(“%d”, & element);

Insert(& |, position, element);

7

Traverse (&|);

Question 2:

Draw two binary trees whose preorder listing is abcdefgh and whose postorder listing is dcbgfhea. Also, list the nodes of binary trees inorder and level order.

Ans. There are three types of tree traversals, namely, preorder, post order and inorder. Preorder Traversal:-

Each node is visited before its children are visited, the root is visited first.Algorithm For Pre Order Traversal:-

1. Visit root node

2. Traverse Left sub-tree in preorder

3. Traverse right sub-tree in preorderExam of pre order traversal:-Reading a book, as we do not read next chapter unless we complete all the sections of previous chapter and all it’s sections refer to the following on the figure:

8

As each node is traversed only once, the time complexity of pre order is T(n) = O(n), where the number n is of nodes in the tree.So, the given preorder listing is abcdefgh and the binary tree is as following:

Algorithm For Pestorder Traversal:1. Traversal left sub-tree in post order2. Traversal sub-tree in post order3. Visit root node

Finding the space occupied by files and directories in a file system requires calculation of space required by all files in the directory (children in tree structure) refer to following figure:

9

BOOK

PREFACECHAPTER 1

SECTION 1

SECTION 1.1SECTION 4.1 SECTION 4.2

SECTION 4.1.1

SUMMARYCHAPTER 8

SECTION 1

SECTION 4

/ ROOT

/ dir 2 / dir 3/ dir 1

FILE n FILE 1FILE 1

“Calculation of space occupied by file system: A Post Order Traversal”The given post order listing is “dcbgfhea”. So, the binary tree for post order is on the next page:-

a

h e

b g

d c

Algorithm For Inorder Traversal1. Traversal left sub-tree2. Visit node3. Traverse right sub-tree

For eg.

“Inorder-Traversal”

In order Traversal can be best described by an expression tree, where the operators are at parent node and operates at leaf nodes.Now let us consider the above expression tree. The preorder, postorder and inorder traversal are given below:Preorder : +*/427 – 31Postorder : 42 / 7 *31 - +Inorder traversal : - ((((4/2) * 7) + (3 - 1))So, given preorder and postorder are silved by given the inorder to both as follow:-The given preorder’s inorder is :-

10

+

3 1

2

/

4

-

7

*

Inorder of preorder :- (d(cbe) a(gfh))The inorder of postorder is :-(((dbc) hg) ae)And level order is the order where all the nodes of the same level are travelled first travelled first starting from the root.

Question 3:Suppose that an undirected graph is represented with the array adjacency list representation. Write an algorithm to remove the an edge from G. What is the time complexity of the algorithm.

Ans. Adjacency List Representation: An adjacency list representation of a graph G= {V, E} consists of an array of adjacency list denoted by adj of V list. For each vertex U e V, adj[U] consists of all vertices adjacent to U in the graph G.Consider the graph for undirected graph:-

The following is the adjacency list representation of graph isAdj [1] = {2, 3, 5}Adj [2] = {2, 4}Adj [3] = {1, 4, 5}Adj [4] = {2, 3, 5}Adj [5] = {1, 3, 4}

An adjacency matrix representation of a graph G= (V, E) is a matrix A(aij) such that

aij = { 1 if edge (i,j) belongs to E O otherwise

The Adjacency matrix for the graph of above is given below:-

1 2 3 4 51 0 1 1 0 1

11

1

5

3 4

2

2 1 0 0 1 13 1 0 0 1 14 0 1 1 0 15 1 0 1 1 0

Adjacency matrix of an undirected graph is symmetric on main diagonal. When directions are not marked on the edges, then the graph is called an undirected graph.

Consider a graph G= (V,E). We wish to find out the shortest path from a single source vertex vEV, to every vertex vEV.

The single source shortest path algorithm is based on assumption that no edges have negative weights.

Now, we shall discuss about an algorithm in which we will remove an edge from the graph G.

And we can solve the path (shortest) algorithm which starts with a single source and finds shortest path to all vertices in the graph. This problem is helpful in finding distance between all pairs problem is mother of all shortest paths problems.

In this algorithm, we will represent the graph by adjacency matrix.

The weight of an edge (ij in an adjacency array representation as follow

o if i=jWeight of the undirected edges from i to j i.e. (i,j)

E= i, j If i-j and (i,j) belongs to

If i=j and (i,j) belongs to E

All the pairs shortest paths problem can be considered as a generalization of single-source-shortest-path problem by using Dijkstra’s algorithm by varying the source node among all nodes in the graph. We can use negative edges is allowed then we can not use Dijkastra’s algorithm.

In this section we shall use a recursive solution to the pairs (edges) problem known as Floyd-warshall algorithm, which runs in O(n) time.

This algorithm is based on the following principle for the graph G let V={1, 2, 3, ------n}. Let us consider a sub set of the vertices {1, 2, 3, k). For any pair opf vertices are from {1, 2, 3, -------k}. This algorithm will exploit the relationship between path P and shortest path from i to j whose intermediate vertices are from {1, 2, 3, ------k-1} with the following two possibilities.

12

If k is not an intermediate vertex in the path p, then all intermediate vertices of the path p are in {1, 2, 3,-----k-1}. Thus shortest path from i to j with intermediate vertices in (1, 2, 3, ----k) is also the shortest path from i to j with vertices {1, 2, 3, -----k}.

We also define a path matrix P where P[i][j] holds intermediate vertex k on the least cost path from i to j that leads to the shortest path from i to j.

Algorithm for lessing edges from G

N= Number of rows of the graph

D [i] [j] = C [i] [j]

For k from 1 to n

Do for i=1 to n

Do for j= 1 to n

D [i] [j] = minimum (dij(k - 1), dik(k - 1)+dki(k – 1))

Enddo

Enddo

Enddo

Where dij(k - 1) = minimum path from i to j using intermediate vertices

Where dik(k - 1) = minimum path from j to k using intermediate vertices

Where dkj(k - 1) = minimum path from k to j using intermediate vertices

Programme:-

#include <stdio.h>#include <conio.h>Void main ( ){All pairs shortest paths (int N, matrix C, matrix P, matrix D){Int i, j, k;If (i=j then C[i] [j]=0){For (i=0; i<N; i++)

13

{For (j=0; j<N; J++){D[i] [j]= C[i] [j];P[i] [j] = -1;}D[i] [j]=0;}For (k=0; k<N; k++){For (i=0; i<N; i++){For (j=0; j<N; j++){If (D [i] [k] + D [k] [j] < D [i] [j]){D [i] [j] = D[i] [k] +D[k] [j]P [i] [j] = k;}}}}}}Getch( );}

14