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 7
0 0 0 0 0 0 5 0 0
1 0 4 0 0 0 0 0 0
2 0 0 0 0 0 0 9 0

1
 3 0 0 3 0 0 0 0 0
4 0 0 0 8 0 0 0 0

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 3 rd 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 9
0 3 5
1 1 4
2 4 9
3 1 3
4 0 1
5 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++)

2
 {

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]);

Getch( );

The Output :- Enter the order of the matrix. The order should be less
than 5 x 5

33

Enter the elements of the matrix:-

1 2 3

0 1 0

0 0 4

The 3-tuple representation of the matrix is:

1 1 1
1 2 2

1 3 3

3
 2 2 1

3 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

INSERTION

In 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 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.

4
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.

#include <stdio.h>

#include <conio.h>

5
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 - -;

Start _> data[position]= element;

Start _>count ++;

6
}

/*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 */

Void traverse (list * start)

Int i;

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

7
 {

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);

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.

8
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 preorder

Exam 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:

9
 BOOK

PREFACE
CHAPTER SUMMARY
CHAPTER 8
1

SECTION 1

SECTION 1 SECTION 4

SECTION
SECTION SECTION
1.1
4.1 4.2

SECTION
4.1.1

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:

10
1. Traversal left sub-tree in post order

2. Traversal sub-tree in post order

3. 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:

/
ROOT

/ dir 1 / dir 2 / dir 3

FILE FILE FILE

1 n 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:-

h e

b g

d c

11
Algorithm For Inorder Traversal

1. Traversal left sub-tree

2. Visit node

3. Traverse right sub-tree

For eg.
+

* -

/ 7

3 1
4
2

“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 – 31

Postorder : 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:-

12
 The given preorder’s inorder is :-

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:-

1 2

3 4

The following is the adjacency list representation of graph is

13
 Adj [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 5
1 0 1 1 0 1
2 1 0 0 1 1
3 1 0 0 1 1
4 0 1 1 0 1
5 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.

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

o if i=j
Weight 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.

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

15
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++)
{
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;
}
}

16
}
}
}
}
Getch( );
}

17