In case of large voluminous data, every byte of space is important and plays a major factor in determining the cost of the resources.

Programs that are run on computer systems will use variables that are stored in main memory for manipulation of data.

When a variable is defined, a calculated amount of contiguous space is allocated to the variable, depending on its type.

Compaction:- is the process of eliminating waste spaces so that there is no block of memory unusable.

Disadvantages:
The programs performing operations on memory are suspended while compaction is performed

Reallocation Method
——————————-
First fit method: In the first-fit method, each block from the beginning is searched for a free block. The requested block of memory is allocated in the first possible free block.

freeblock *alloc,*y;
x = fbhead;
y = NULL;
alloc = NULL;
while( (x != NULL) && (x->size < n) )
{
y = x;
x = x->next;
}
if( x != NULL )
{ s = x->size;
alloc = x + s – n;
if( s == n )
if( y == NULL )
fbhead = x->next;
else
y->next = x->next;
else
x->size = s – n;
}

Best fit method: In the best-fit method, the entire list of free blocks is traversed and the smallest free block where allocation can be done is found out.

freeblock *alloc,*y;
x = fbhead;
y = NULL;
z = NULL;
alloc = NULL;
bz = NULL;
zsize = MAXMEM + 1;
if( z != NULL )
{
alloc = z + zsize – n;
if( zsize == n )
if( bz == NULL )
fbhead = z->next;
else
bz->next = z->next;
else
z->size = zsize – n;
}

Garbage collection
—————————-
Two phases of garbage collection are:
-Marking phase
-Collection phase

Marking phase: A node is marked if it can be accessed from a given pointer. The nodes in the memory are sequentially checked.

If there are any nodes that can be accessed
from the current node, then the nodes are all marked.
In case the second node’s address is less than the
previous node, the process continues from the second
node. The process continues until all nodes are marked.

Node structure created for the example of Marking
Phase

struct listnode
{
int info;
int mark;
int next;
}list [50];
int arptr[10];
for( i=0; i<10 ; i++)
list[ arptr[i] ].mark = TRUE;
i = 1;
while( i < 50 )
{
k = i + 1;
if( list[i].mark )
{
if( list[ list[i].next].mark != TRUE )
{
list[ list[i].next].mark = TRUE;
if( list[i].next < k )
k = list[i].next;
}
}
i = k;
}

Collection phase: After the required nodes are marked, the collection phase begins. In the collection phase all the nodes that are not marked are added to a separate list. Then the space allocated for these nodes are reclaimed and assigned to newer nodes.

for( i = 0; i< 50; i++ )
{
if( list[i].mark != TRUE )
{
list[i].next = glist;
glist = i;
}
list[i].mark = FALSE;
}
The Big O Notation: is a popular mathematical tool used to calculate time complexities for different algorithms.
The Big O notation is represented as:
f(n) = O( g((n) )
f(n) – the computing time of the algorithm when
it is run for an input size of n.
g(n) – standard function, whose value is
determined prior to the execution of the algorithm.

Standard functions
——————————-
n: An algorithm having a time complexity of order n, is said to be linear. The time taken is said to be linearly proportional to n.
n2: The algorithm is said to be quadratic if the time complexity is of order n2.
n3: If the time complexity of an algorithm is of order n3, then the algorithm is said to be cubic.
Log n: If the time complexity of an algorithm matches the function log n, then the algorithm is said to be logarithmic.
nlogn: If the time complexity of an algorithm is n log n, then it can be said that the algorithm solves a problem by breaking it into smaller sub-problems and solving them independently.

Conclusion:
When a variable is defined, a calculated amount of contiguous space is allocated to the variable
Collecting unused space towards on one end in memory is called compaction
A pointer is used to store the first location of the free block initially
The disadvantage of compaction is the programs performing operations on memory are suspended, while compaction is performed

A linear list is used to keep track of list of free blocks
The process of detecting unused nodes and collecting them together is known as Garbage Collection
Garbage collection is done in two phases – marking phase and collection phase
The garbage collection routine is called when there are only few spaces left in memory

The post Storage Management appeared first on .

Files and Records: A record is a collection of related information and Collection of records is called a file.

Ordered and unordered
———————————–
Unordered– There is no relation between the records

Ordered –The keys are ordered in a specific fashion to enhance searching.

Keys: Specific field in a record to differentiate each record

Internal and External searches

1. Internal search –When the searching is performed the entire database or table is copied to the main memory.

2. External search– When only a part of database is copied to the main memory due to huge size of database.

Sequential search
———————————–
Simple and easiest method to implement.
The key field in each record is compared with the given key value starting from the first record. If there is a match the index of the key field is returned.

int seqSearch( int key, int array[ ], int n )
{

for ( int i=0; i<n; i++ )
if ( array[i] == key )
return i;
return -1;
}
Sequential search on a sorted array
——————————————————————-
Sequential search if applied on a sorted array reduces the number of comparisons if some modifications are made.

This is faster than the ordinary sequential searches.

Sequential search on a sorted array
—————————————————-
int seqSearchsorted( int key, int array[ ], int n )
{
for ( int i=0; i<n; i++ )
{
if ( array[i] == key )
return i;
else if( array[i] > key )
return -1;
}
}

Indexed sequential search
—————————————-
Procedure: The index table and the records must be sorted on the key. Not all keys are indexed in to the index table. The record table is divided equally and the key in the record, in the beginning of each division along with a pointer to that record is entered in to the index table.

int indseqSearch( int key, int indexsize, int indtable[ ], int *indpointer[ ] int array[ ] )
{
int llimit,hlimit;
for( int i=0; indtable[i] <= key && i<indexsize; i++);
llimit = (i==0) ? 0 : indpointer[i-1];
hlimit = (i==indexsize) ? n-1 : indpointer[i-1];
for( int llimit; j <= hlimit && array[j] != key; j++);
return ( ( j > hlimit ) ? -1 : j );
}
Advantages: Fastest search among all

Disadvantages: Uses an extra table to store indexes,which may consume spaces for large databases.

Binary search Technique
—————————————
Procedure: The given sorted records are divided into two halves. The key is first compared with the key field of the middle record. If a match is found, the key index is returned. If it does not match, then required key must be either in the lower or upper half. If the key is less than the key field of the middle record, the key is searched in the lower half otherwise it is checked in the upper half.

int binsearch(int records[], int key, int llimit, int hlimit)
{
int middle;
if( llimit > hlimit)
return (-1);
middle = (llimit + hlimit) / 2;
if( key == records[middle] )
return (middle);
else
{
if( key < records[middle] )
return (binsearch( records, key , llimit ,middle – 1) );
else
return (binsearch( records, key, middle + 1, hlimit) );
}
}

Advantages of Binary search: Most effective technique applied on sorted arrays.

Disadvantages: Cannot be implemented on unsorted array.

Hashing: Process to develop a hash function to determine where the records can be stored
Example : r=h(k)
h(k)- Hash function
k – Key
r – an offset when added to the starting address of the block of memory, where the records are to be stored, yields the particular record.

Properties of Hashing: Any hash function developed should return a unique value Must be able to minimize the number of collisions.

Hash collision: If the hash function returns the same value for two different records it is called hash collisions.

Mid square method: In this method, the key is squared first. Then required number of digits is chosen from the middle of the squared number. The number of digits to be chosen depends on the size of the record.

Resolving Hash Collisions
———————————-
Methods for minimizing the collisions
Open address method
Method of finding the next available space to store the record
Also known as rehashing

The two types of probing are
Linear Probing
Quadratic probing

Double Hashing: Solves the problem of double clustering
Two hashing methods used h1(k) and h2(k)-One is primary and the other is secondary.

click here for sorting technique

The post Searching techniques appeared first on .

Definition of an AVL tree: An AVL tree is a binary search tree which has the following properties:

1. The sub-trees of every node differ in height by at most one.
2. Every sub-tree is an AVL tree.

Named after their inventors, Adelson-Velskii and Landis, they were the first dynamically balanced trees to be proposed.

Features of AVL Trees
——————————–

AVL Trees are derived from binary search trees by applying one condition; the difference of height between the left and right sub-trees should not exceed 1.
These types of binary trees are also called Balanced binary trees.

The balance factor can have values of –1, 0 and 1. If the balance factor holds any other values, then it is not considered as an AVL tree. The three values given above represent different conditions of AVL trees. They are –
1. balance = -1: the height of the left sub-tree of the current node is less than its right sub-tree by 1.
2. balance = 0: the heights of the left and right sub-trees of the current node are equal
3. balance = 1: the height of the left sub-tree is one more than the right sub-tree

Representation of AVL Trees
——————————————
struct AVL
{
struct AVL *left;
int value;
struct AVL *right;
int balance;
};
Insertion of a Node
———————————-
Inserting a node in an AVL tree is similar to the binary search tree.

To balance a tree, an operation called rotation is performed
Inserting a node may change the balancing factor of other nodes and thus may not satisfy the conditions of the AVL tree.

To balance a tree, an operation called rotation is performed.
To rotate the tree about a node is to move the nodes either left or right so that the inorder traversal remains the same.
Deletion of a node
——————————
The deletion performed on a node in AVL tree is the same as that of the deletion process of the Binary search tree.

First the node to be deleted is searched using the binary search method.

The node is deleted and other nodes are adjusted to maintain the inorder traversal.

After the node is deleted, balancing operation is performed which is the same as of that done during the insertion operation.
Definition of a B tree
————————————
A B-tree is a data structure that maintains an ordered set of data and allows efficient operations to find, delete, insert, and browse the data. In this discussion, each piece of data stored in a B-tree will be called a “key”, because each key is unique and can occur in the B-tree in only one location

Representation of B Trees
————————————-
struct Bnode
{
int n;
int value[MAX + 1];
struct Bnode *child[MAX + 1];
};
Operations on B-Trees
———————————-
When the tree is large and stored in secondary storage medium, the searching operation may consume time.

One way of reducing the time is to take up many nodes for comparison. As a result Multi-way search trees were developed.

1. Insertion operation in B-tree

2. Deletion process in B-tree

Insertion operation in B-tree: To insert a value in a B-tree, the node in the tree after which it can be inserted is searched first. Once the node is found, insertion process begins.

Deletion operation in B-tree: To delete a node, first the value to be deleted is searched. Once the node, which contains the value, is found the deletion process starts. There are some conditions that has to be taken care after deleting a node.
Conditions on Deletions
——————————–
When the number of values in the current node is greater or equal to the minimum number the node has to hold. In this case, the deletion of the node does not violate the conditions for the B-tree

When the number of values in the current node is less than the minimum number the node has to hold. Here the tree has to be adjusted so that the conditions for the B-tree is not violated.

Introduction to Trees [data structure]

The post Data structure – Advanced Trees appeared first on .

Creating and Managing Linked Lists
————————————————–
List generally refers to a sequential organization of items like an array.
Array allocates memory of size, which we determine in the beginning itself. Later this can be used for storing values.
A linked list is a chain of structures in memory. These structures contain data as well as a pointer to the next logical structure in the list

struct list {
datatype data;
………
………
struct list *next;
/* next is a pointer of type struct list, pointing to the next logical structure in the list */
};
Advantages of Linked Lists
———————————————–
Linked lists have several advantages over arrays-
One does not have to decide on the number of items in the linked list.

This is because memory can be allocated dynamically as and when a node is added to the list.

Types of Linked Lists
————————————
There are several types of linked lists, two of which will be discussed in this chapter –
Singly Linked List – each node contains the address of the next node in the list. The start node points to the first node in the list.

Doubly Linked List – each node contains the address of the next node as well as the previous node in the list. The start node points to the first node in the list whereas the end node points to the last node.

Singly Linked Lists
——————————-
The operations that can be performed on singly linked lists are listed below –
Creation of a list
Insertion of nodes
Traversal of the list
Search of a specific node
Modification of a node
Deletion of a node
Insertion in a list
——————————–
Assuming that a node has to be inserted at the beginning of an existing linked list, the following steps has to be performed :
Initialize, allocate memory and accept data into a node, let this node be called new.
Make new’s next point to what start is pointing to, i.e., the first node in the list. This can be done by new->next = start;
Make start point to new (i.e., make it the first node). This can be done by start=new;

Creation of a Singly Linked List
———————————————
This involves two steps :
Creating a new node (allocate memory for the node and accept data into it).
Storing the address of the node created in start. start=new;

Traversing a Linked List
———————————
This involves the following steps:
Set list_ptr to start (assume that list_ptr is a pointer declared of type struct list).
Print the information part of the node.
Advance the pointer so that it points to the next node. This can be done by list_ptr=list_ptr->next;
Repeat steps 2 and 3 until list_ptr is equal to NULL.

list_ptr=start;
while(list_ptr)
{
printf(“ %c”, list_ptr->information);
list_ptr=list_ptr->next;
}

Searching in a Linked List
—————————————-
Linked lists can be of two types –
Sorted
Unsorted
Searching in a linked list involves traversing the list until the required node is reached.
Modification in a linked list involves –
Searching for the node to be modified.
Changing the information part of the node.

Deletion in a Singly Linked List
———————————————-
For deleting a node at the beginning of a list, the steps involved are –
Set ptr to start.
Set start to point to what ptr’s next is pointing to start=ptr->next;
Free the memory occupied by the node free(ptr);
Doubly Linked Lists
————————————
A Doubly Linked List is just an extension of the concept of a singly linked list. Each node in a doubly linked list has an information part and two pointers – one pointing to the next node and one to the previous node.

Representing Doubly Linked Lists in C
Doubly Linked Lists are represented in C in the same manner in which singly linked lists are.
struct dlist {
datatype data;
………
………
struct dlist *next;
struct dlist *prior;
};

Traversal in a Doubly Linked List
————————————————–
Traversal in a doubly linked list can be done in two directions –
Start from the beginning of the list to the end of the list.
Start from the last node and traverse in the opposite direction to the first node.

Circular Linked Lists
—————————————
A circular linked list is obtained by modifying the link of the last node in a linked list.
The main drawback of circular lists is that a node can be accessed from a given node by traversing through the list.

Implementing Stacks
————————————
A Stack is a data structure in which insertions and deletions are restricted to one end called Top.
Stacks are also called Last-In-First-Out (LIFO) lists because they come out in the reverse order in which they go in

The post List-Stack-Queues appeared first on .

• A data structure is a logical method of representing data in memory.
• Data structure is strictly described as an instance of an Abstract Data Type (ADT).
• An Abstract Data Type is defined as a mathematical model of a user-defined type along with the operations performed on that model.

Algorithm

An algorithm can be described as sequence of steps or instructions required to solve a given problem.

It is a finite set of instructions written to accomplish a particular task.

When designing an algorithm, one must ensure that the

algorithm adheres to the following criteria:

Input: Some input data (can be empty in some cases) externally supplied to the algorithm

Output: At least one output is produced

Finiteness: The algorithm must terminate after finite number of steps

Definiteness: The instructions must be clear and unambiguous

Effectiveness: Every instruction must be basic enough to be carried out on paper

Following are certain points to be considered

while writing an algorithm :

Representing an algorithm.

Designing an algorithm.

Analyzing an algorithm.

Algorithm Analysis

Algorithm Analysis involves comparing different algorithms written for a specific problem. All the algorithms are compared for their space and time complexities.

Space complexity: It refers to the amount of storage the algorithm consumes.

Time complexity: It is the time required by the algorithm for execution.

Following are the different types of time complexities:

Best-case time complexity: It is the measure of minimum time required for an algorithm to execute for a known input size.

Average case time complexity: Average time complexity is the measure of time an algorithm will require to execute, for a typical input data size. This method requires statistical calculations.

Worst-case time complexity: It is the measure of maximum time required for an algorithm to execute for a known input size.

The post Data structure and algorithm appeared first on .