Data Structure Using ‘C’ Assignment No: 01

1. Write a program in ‘C’ to read N numbers and print them in

descending order.

Sol:- #include<stdio.h>

#include<conio.h>int main(){Int sort [n], i, j, t, n;Clrscr ();Printf ("\n\nEnter Numbers");scanf ("%d", &n);Printf ("Enter number to be print in descending order");For (i=0;i<n;i++)Scanf ("%d",&sort[i]);for(i=0;i<n;i++){for (j=i+1;j<n;j++){if(sort[i]>sort[j]){t=sort[i];Sort[i] =sort[j];Sort[j] =t;}}}printf ("Numbers in Descending Order Are :");For (i=n-1;i>=0;i--){printf ("%d\n", sort[i]);}getch ();}

2. Discuss the properties of ADT.

Sol: - ADT belongs to abstract data type. It is characterized by the following properties:-

It exports a type. It exports a set of operations. This set is called interface. Operations of the interface are the one and only access mechanism to the

type’s data structure. Axioms and preconditions define the application domain of the type.

With the first property of ADT it is possible to create

more than one instant of an ADT.

3. Write a note on i) Binary tree ii) Hash tables.

Sol:- i) Binary tree:- In computer science, a binary tree is a tree data structure in which

each node has at most two children. Typically the child nodes are called left and right.

In binary tree the upper node is called as root. Roots are larger from its childe. Binary

trees are commonly used to implement binary search trees and binary heaps.

Notes:-

Each node contains only one element.

The right childe could be empty but not left is empty and right have an element.

No of nodes on lowest level should be 2i-2.

ii) Hash tables:- A hash table, or a hash map, is a data structure that

associates keys with values. The primary operation it supports efficiently is a

lookup: given a key (e.g. a person's name), find the corresponding value (e.g.

that person's telephone number). It works by transforming the key using a hash

function into a hash, a number that is used as an index in an array to locate the

desired location ("bucket") where the values should be.

Hash tables support the efficient insertion of

new entries, in expected O(1) time. The time spent in searching depends on the

hash function and the load of the hash table; both insertion and search approach

O(1) time with well chosen values and hashes.

4. Write a ‘C’ program to implement the stack operations using arrays.

Sol:- C program to implement the stack using arrays is as following:-

#include<stdio.h>

#include<conio.h>

#include<process.h>

#define STACK_SIZE 5

5. What is queue? Explain different types of queues.

Sol:-Queue is a special type of data structure. A queue is a particular kind of

collection in which the entities in the collection are kept in order and the

principal (or only) operations on the collection are the addition of entities to the

rear terminal position and removal of entities from the front terminal position.

This makes the queue a First-In-First-Out (FIFO) data structure. In a FIFO data

structure, the first element added to the queue will be the first one to be

removed. This is equivalent to the requirement that whenever an element is

added, all elements that were added before have to be removed before the new

element can be invoked. A queue is an example of a linear data structure. There

are four types of queue which are:-

Ordinary Queue:- It operates on FIFO rule i.e. the item will be inserted

first will be removed first.

Double Ended Queue:- Deque (short of double-ended queue) is an

abstract list type data structure, also called a head-tail linked list, for

which elements can be added to or removed from the front (head) or back

(tail).

Circular Queue:- A circular is a data structure that uses a single, fixed-

size queue as if it were connected end-to-end. This structure lends itself

easily to buffering data streams.

Priority Queue:- A priority queue is an abstract data type in computer

programming that supports the following three operations:

1. Insert With Priority: add an element to the queue with an associated

priority

2. Get Next: remove the element from the queue that has the highest

priority, and return it (also known as "Pop Element(Off)", or "Get

Minimum")

3. Peek At Next (optional): look at the element with highest priority

without removing it.

6. Explain the Circular singly linked list with neat diagram.

Sol:-In a circularly-linked list, the first and last nodes are linked together. This can

be done for both singly and doubly linked lists. To traverse a circular linked list,

we begin at any node and follow the list in either direction until we return to the

original node. Viewed another way, circularly-linked lists can be seen as having

no beginning or end. This type of list is most useful for managing buffers for

data ingest, and in cases where you have one object in a list and wish to iterate

through all other objects in the list in no particular order. The pointer pointing to

the whole list may be called the access pointer.

A circularly-linked list

7. Discuss the various graphs with neat diagram.

Sol:- In computer science, a graph is a kind of data structure, specifically an abstract data type (ADT), that consists of a set of nodes (also called vertices) and a set of edges that establish relationships (connections) between the nodes. The graph ADT follows directly from the graph concept from mathematics.

Informally, G=(V,E) consists of vertices, the elements of V, which are connected by edges, the elements of E. Formally, a graph, G, is defined as an ordered pair, G=(V,E), where V is a set (usually finite) and E is a set consisting of two element subsets of V.

The graphs can be represented in two ways. One is adjacency matrix and adjacency list.

For A----------->B | ^ | | | | V | C ------------

Adjacency Matrix

A B C A 0 1 1 B 0 0 0 C 0 1 0

Adjacency List

A ----> | B | ----> | C | ---- NULL B ----> ---- NULL C ----> | B | ---- NULL

Example let us consider the following graph

8. Explain with example how to delete a node from the tree.

Each element in an internal node acts as a separation value for two subtrees, and when such an element is deleted, two cases arise. In the first case, both of the two child nodes to the left and right of the deleted element have the minimum number of elements, namely L-1. They can then be joined into a single node with 2L-2 elements, a number which does not exceed U-1 and so is a legal node. Unless it is known that this particular B-tree does not contain duplicate data, we must then also (recursively) delete the element in question from the new node.

In the second case, one of the two child nodes contains more than the minimum number of elements. Then a new separator for those subtrees must be found. Note that the largest element in the left subtree is the largest element which is still less than the separator. Likewise, the smallest element in the right subtree is the smallest element which is still greater than the separator. Both of those elements are in leaf nodes, and either can be the new separator for the two subtrees.

If the value is in an internal node, choose a new separator (either the largest element in the left subtree or the smallest element in the right subtree), remove it from the leaf node it is in, and replace the element to be deleted with the new separator.

This has deleted an element from a leaf node, and so is now equivalent to the previous case.

Data Structure Using ‘C‘ Assignment No: 02

1. Define Data structure? Explain its three comments.

Sol: - Data structure:- A data structure in computer science is a way of storing data in a computer so that it can be used efficiently. It is an organization of mathematical and logical concepts of data. Often a carefully chosen data structure will allow the most efficient algorithm to be used. The choice of the data structure often begins from the choice of an abstract data type. A well-designed data structure allows a variety of critical operations to be performed, using as few resources, both execution time and memory space, as possible. Data structures are implemented by a programming language as data types and the references and operations they provide.

Different kinds of data structures are suited to different kinds of applications, and some are highly specialized to certain tasks. For example, B-trees are particularly well-suited for implementation of databases, while networks of machines rely on routing tables to function.

In the design of many types of computer program, the choice of data structures is a primary design consideration. Experience in building large systems has shown that the difficulty of implementation and the quality and performance of the final result depends heavily on choosing the best data structure. After the data structures are chosen, the algorithms to be used often become relatively obvious. Sometimes things work in the opposite direction — data structures are chosen because certain key tasks have algorithms that work best with particular data structures. In either case, the choice of appropriate data structures is crucial.

This insight has given rise to many formalized design methods and programming languages in which data structures, rather than algorithms, are the key organizing factor. Most languages feature some sort of module system, allowing data structures to be safely reused in different applications by hiding their verified implementation details behind controlled interfaces. Object-oriented programming languages such as C++ and Java in particular use classes for this purpose.

Since data structures are so crucial, many of them are included in standard libraries of modern programming languages and APIs, such as C++'s containers, the Java Collections Framework, and the Microsoft .NET Framework.

The fundamental building blocks of most data structures are arrays, records, discriminated unions, and references. For example, the nullable reference, a reference which can be null, is a combination of references and discriminated unions, and the simplest linked data structure, the linked list, is built from records and nullable references.

Data structures represent implementations or interfaces: A data structure can be viewed as an interface between two functions or as an implementation of methods to access storage that is organized according to the associated data type.

2. Explain the pre and Post conditions with a suitable example.

3. Explain different Applications of stack.

In computer science, a stack is an abstract data type and data structure

based on the principle of Last In First Out (LIFO). Stacks are used

extensively at every level of a modern computer system. For example,

a modern PC uses stacks at the architecture level, which are used in

the basic design of an operating system for interrupt handling and

operating system function calls. Among other uses, stacks are used to

run a Java Virtual Machine, and the Java language itself has a class

called "Stack", which can be used by the programmer. The stack is

ubiquitous.

Application of stack

Expression evaluation and syntax parsing

Calculators employing reverse Polish notation use a stack structure to hold values. Expressions can be represented in prefix, postfix or infix notations. Convers

Expressions can be represented in prefix, postfix or infix notations. Conversion from one form of the expression to another form needs a stack. Many compilers use a stack for parsing the syntax of expressions, program blocks etc. before translating into low level code. Most of the programming languages are context-free languages allowing them to be parsed with stack based machines.

Runtime memory management

A number of programming languages are stack-oriented, meaning they define most basic operations (adding two numbers, printing a character) as taking their arguments from the stack, and placing any return values back on the stack. For example, PostScript has a return stack and an operand stack, and also has a graphics state stack and a dictionary stack.

Forth uses two stacks, one for argument passing and one for subroutine return addresses. The use of a return stack is extremely commonplace, but the somewhat unusual use of an argument stack for a human-readable programming language is the reason Forth is referred to as a stack-based language.

4. Write a note on Double Ended queues.

In computer science theory, a deque (short for double-ended queue—usually pronounced deck) is an abstract list type data structure, also called a head-tail linked list, for which elements can be added to or removed from the front (head) or back (tail).Deque is sometimes written dequeue, but this use is generally deprecated in technical literature or technical writing because dequeue is also a verb meaning "to remove from a queue". Nevertheless, several libraries and some writers, such as Aho, Hopcroft, and Ullman in their textbook Data Structures and Algorithms, spell it dequeue. DEQ and DQ are also used.

This differs from the queue abstract data type or First-In-First-Out List (FIFO), where elements can only be added to one end and removed from the other. This general data class has some possible sub-types:

An input-restricted deque is one where deletion can be made from both ends, but input can only be made at one end.

An output-restricted deque is one where input can be made at both ends, but output can be made from one end only.

Both the basic and most common list types in computing, the queues and stacks can be considered specializations of deques, and can be implemented using deques.

5. Write a ‘C’ program to implement deque using circular linked list.

Sol: - Program to implement deque using circular linked list:-

#include<stdio.h>

#include<conio.h>

#include<alloc.h>

#include<process.h>

struct node

{int info;

Struct node*link:

};

typedef struct node*NODE;

void main()

{NODE last;

int choice,item;

last=NULL;

for(;;)

{printf("1:Insert_Front,2:Insert_rear\n");

printf("3:Delet_Front,4:Delet_rear\n");

printf("5:Display,6:Exit\n");

printf("Enter the choice\n");

scanf("%d",choice);

switch(choice)

{case 1:

printf("Enter the item to be inserted\n");

scanf("%d",&item);

last=insert_front(item,last);

break;

case 2:

printf("Enter the item to be inserted\n");

scanf ("%d",item);

last=insert_rear(item,last);

break;

case 3:

case 4:

last=delet_rear(last)

break;

case 5:

displaya(last);

break;

case 6:

exit(0);

break;

default:

exit(0);

}}}

getch();

}

6. Explain various operations that can be performed on binary tree.

Sol:- A Binary tree is a tree in which no node have more than two sub tree. In other word A tree in which every parent has one or two children (but not more then that) is called as binary tree.

The root component of binary tree is the forefather of all children. But it can have only up to two children one right child and left child. These children can become fathers, grandfather, great grandfather and son.

The operations which can be on a binary tree is Insertion – Insert a given item into a tree Traversal – Visiting the nodes of the tree one by one. Search – Search for the specific item. Copying – To obtain exact copy of the given tree. Deletion – To delete a node from the tree.

7. Write a note on Binary Search Tree (BST).

In computer science, a binary search tree (BST) is a binary tree data structure which has the following properties:

each node (item in the tree) has a distinct value; both the left and right subtrees must also be binary search trees; the left subtree of a node contains only values less than the node's value; the right subtree of a node contains only values greater than or equal to the node's value.

The major advantage of binary search trees over other data structures is that the related sorting algorithms and search algorithms such as in-order traversal can be very efficient.

Binary search trees can choose to allow or disallow duplicate values, depending on the implementation.

Binary search trees are a fundamental data structure used to construct more abstract data structures such as sets, multisets, and associative arrays.

Searching a binary tree for a specific value can be a recursive or iterative process. This explanation covers a recursive method.

We begin by examining the root node. If the tree is null, the value we are searching for does not exist in the tree. Otherwise, if the value equals the root, the search is successful. If the value is less than the root, search the left subtree. Similarly, if it is greater than the root, search the right subtree. This process is repeated until the value is found or the indicated subtree is null. If the searched value is not found before a null subtree is reached, then the item must not be present in the tree.

8. Write a ‘C’ program to sort an array of 10 elements using Bubble sort

algorithm.

Sol: - Bubble sort algorithm

Input: list [] of N=10 items in random order

Output: list [] of N=10 items in sorted in ascending order.

1. SWAP=TRUE

PASS=0/

2. WHILE SWAP=TRUE DO

BEGIN

2.1 FOR I = 0 TO (N-PASS ) DO

BEGIN

2.1.1 IF A[I] > A[I+1]

BEGIN

TMP = A[I]

A[I] = A[I+1]

A[I+1] =TMP

SWAP = TRUE

END

ELSE

SWAP = FALSE

2.1.2 PASS=PASS+1

END

END

PROGRAM FOR BUBBLE SORT ALGORITHM:-

#include<stdio.h>

#include<conio.h>

void main()

{ int n,temp,i,j;

int arr[20];

clrscr();

printf("Enter no");

scanf("%d",&n);

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

{ printf("Enter the value in array : ");

scanf("%d",&arr[i]);

}

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

{ for(j=0;j<n;j++)

{

if (arr[i]>arr[j]);

{ temp=arr[i];

arr[i]=arr[j];

arr[j]=temp; }}}

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

printf("\n%d",arr[j]);

getch(); }