Attribution Non-Commercial (BY-NC)

543 vues

Attribution Non-Commercial (BY-NC)

- Internet Technology Lab Manual
- i Year b.tech,
- 25422733 C Programming and Data Structures Lab Manual
- data-struct
- CSC263 Spring 2011 Assignment 2 Solutions
- Cs2201 Data Structures
- 12111 Data Structure
- Operating Systems Deadlock
- Ece Sylabus Copy
- Data Structure
- c Language Basic Programs Which Used for Bigginners
- An Efficient Fault Diagnosis Method for Complex System Reliability
- Target PlacementsTQuestions
- DS lp
- Homework 1 Search in Pacman_2018spring
- 3_Solving Problems by Searching
- 123BP112016.pdf
- Bfs
- BST
- Prev Years Question Papers.pdf

Vous êtes sur la page 1sur 39

Assignment No. 1

Title of Assignment: Write a menu driven program to perform following operations on

Singly linked list: Create Insert, Delete and Display.

Design Analysis / Implementation Logic:

1. Ask the user to enter the data to be entered in the SLL one element at a time. For the

1st data create a node and initialize the 1 pointers to NULL.

2. From the second element entry onwards, traverse the SLL till the end with the help of

the forward pointer and create a new node, assign the data to it, its next pointer should

point to NULL.

Delete :

1. Accept the data which is to be deleted from the SLL.

2. Traverse the entire SLL from the 1st node and compare the data of every node with

the data entered by the user.

3. If match occurs delete the node. Deletion is accomplished by assigning the next

pointer of the previous node to the next node. Free the memory of the current node.

Display :

1. Begin with the 1st node in the SLL, print the data of all the nodes of the SLL in the

serial order with the help of the next pointer.

Testing:

Test Conditions:

Simple input of random numbers. After every insertion display to see if all the

contents are displayed properly. After every deletion also do the same. Delete nodes

at different locations in the SLL for eg, start node, last node and middle node. Make

sure that your delete function works for all cases.

Input:

Enter data ( could be words, characters or numbers) to be stored in the singly linked

list. Every node in

the SLL would contain 2fields: data, pointer.

Output :

Display the list of elements in the serial order as they appear in the SLL.

1

Lab Manual: Data Structures Laboratory

FAQS:

Conclusion:

In this assignment we have studied the basics about dynamic memory allocation and

how to create singly linked list and various operations on it.

2

Lab Manual: Data Structures Laboratory

Assignment No. 2

Title of Assignment: Write a menu driven program to perform following operations on

doubly linked list : Create, Insert, Delete, Display, Sort and Merge.

Algorithms:

1. Ask the user to enter the data to be entered in the DLL one element at a time. For

the 1st data create a node and initialize the 2 pointers to NULL.

2. From the second element entry onwards, traverse the DLL till the end with the

help of the forward pointer and create a new node, assign the data to it, its left

pointer should point to the node which was the last node previously and its right

pointer should point to NULL.

Delete :

1. Accept the data which is to be deleted from the DLL.

2. Traverse the entire DLL from the 1st node and compare the data of every node

with the data entered by the user.

3. If match occurs delete the node. Deletion is accomplished by assigning the

forward pointer of the previous node to the next node and the backward pointer

of the next node to the previous node. Free the memory of the current node.

Display :

1. Begin with the 1st node in the DLL, print the data of all the nodes of the DLL in

the serial order with the help of the next pointer.

Testing:

Test Conditions:

Simple input of random numbers. After every insertion display to see if all the

contents are displayed properly. After every deletion also do the same. Delete nodes

at different locations in the DLL for e.g., start node, last node and middle node. Make

sure that your delete function works for all cases.

Input:

Enter data (could be words, characters or numbers) to be stored in the doubly linked list.

Every node in the DLL would contain 3 fields: data, left pointer and right pointer.

Output:

Display the list of elements in the serial order as they appear in the DLL.

3

Lab Manual: Data Structures Laboratory

FAQS:

Conclusion:

In this assignment we have studied about doubly linked list, its advantages over

singly linked list and various operations on it.

Assignment No. 3

4

Lab Manual: Data Structures Laboratory

list and write a menu driven program to perform addition,

multiplication and evaluation.

Algorithms:

Addition of 2 polynomials.

1. Begin with 2 pointers initialized to the head of the 2 CLLs. Move the pointers one

location.

2. Check the exponent values in both the nodes. If they are same, add the coefficients,

create the node for the resultant CLL and insert the addition of the coefficients and

the exponent. If they are not the same copy the coefficient and exponent, of the larger

exponent value to the resultant polynomial. In the first case move both pointers

forward and in the latter move the pointer of the polynomial whose node has been

copied. At every step a node has to be created for the third polynomial.

3. The above step to be performed repeatedly till one of the pointers reaches the head

node back again. In that case copy the contents of the other list to the end of the

resultant list.

4. Finally connect the last node of the resultant to the first, making it a circular list.

Multiplication of 2 polynomials :

1. Begin with 2 pointers initialized to the head of the 2 CLLs. Move the pointers one

location.

2. Keeping the pointer in 1st list at the same node, move the pointer of the 2nd list over

the entire list. Multiply the coefficients and add the exponents at every stage. Insert

the coeff, exp pair in a new node in the 3rd list.

3. After the entire 2nd list has been traversed once, move the pointer of the 1st list to the

next node and position pointer of the 2nd list back to the 1st node and continue the

above process.

4. Before inserting the new coeff, exp pair in the third list, traverse the entire list and if

any node with same exponent is already present the new coefficient must be added to

the previous one. Also the exponent should be entered in the list in the sorted fashion

(descending order of exponents).

5. When the pointer of the 1st list reaches the head node, multiplication is complete.

Connect the pointer of the last node of the 3rd list back to the front, making it circular

and terminate.

5

Lab Manual: Data Structures Laboratory

Testing:

Test Conditions:

Addition of two polynomials :

Enter input :

12x^6 +34.5x^5 +x +1 =0

14x^5 +22x =0

Addition of the 2 polynomials is :

12x^6 +48.5 x^5 +23x+1=0

Multiplication of the 2 polynomials is :

Enter input :

x^2 +x +1 =0

2x+2=0

Multiplication of the above 2 polynomials is

2x^3 +4x^2 +4x+2=0.

Take x as input from user and evaluate any of the above polynomials and display result.

Input:

Polynomials entered in the circular linked list. Every node in the C.L.L will have an float

coefficient, integer exponent and a pointer to the next node. Special symbols (such as 0.0

and 0) should be stored in the first node since this is a circular list. The entry should be

done in a descending order of exponents.

Output:

Resultant polynomial after addition and multiplication. Take the value of x from user and

evaluate the resultant polynomial.

FAQS:

Conclusion:

In this assignment we have studied circular linked list and also how to implement

polynomials using it.

6

Lab Manual: Data Structures Laboratory

Assignment No. 4

Title of Assignment: Represent circular Queue and Double ended queue using Linked

representation and write a program to perform the following

operations : Insert, Delete.

Algorithms:

1. Maintain two counters front and rear which will always point to the front of the queue

and rear of the queue respectively. Initially both front and rear could point to the 1st

location of the array

2. When the Insert queue function or the add function is called, the rear should be

incremented by 1 position. Since we want to maintain a circular queue, advance rear

clockwise in the array (rear:=(rear+1)mod n), where n is the length of the array.

3. Check if front and rear are the same location. If so, it means queue is full, else add the

element in the position pointed to by rear.

Delete :

1. Check if front and rear are the same location. If so, it means queue is empty, else

increment the front by one position clockwise the same way we did to rear previously.

Then assign the item in that location to a variable and return.

(Note that queue full and queue empty are apparently having the same checking criteria,

but one is done after incrementing and the other is done before.)

Finding front :

1. Would proceed similar to delete except that after the variable has been returned, we

need to take front counter back 1 position to where it was before.

Finding rear :

1. Check if front and rear point to same location, if so say queue empty.

2. If not, return the element pointed to by the rear counter as the rear element of the

queue.

7

Lab Manual: Data Structures Laboratory

Testing:

Test Conditions:

Simple input of random numbers. After every insertion use function find rear to see if the

element is added properly. After every deletion also do the same. Also perform find front

prior to delete and make sure the same element is displayed in both cases.

Input:

Enter data ( could be words, characters or numbers) to be stored in the circular queue.

Every node in the circular queue would the data field. The queue should be implemented

as an array of data.

Output:

Display the item deleted from the queue at any time when the delete function is called

FAQS:

1. How to insert the new node in Circular queue & double ended queue?

2. How to delete the node from the front end of the Circular queue & double ended

queue ?

4. How to search the element in circular queue & double ended queue?

Conclusion:

In this assignment we have studied queue and doubly ended queue and how to

implement them using singly circular and doubly circular linked lists.

8

Lab Manual: Data Structures Laboratory

Assignment No.5

Title of Assignment: Creation of binary tree and perform recursive and non-recursive

traversals.

Algorithms:

1. Accept a random order of numbers from the user. The first number would be inserted

at the root node.

2. Thereafter, for every number ask user at which location he want to insert node. If he

said left than proceed left of the BT, else proceed right.

3. Perform this till you reach a null pointer, the place where the present data is to be

inserted.

4. Allocate a new node and assign the data in this node and allocate pointers

appropriately.

Traversals (Recursive):

1. Inorder: The recursive function will receive the root of the tree (or subtree) from

where inorder traversal is to be initiated. Algorithm is to proceed left, which in this

case is to call the same function with the left child of the node, print the data and then

proceed right, which in this case is to call the same function with the right child of the

node.

2. Preorder : Inorder was LDR, first move left, access data and then move right.

Preorder is DLR, first access data, move left and then move right.

3. Post order is LRD, first move left, then move right and then access the data.

1. The same effect which happened during the recursive run needs to be effected here.

2. Declare a stack which holds pointers ( the nodes of the BT).

3. In the inorder case, begin with a loop which moves left as far as it can, pushing the

current node on the stack.

4. When you reach null, pop a node from the stack, access and display its data, move

right and go back to step 3. If stack is empty at step 4, exit the loop.

5. The preorder and postorder traversals would proceed in an identical manner, except

the position of displaying the contents of data would vary.

9

Lab Manual: Data Structures Laboratory

Testing:

Test Conditions:

Simple input of random numbers. Display the inorder traversal. It must be a sorted

list of the numbers entered, since a BT has been created. This would be prove that the

BT has been constructed properly. The preorder and post order traversals would give

a listing of data, which could be checked by drawing the BT on paper and checking if

it were true.

Input:

Enter data ( numbers) to be stored in the binary search tree. Every node in the BT would

contain 3 fields: data, left child pointer and right child pointer.

Output:

Display the list of elements in the serial order as they appear in the three traversals:

inorder, preorder and postorder. (both recursively and non recursively)

FAQS:

Conclusion:

In this assignment we have studied about trees and its applications. We have also

studied how to implement the trees and traversals on trees.

10

Lab Manual: Data Structures Laboratory

Assignment No. 6

Title of Assignment: Creation of binary Search tree and perform recursive and non-

recursive traversals.

Algorithms:

1. Accept a random order of numbers from the user. The first number would be

inserted at the root node.

2. Thereafter, every number is compared with the root node. If less than

or equal to the data in the root node, proceed left of the BST, else proceed right.

3. Perform this till you reach a null pointer, the place where the present

data is to be inserted.

4. Allocate a new node and assign the data in this node and allocate

pointers appropriately.

Traversals (Recursive):

1. Inorder: The recursive function will receive the root of the tree (or subtree) from

where inorder traversal is to be initiated. Algorithm is to proceed left, which in this

case is to call the same function with the left child of the node, print the data and then

proceed right, which in this case is to call the same function with the right child of the

node.

2. Preorder : Inorder was LDR, first move left, access data and then move right.

Preorder is DLR, first access data, move left and then move right.

3. Post order is LRD, first move left, then move right and then access the data.

1. The same effect which happened during the recursive run needs to be effected here.

2. Declare a stack which holds pointers ( the nodes of the BST).

3. In the inorder case, begin with a loop which moves left as far as it can, pushing the

current node on the stack.

4. When you reach null, pop a node from the stack, access and display its data, move

right and go back to step 3. If stack is empty at step 4, exit the loop.

5. The preorder and postorder traversals would proceed in an identical manner, except

the position of displaying the contents of data would vary.

11

Lab Manual: Data Structures Laboratory

Testing:

Test Conditions:

Simple input of random numbers. Display the inorder traversal. It must be a sorted

list of the numbers entered, since a BST has been created. This would be prove that

the BST has been constructed properly. The preorder and post order traversals would

give a listing of data, which could be checked by drawing the BST on paper and

checking if it were true.

Input:

Enter data (numbers) to be stored in the binary search tree. Every node in the BST would

contain 3 fields: data, left child pointer and right child pointer.

Output:

Display the list of elements in the serial order as they appear in the three traversals:

inorder, preorder and postorder. (both recursively and non recursively)

FAQS:

1. What is the time complexity of binary search algorithm?

Conclusion:

In this assignment we have studied about binary search trees, its applications and

implementation.

12

Lab Manual: Data Structures Laboratory

Assignment No. 7

Title of Assignment: Write a program to create a Binary tree and find the height of tree

and print it’s leaf nodes. Find it’s mirror image, print original and

mirror image using level-wise printing.

Algorithms:

1. Accept a random order of numbers from the user. The first number would be inserted

at the root node.

2. Thereafter, every number is compared with the root node. If less than or equal to the

data in the root node, proceed left of the BST, else proceed right.

3. Perform this till you reach a null pointer, the place where the present data is to be

inserted.

4. Allocate a new node and assign the data in this node and allocate pointers

appropriately.

Height of BST :

1. This algorithm is based on the idea of storing the nodes of every level of the BST in a

dynamic queue (link list). It is also simultaneously useful to print the tree level wise.

The total number of levels accessed would be the height of the tree.

2. Initialize the contents of the list with the root of the BST. The counter

no_of_nodes_in_current_level =1 and the level_accessed =1.

3. Access no_of_nodes_in_current_level from the link list and add all their children to

the list at the end and simultaneously keep track of the number of nodes accessed in

the next level in a variable which at the end is assigned back to

no_of_nodes_in_current_level. Also increment level_accessed, indicating one more

level accessed in the BST.

4. Continue step 3 repeatedly till no_of_nodes_in_current_level is 0, which means no

more nodes in the next level. The value stored in the variable level_accessed is the

height of the BST.

(The above is a non recursive implementation to find the height of the BST. One could

also write a recursive algorithm to do the same.)

13

Lab Manual: Data Structures Laboratory

1. There are many algorithms to find the leaf nodes of a BST. The one considered here

is based on the idea that one could do a simple inorder traversal of the BST and just

before printing the data as one normally does in an inorder traversal, check if both the

left and right nodes are NULL. If so, it means the node under consideration is a leaf

node and must be printed.

2. Inorder: The recursive function will receive the root of the tree (or subtree) from

where inorder traversal is to be initiated. Algorithm is to proceed left, which in this

case is to call the same function with the left child of the node, print the data if both

left and right pointers are NULL and then proceed right, which in this case is to call

the same function with the right child of the node.

3. Thus all the leaf nodes of the BST are printed.

Mirror of Tree :

function mirror_Tree accepts a pointer to a tree as the parameter. Initially the root

node is passed later the roots of the subsequent subtrees are passed as the parameter.

2. The function begins by checking if the pointer passed is not NULL. If not, allocates a

new node. Assigns the data of the original node to the copied node. Assigns the left

child of the new node by calling the function mirror Tree with the right child of the

original node and assigns the right child of the new node by calling the function

mirror_Tree with the left child of the original node. If the pointer passed is NULL,

NULL is returned by the function else the new node created is returned.

1. This algorithm is based on the idea of storing the nodes of every level of the BST in a

dynamic queue (link list).

2. Initialize the contents of the list with the root of the BST. The counter

no_of_nodes_in_current_level =1 and the level_accessed =1.

3. Access no_of_nodes_in_current_level from the link list. Print the Level Number and

all the data of all the nodes of the current level. Simultaneously add all their children

to the list at the end and keep track of the number of nodes accessed in the next level

in a variable which at the end is assigned back to no_of_nodes_in_current_level.

Also increment level_accessed, indicating one more level accessed in the BST.

4. Continue step 3 repeatedly till no_of_nodes_in_current_level is 0, which means no

more nodes in the next level.

(The above is a non recursive implementation to do level wise printing of the BST. One

could also write a recursive algorithm to do the same.)

14

Lab Manual: Data Structures Laboratory

Testing:

Test Conditions:

Simple input of random numbers. Display the height of the tree and the leaf nodes. The

BST entered could be drawn on a rough page and one could check if the height calculated

and the leaf nodes printed are correct.

The height of the BST is 3.

The leaf nodes are 6, 14, 40 and 70.

Enter : 34, 12, 56, 6, 14, 40, 70.

Level 1 : 34

Level 2 : 12, 56,

Level 3 : 6, 14, 40, 70

Level 1 : 34

Level 2 : 56, 12

Level 3 : 70,40, 14,6

Input :

Enter data ( numbers) to be stored in the binary search tree. Every node in the BST

would contain 3 fields: data, left child pointer and right child pointer

Output

The height of the tree and the list of its leaf nodes.

The original and mirror image printed levelwise.

15

Lab Manual: Data Structures Laboratory

FAQS:

Conclusion:

In this assignment we have studied depth first and breadth first traversal of binary tree

and how to display the tree level-wise. We have also studied how to find out the

mirror image of a tree.

16

Lab Manual: Data Structures Laboratory

Assignment No. 8

Title of Assignment: Creation of binary inorder threaded tree (BST) and perform inorder

traversal using the inorder threads.

Algorithms:

1. Accept a random order of numbers from the user. The first number would be inserted

at the root node.

2. Thereafter, every number is compared with the root node. If less than or equal to the

data in the root node, proceed left of the BST, else proceed right.

3. Perform this till you reach a null pointer, the place where the present data is to be

inserted.

4. Allocate a new node and assign the data in this node and allocate pointers

appropriately. Initialize all the thread values to ‘f’ (false).

Creation of Threads :

Could be done in two ways: one after BST is created and the other inserting nodes in the

inorder position of the BST as and when it appears.

1. For the first method, run an inorder traversal (by previous algorithm) and store the

nodes of the inorder traversal as they appear in a linear list.

2. Then read the list of nodes and if a node has its left or right pointer pointing to NULL,

make it now point to the inorder predecessor or successor respectively and assign the

thread values to ‘t’ indicating true. Assign a head node, who will be pointed at by the

left pointer of the 1st node in the inorder traversal and by the right pointer of the last

node in the inorder traversal.

In the other technique, when you want to insert nodes in an existing threaded tree, do the

following :

1. If a node t is to be inserted as the right child of s in a threaded binary tree, t’s right

child will point to s’s right child and so will t’s right thread.

2. t’s left child will point to s and it’s left thread will be assigned ‘t’ (true). s’s right

child will point to t and its right thread will be ‘f’.

3. Find the inorder successor of t and its left child will now point to t.

1. Write a function which will take any node and will give you its inorder successor.

This function will access the right child of the given node.

17

Lab Manual: Data Structures Laboratory

2. If thread value is ‘f’, then as long as left thread is ‘f’ keep moving left through the left

pointer.

3. The node thus finally reached would be the inorder successor.

4. The Inorder traversal now becomes easy : Beginning with the first node of the inorder

traversal, which can be reached from the header node, call the inorder successor

repeatedly, display its data, and go on till you meet the header node again, which

signals the end of the inorder traversal.

Testing:

Test Conditions:

Simple input of random numbers. Display the inorder traversal. It must be a sorted

list of the numbers entered, since a BST has been created. This would be prove that

the threaded BST has been constructed properly

Input:

Enter data (numbers) to be stored in the binary search tree. Every node in the BST would

contain 5 fields: data, left child pointer and right child pointer, left thread tag and a right

thread tag

Output :

Display the list of elements in the serial order as they appear in the inorder traversal.

FAQS:

1. How to create Threaded BST?

Conclusion:

In this assignment we have studied about threaded binary trees, advantages of

threading and its implementation.

18

Lab Manual: Data Structures Laboratory

Assignment No.9

Title of Assignment: Write a program to represent a graph using adjacency list and

perform BFS and DFS.

Algorithms:

1. Declare an array of pointers to a link list having a data field (to store vertex number)

and a forward pointer. The number of array of pointers would equal the total number

of vertices in the graph.

2. Take the edge set from the user. If for eg, vertex 1 is connected to vertex 2 and 3 in

the graph, the 1st location of the array of pointers (corresponding to vertex 1) would

point to 2 nodes, one having the data 2 (corresponding to vertex 2) and the other

having data 3.

3. In this way construct the entire adjacency list.

1. The start vertex is visited. Next an unvisited vertex w adjacent to v is selected and a

DFS from w initiated.

2. When a vertex u is reached such that all its adjacent vertices have been visited, we

back up to the last vertex visited which has an unvisited vertex w adjacent to it and

initiate a DFS search from w.

3. The search terminates when no unvisited vertex can be reached from any of the

visited ones.

1. Starting at vertex v and marking it as visited, BFS differs from DFS in that all

unvisited vertices adjacent to v are visited next.

2. Then unvisited vertices adjacent to these vertices are visited and so on.

3. A queue is used to store vertices as they are visited so that later search can be initiated

from those vertices.

19

Lab Manual: Data Structures Laboratory

Testing:

Test Conditions:

Enter the graph with 8 vertices and 10 edges (1,2), (1,3), (2,4), (2,5), (3,6), (3,7), (4,8),

(5,8), (6,8),(7,8).

The order of the vertices visited by BFS is : 1, 2, 3, 4, 5, 6, 7, 8.

Input :

The number of vertices and the edge set of the graph

Output :

The order of vertices visited in both DFS and BFS.

FAQS:

Conclusion:

In this assignment we have studied how to represent the graph using adjacency list and

DFS and BFS traversals.

20

Lab Manual: Data Structures Laboratory

Assignment No. 10

Title of Assignment: Write a program to represent graph using adjacency list or matrix

and generate minimum spanning tree using PRIM’s algorithm

Algorithms:

Both the methods are implemented using the Greedy approach. The difference lies in the

way the cycle is prevented. To construct a M.S.T. from a graph of n vertices, we need n-

1 edges exactly. Also, these must be selected in a way that the sum of the n-1 edges is

minimum and so cycle is formed.

2. Assign two arrays mindist, in which we note the minimum distance from each of the

vertex to vertex 1 and array nearest in which all the vertex are initially near vertex 1.

3. Among mindist find the smallest value and include that vertex in the MST along with

the respective edge. Assign the value in the corresponding nearest entry to –1.

4. Now consider all the other vertices with respect to the vertex recently added to the

MST. If the edge from any of these vertices to the recently added vertex is smaller

than the current value stored in mindist then change the mindist value to this value

and change nearest array value to the recently added node.

5. If n-1 edges are not yet part of the answer goto step 3.

6. The time complexity of the above algorithm is n2, where n is the number of vertices.

There is an outer for loop that loops n-1 times to find the n-1 edges and there is a

inner for loop that scans the mindist array which of size n to find the smallest entry.

The Kruskal’s method to find the M.S.T proceeds in the following manner :

1. Form a min heap of all the edges according to their weights. Any call to delete an

edge from the min heap will return the smallest weighted edge and rearrange the heap

in such a way that the heap property is maintained.

2. Form a list of connected components in which maintain all the vertices in different

sets.

3. Delete the smallest edge from the heap. Check if the two vertices of the edge belong

to different sets; if they do then add the edge to the minimum spanning tree and

merge the sets to which the vertices belong into 1 set.

4. If the two vertices of the set belong to a single set, then do not add the edge to the

MST, in this way cycles are prevented.

5. If n-1 edges do not yet belong to the solution then go back to step 3.

6. The time complexity to sort the edges is aloga, a the number of edges all the other

steps are carried out in a time less than this one. Thus for a sparse graph where a is

approximately equal to n the time complexity is nlogn and for a dense graph where a

21

Lab Manual: Data Structures Laboratory

Thus for sparse graphs Kruskal’s algorithm is faster and for a dense graph Prim’s

algorithm is faster.

Testing:

Test Conditions:

The graph for which MST is to be found out is as follows :

Vertex 1 Vertex 2 Edge Weight

1 2 1

2 3 2

1 4 4

2 4 6

2 5 4

3 5 5

3 6 6

4 5 3

5 6 8

4 7 4

5 7 7

6 7 3

The Minimum Spanning Tree for the above graph is

Vertex 1 Vertex 2 Edge Weight

1 2 1

2 3 2

1 4 4

4 5 3

4 7 4

6 7 3

Input:

Graph entered as an adjacency matrix for n vertices i.e. fill an n*n matrix with the values

of the weights of the edges of the graph where the row number and column number as

the two vertices of one edge.

22

Lab Manual: Data Structures Laboratory

Output :

The Minimum Spanning Tree of the particular graph, i.e. the set of edges which are part

of the M.S.T along with their respective weights and the total weight of the M.S.T.

FAQS:

Conclusion:

In this assignment we have studied how to represent the graph using adjacency matrix

and finding out MST using Prim’s algorithm.

23

Lab Manual: Data Structures Laboratory

Assignment No. 11

Title of Assignment: Write a C++ Program to create a text file, read it and computer

frequency of vowels, count words, characters, lines and white space

characters and write these results into another text file . Use

command line arguments.

Algorithm:

1. Initialize the variables char_count, word_count, line_count, vowel_count to 0.

2. Accept the name of the text file from the user through command line.

3. Check whether the user has provided the file name through command line. If not

then flag an error and exit.

4. If the user has provided the file name through command line, then store it in a

string.

5. Open the file in read mode.

6. Read the file character by character until end of file is reached.

7. Increment the character count for each and every character.

8. Increment the word count when we encounter space character or new line

character.

9. Increment the vowel count when we get either of a, e, i, o, u, A, E, I, O, U.

10. Increment the line count when we get new line character.

11. Close the opened file.

12. Display the number of characters, words, lines, and vowels in the given text file.

Testing:

Test Conditions:

The text file name is passed as a command line argument. If the file is not present

then the error is reported. If the file is present then the information about the number of

characters, words, lines, and vowels is displayed on the screen.

Input:

The file name is passed as a command line argument.

Output:

The information about the number of characters, words, lines, and vowels is

displayed on the screen.

24

Lab Manual: Data Structures Laboratory

FAQS:

• How to open the files in C++?

• How to read and write the files in C++?

• Which classes support the processing of the files in C++?

Conclusion:

In this assignment we have studied how to process the files in C++ and also we have

studied how to access the command line arguments.

25

Lab Manual: Data Structures Laboratory

Assignment No. 12

Title of Assignment: Write a program to implement direct access file.

Algorithms:

Chaining :

Here we link all the synonyms in the file. Each time we come across a synonym we add

it to empty space in the file and make it’s previous node with same hash key point to it.

So we get different chains of the same synonym in the main file.

Addition of record :

1. Accept record from the user.

2. Calculate hashed value of the key field.

3. Check for that position in the file.

4. If position found empty insert record. If not goto next available location and store

data there.

5. Connect the next pointer of the previous synonym of that key to this location and the

previous pointer of this record to previous synonym.

1. Accept the key of record to be searched.

2. Calculate hash value of the key.

3. Check at the position in the file.

4. If not, match found, check for that record in the entire chain by using the next link.

5. If key matched then display the record.

6. If not found, display ‘Record not found’ message.

Deletion of a record :

1. Accept the key field of the record to be deleted.

2. Search the record in the file using the chain.

3. If found, then delete the record by making key = -1.

4. Make the pointer of the previous node point to the next node the current record was

pointing to.

Append a record proceeds similarly as display record, except that after the record is

obtained changes are made to it and written in the same location as was read.

26

Lab Manual: Data Structures Laboratory

Testing:

Test Conditions:

Enter any student database with student name, roll number and marks. Use roll

number as key. Display the records to see if they are accessed properly. Delete a

record and then try to display it. Appropriate error message must be printed.

Input:

Student data to be entered in the Simple Index file

Output :

Data displayed on request.

FAQS:

1. What is chaining?

Conclusion:

In this assignment we have studied various hashing techniques.

27

Lab Manual: Data Structures Laboratory

Assignment No.13

Title of Assignment: Write a program to add binary numbers (assume one bit as one

number) use STL stack.

Algorithms:

Template can be use to create the generic classes and functions that extend

support to generic programming. The collection of the generic classes and functions is

called standard template library.

Components of STL:

1. Containers

2. Algorithms

3. Iterators

Containers:

It is an object that actually stores data. It is the way in which data is stored in

memory. STL containers are implemented by template classes and therefore can be easily

customized to hold different data types.

Algorithm:

An algorithm is a procedure that is used to process data that is held in containers.

STL includes many different types of algorithm.

Iterator:

It is an object that points to an element in a container. We can use an iterator to

more through the contents of a container. Iterators are handled just like like pointers.

Steps:

1. Read numbers

2. Obtain remainder on division by 2

3. Push remainder onto stack

4. Divide no. by 2

5. If no.>0 , goto step 2

6. Display no.

7. return

28

Lab Manual: Data Structures Laboratory

Add:-

2. Pop one element from each stack

3. Add the two and push result into the third stackalso initialise carry caused due to

addition

4. In both stacks are not empty , goto step 2

5. For stack that is not empty , perform addition with carry and push result into the third

stack

6. Convert result intodecimal

7. Return

Testing:

Test Conditions:

Binary value for 9= 1001

Result = 16 in binary = 10000

Input:

Output :

FAQS:

1. What is STL?

2. Why we are using STL?

3. What are the functions used in this program?

4. What is Itrator?

5. What is Container?

Conclusion:

In this assignment we have studied STL and vectors in STL

29

Lab Manual: Data Structures Laboratory

Assignment No.14

Title of Assignment: Write a program to implement Deque using STL

Algorithms:

A deque is double ended queue with optimized operations both at the front and the back

The deque is maintained into standard template library.

Front()

Back()

Push_front()

Pop_front()

Push_back()

Pop_back()

Empty()

1. Main()

Read choice from user

2. Switch(choice)

Case 1: read element

Call: push_front(element)

Case 2: read element from user

Call: Push_back()

Case 3: Display front()

Call: pop_front()

Case 4: Display back()

Call: pop_back()

3. If user wants to continue goto step 1

4. Exit

1. Display()

Declare an iterator of the container type . i.e. in this case dequeue say I

For(I=dq.begin();I!=dq.end;i++)

Display(*i)

Return

30

Lab Manual: Data Structures Laboratory

Testing:

Test Conditions:

1. Add from front

2. Add from rear

3. Delete from front

4. Delete from rear

Enter the element to add from front:1

Enter the element to add from rear:4

Enter the element to add from rear:7

Delete the element from the rear:

Input:

Give the integer input from front and rear. store that data in deque.

Output:

Display the data present in the deque. Display it after deletion of the data from front and

from rear .

FAQS:

Conclusion:

In this assignment we have studied deque in STL

31

Lab Manual: Data Structures Laboratory

Assignment No. 15

Title of Assignment: Write a program to use STL for sorting and searching with user

defined records.

Algorithms:

By including algorithm.h the above file many useful generic algorithms can be applied

on containers. These algorithms can be applied to containers such as list ,vector ,deque,

etc.

Binary_search, search: to search for the element in container class

Equal: to check two containers are equal or not.

Copy: to copy the item of one container class into another container

class.

Fill: to fill all the elements of a container class with a particular item.

Remove: to remove all the elements from the container class

main()

2. Select case choice

Case 1:

Read data from user

Add data to container

Case 2:

Call:display()

Case 3:

Read data to be searched

Declare an iterator of that type

Call: search(start,end,data)

Case 4:

Call: sort(start,end)

3.Exit

32

Lab Manual: Data Structures Laboratory

display()

2. For I= begin() ; I not equal to end() ; I++

DISPLAY(*i);

3. Return

Testing:

Test Conditions:

1. ADD

2. DISPLAY

3. SEARCH

4. SORT

5. EXIT

ENTER ROLL_NO :1

ENTER NAME : A

1. ADD

2. DISPLAY

3. SEARCH

4. SORT

5. EXIT

ENTER ROLL_NO :2

ENTER NAME : B

1. ADD

2. DISPLAY

3. SEARCH

4. SORT

5. EXIT

ENTER ROLL_NO :3

ENTER NAME : C

33

Lab Manual: Data Structures Laboratory

1. ADD

2. DISPLAY

3. SEARCH

4. SORT

5. EXIT

ROLL NO:1

NAME :A

ROLL NO:2

NAME :B

ROLL NO:3

NAME :C

1. ADD

2. DISPLAY

3. SEARCH

4. SORT

5. EXIT

ENTER ROLL NO :2

ROLL NO:2

NAME :B

1. ADD

2. DISPLAY

3. SEARCH

4. SORT

5. EXIT

ROLL NO:1

34

Lab Manual: Data Structures Laboratory

NAME :A

ROLL NO:2

NAME :B

ROLL NO:3

NAME :C

Input:

Enter the name and roll number of the students.

Output:

Whatever the name and roll number search the records by roll number.

Whatever the name and roll number sort the records by roll number.

FAQS:

Conclusion:

In this assignment we have studied stack in STL

35

Lab Manual: Data Structures Laboratory

Assignment No. 16

Title of Assignment: Mini Project:- Database using sequential files.

Algorithm:

Testing:

FAQS:

Conclusion:

36

Lab Manual: Data Structures Laboratory

37

Lab Manual: Data Structures Laboratory

38

Lab Manual: Data Structures Laboratory

39

- Internet Technology Lab ManualTransféré parmitprasoon
- i Year b.tech,Transféré parSRINIVASA RAO GANTA
- 25422733 C Programming and Data Structures Lab ManualTransféré parChanabasayya Vastrad
- data-structTransféré parapi-3782519
- CSC263 Spring 2011 Assignment 2 SolutionsTransféré paryellowmoog
- Cs2201 Data StructuresTransféré parKarthik Sara M
- 12111 Data StructureTransféré parFarah Khan
- Operating Systems DeadlockTransféré parjayangp
- Ece Sylabus CopyTransféré parSrinivas Karatlapelli
- Data StructureTransféré parNeeraj Joshi
- c Language Basic Programs Which Used for BigginnersTransféré parRavikumar Vendi
- An Efficient Fault Diagnosis Method for Complex System ReliabilityTransféré parkarhitsh
- Target PlacementsTQuestionsTransféré parsishantkumar
- DS lpTransféré parpriyanga
- Homework 1 Search in Pacman_2018springTransféré parStrider_17
- 3_Solving Problems by SearchingTransféré parVicky Hardian Kusuma Candra
- 123BP112016.pdfTransféré parthirupathi
- BfsTransféré parLalith Kartikeya
- BSTTransféré parMelania Nitu
- Prev Years Question Papers.pdfTransféré parPavi Agra
- Articulo IATransféré parMiguel Andres
- L-14Transféré parShah Khan
- Ds Lab ManualTransféré parAnanth Balakrishnan
- 002 - Planarity testing and embedding.pdfTransféré parAdriano VIsmara
- lec21Transféré parPaVan Nelakuditi
- ALG2.2Transféré parWin Zonio
- Course Plan New FORMAT-1Transféré parsprabhakaranece
- Algorithm and Data Structures ListTransféré parRahman M.
- sairamIITMCIKMTransféré parAmit Chandak
- 1-s2.0-S1877705811018340-main.pdfTransféré parmotherearthcalls

- Computer Networks FAQsTransféré parAmit Sangale
- ADBMS Lab ManualTransféré parAmit Sangale
- Adbms Oral FaqTransféré parAmit Sangale
- PCD Final AssTransféré parAmit Sangale
- Adbms Oral Questions Topic - Client Server Architecture (Unit III).Transféré parAmit Sangale
- OS Lab ManualTransféré parAmit Sangale
- Ommd QuestionTransféré parAmit Sangale
- 2008 09 OOMD Lab ManualTransféré parAmit Sangale
- Rdbms Vpl Lab ManualTransféré parAmit Sangale
- DSP LabmanualTransféré parAmit Sangale
- Unit i : Classification of SignalsTransféré parAmit Sangale
- Programming Laboratory Lab_manualTransféré parAmit Sangale
- Software LabTransféré parAmit Sangale
- Cnl Lab Manual FullTransféré parAmit Sangale
- Cg Oral QuestionTransféré parAmit Sangale
- Dsl Oral QuestionTransféré parAmit Sangale
- Mil Oral QuestionTransféré parAmit Sangale
- MIL Lab Manual NewTransféré parAmit Sangale
- Lab Manual OopsTransféré parAmit Sangale
- Lab Manual CGTransféré parAmit Sangale
- Unit 6 1. Which Are Different Techniques of Document IndexingTransféré parAmit Sangale
- Amit 1 What is .Diff Between Oltp n Olap(3 Pts)Transféré parAmit Sangale
- Topic Name: Distributed Database System Q1:What Do You Mean ByTransféré parAmit Sangale
- Adbms Oral” Question “unit -1”Transféré parAmit Sangale

- Different Types of ModelingTransféré parAgnus S Swarna Lakshmi
- Lotus-Domino-Designer Programming Guide Vol1Transféré parPettrie De Bondt
- Java_Fundamentals_Midterm_Exam.docxTransféré parTxG - BoyVivo
- ccms nagiosTransféré pargouthamshoroff
- Aotc Autodesk 3ds Max 9 Maxscript Essential.unlockedTransféré parjasopanev
- What is PDV (Program Data Vector)Transféré pargenius_gks
- Do Cum en ToTransféré parFrekes Villas
- Sky X TechnologyTransféré parVishnu Pradeep
- VB Script - QTPTransféré parvenkatabalaji.e7390
- On EBX5 ProjectsTransféré parsakir bayram
- Project Report -Memory Monitor - JyotiTransféré parArvind Tilotia
- Java Interview Notes_ 700 Java Interview Q - Jolly MTransféré parbrian
- znotesTransféré paralperaydyn2
- Oracle Databases on the Web Learn to Create Web Pages That Interface With Database Engines.9781576100998Transféré parapi-3855630
- script 1 bitslerTransféré parMastersBestHackers
- ResumeTransféré parChashmeet Singh
- SubSonicTransféré parMitchell Hastings
- An ISO 9001:2000 CompanyTransféré pardophamduy
- plugindocTransféré parJohnny Rodriguez
- CS Review QuestionsTransféré parNguyen Dong Duc
- matlabTransféré parHafizatul Faiza
- A New Approach For Regression Test Case Prioritization Using Branch Coverage, Decision Coverage And Criticality Coverage TechniquesTransféré parEditor IJRITCC
- pattern.. strategyTransféré parAniruddha Patil
- Oracle TOAD Lab GuideTransféré parsamramon95
- Software Requirements SpecificationTransféré parAkash Maurya
- Tetris Tutorial in C++ Platform Independent Focused in Game Logic for Beginners _ JavilopTransféré parziedus
- Takion API and Developer DocumentationTransféré parphoenix92x
- Image Manipulation in JavaTransféré parRitesh Kumar
- CDC UP Project Schedule TemplateTransféré parMuhammadIqbalMughal
- Cvicore1 Coursemanual English SampleTransféré parArun