Data Structure

The data structure name indicates itself that organizing the data in memory. There are many ways of
organizing the data in the memory as we have already seen one of the data structures, i.e., array in C

The data structure is not any programming language like C, C++, java, etc. It is a set of algorithms that
we can use in any programming language to structure the data in the memory.

Basic Terminology

Data structures are the building blocks of any program or the software. Choosing the appropriate data
structure for a program is the most difficult task for a programmer. Following terminology is used as far as
data structures are concerned.

Data: Data can be defined as an elementary value or the collection of values, for example, student's name and
its id are the data about the student.

Group Items: Data items which have subordinate data items are called Group item, for example, name of a student
can have first name and the last name.

Record: Record can be defined as the collection of various data items, for example, if we talk about the student entity,
then its name, address, course and marks can be grouped together to form the record for the student.

File: A File is a collection of various records of one type of entity, for example, if there are 60 employees in the class,
then there will be 20 records in the related file where each record contains the data about each employee.

Attribute and Entity: An entity represents the class of certain objects. it contains various attributes. Each attribute
represents the particular property of that entity.

Field: Field is a single elementary unit of information representing the attribute of an entity.

Abstract Data Type in Data Structures

The Data Type is basically a type of data that can be used in different computer program. It signifies the type
like integer, float etc, the space like integer will take 4-bytes, character will take 1-byte of space etc.

The abstract datatype is special kind of datatype, whose behavior is defined by a set of values and set of operations.
The keyword “Abstract” is used as we can use these datatypes, we can perform different operations. But how those
operations are working that is totally hidden from the user. The ADT is made of with primitive datatypes, but operation
logics are hidden.

Some examples of ADT are Stack, Queue, List etc.

Let us see some operations of those mentioned ADT −

 Stack −
o isFull(), This is used to check whether stack is full or not
o isEmpry(), This is used to check whether stack is empty or not
o push(x), This is used to push x into the stack
 o pop(), This is used to delete one element from top of the stack
o peek(), This is used to get the top most element of the stack
o size(), this function is used to get number of elements present into the stack
 Queue −
o isFull(), This is used to check whether queue is full or not
o isEmpry(), This is used to check whether queue is empty or not
o insert(x), This is used to add x into the queue at the rear end
o delete(), This is used to delete one element from the front end of the queue
o size(), this function is used to get number of elements present into the queue
 List −
o size(), this function is used to get number of elements present into the list
o insert(x), this function is used to insert one element into the list
o remove(x), this function is used to remove given element from the list
o get(i), this function is used to get element at position i
o replace(x, y), this function is used to replace x with y value

 Abstract Data Type is a definition of new type, describes its properties and operations.
 Data Structure is an implementation of ADT. Many ADT can be implemented as the same Data Structure.

Types of Data Structures

There are two types of data structures:

o Primitive data structure

o Non-primitive data structure

Primitive Data structure

The primitive data structures are primitive data types. The int, char, float, double, and pointer are the primitive data
structures that can hold a single value.

Non-Primitive Data structure

The non-primitive data structure is divided into two types:

o Linear data structure

o Non-linear data structure

Linear Data Structure

The arrangement of data in a sequential manner is known as a linear data structure. The data structures used for this
purpose are Arrays, Linked list, Stacks, and Queues. In these data structures, one element is connected to only one
another element in a linear form.
Non linear data structure

When one element is connected to the 'n' number of elements known as a non-linear data structure. The best
example is trees and graphs. In this case, the elements are arranged in a random manner.

Major Operations

The major or the common operations that can be performed on the data structures are:

o Searching: We can search for any element in a data structure.

o Sorting: We can sort the elements of a data structure either in an ascending or descending order.
o Insertion: We can also insert the new element in a data structure.
o Updation: We can also update the element, i.e., we can replace the element with another element.
o Deletion: We can also perform the delete operation to remove the element from the data structure.

Advantages of Data structures

The following are the advantages of a data structure:

o Efficiency: If the choice of a data structure for implementing a particular ADT is proper, it makes the
program very efficient in terms of time and space.
o Reusability: The data structure provides reusability means that multiple client programs can use the data
structure.
o Abstraction: The data structure specified by an ADT also provides the level of abstraction. The client cannot
see the internal working of the data structure, so it does not have to worry about the implementation part.
The client can only see the interface.
o Data Structure Classification
o Linear Data Structures: A data structure is called linear if all of its elements are arranged in the linear order.

In linear data structures, the elements are stored in non-hierarchical way where each element has the

successors and predecessors except the first and last element.

o Types of Linear Data Structures are given below:

o Arrays: An array is a collection of similar type of data items and each data item is called an element of the

array. The data type of the element may be any valid data type like char, int, float or double.

o The elements of array share the same variable name but each one carries a different index number known as

subscript. The array can be one dimensional, two dimensional or multidimensional.

o The individual elements of the array age are:

o age[0], age[1], age[2], age[3],......... age[98], age[99].

o Linked List: Linked list is a linear data structure which is used to maintain a list in the memory. It can be seen

as the collection of nodes stored at non-contiguous memory locations. Each node of the list contains a

pointer to its adjacent node.

o Stack: Stack is a linear list in which insertion and deletions are allowed only at one end, called top.

o A stack is an abstract data type (ADT), can be implemented in most of the programming languages. It is

named as stack because it behaves like a real-world stack, for example: - piles of plates or deck of cards etc.

o Queue: Queue is a linear list in which elements can be inserted only at one end called rear and deleted only

at the other end called front.

o It is an abstract data structure, similar to stack. Queue is opened at both end therefore it follows First-In-

First-Out (FIFO) methodology for storing the data items.

o Non Linear Data Structures: This data structure does not form a sequence i.e. each item or element is

connected with two or more other items in a non-linear arrangement. The data elements are not arranged in

sequential structure.

o Types of Non Linear Data Structures are given below:

o Trees: Trees are multilevel data structures with a hierarchical relationship among its elements known as

nodes. The bottommost nodes in the herierchy are called leaf node while the topmost node is called root

node. Each node contains pointers to point adjacent nodes.

o Tree data structure is based on the parent-child relationship among the nodes. Each node in the tree can

have more than one children except the leaf nodes whereas each node can have atmost one parent except

the root node. Trees can be classfied into many categories which will be discussed later in this tutorial.

o Graphs: Graphs can be defined as the pictorial representation of the set of elements (represented by

vertices) connected by the links known as edges. A graph is different from tree in the sense that a graph can

have cycle while the tree can not have the one.

o Operations on data structure

o 1) Traversing: Every data structure contains the set of data elements. Traversing the data structure means

visiting each element of the data structure in order to perform some specific operation like searching or

sorting.

o Example: If we need to calculate the average of the marks obtained by a student in 6 different subject, we

need to traverse the complete array of marks and calculate the total sum, then we will devide that sum by

the number of subjects i.e. 6, in order to find the average.

o 2) Insertion: Insertion can be defined as the process of adding the elements to the data structure at any

location.

o If the size of data structure is n then we can only insert n-1 data elements into it.

o 3) Deletion:The process of removing an element from the data structure is called Deletion. We can delete an

element from the data structure at any random location.

o If we try to delete an element from an empty data structure then underflow occurs.

o 4) Searching: The process of finding the location of an element within the data structure is called Searching.

There are two algorithms to perform searching, Linear Search and Binary Search. We will discuss each one of

them later in this tutorial.

 o 5) Sorting: The process of arranging the data structure in a specific order is known as Sorting. There are

many algorithms that can be used to perform sorting, for example, insertion sort, selection sort, bubble sort,

etc.

o 6) Merging: When two lists List A and List B of size M and N respectively, of similar type of elements,
clubbed or joined to produce the third list, List C of size (M+N), then this process is called merging

What is an Algorithm
An algorithm is a process or a set of rules required to perform calculations or some other problem-solving
operations especially by a computer. The formal definition of an algorithm is that it contains the finite set of
instructions which are being carried in a specific order to perform the specific task. It is not the complete program or
code; it is just a solution (logic) of a problem, which can be represented either as an informal description using a
Flowchart or Pseudocode.

Characteristics of an Algorithm

The following are the characteristics of an algorithm:

o Input: An algorithm has some input values. We can pass 0 or some input value to an algorithm.

o Output: We will get 1 or more output at the end of an algorithm.

o Unambiguity: An algorithm should be unambiguous which means that the instructions in an algorithm

should be clear and simple.

o Finiteness: An algorithm should have finiteness. Here, finiteness means that the algorithm should contain a

limited number of instructions, i.e., the instructions should be countable.

o Effectiveness: An algorithm should be effective as each instruction in an algorithm affects the overall
process.

o Language independent: An algorithm must be language-independent so that the instructions in an

algorithm can be implemented in any of the languages with the same output.

Dataflow of an Algorithm

o Problem: A problem can be a real-world problem or any instance from the real-world problem for which we
need to create a program or the set of instructions. The set of instructions is known as an algorithm.

o Algorithm: An algorithm will be designed for a problem which is a step by step procedure.

o Input: After designing an algorithm, the required and the desired inputs are provided to the algorithm.
 o Processing unit: The input will be given to the processing unit, and the processing unit will produce the

desired output.

o Output: The output is the outcome or the result of the program.

o The following are the steps required to add two numbers entered by the user:
o Step 1: Start
o Step 2: Declare three variables a, b, and sum.
o Step 3: Enter the values of a and b.
o Step 4: Add the values of a and b and store the result in the sum variable, i.e., sum=a+b.
o Step 5: Print sum

Approaches of Algorithm

The following are the approaches used after considering both the theoretical and practical importance of
designing an algorithm:

o Brute force algorithm: The general logic structure is applied to design an algorithm. It is also known as an
exhaustive search algorithm that searches all the possibilities to provide the required solution. Such
algorithms are of two types:

1. Optimizing: Finding all the solutions of a problem and then take out the best solution or if the

value of the best solution is known then it will terminate if the best solution is known.

2. Sacrificing: As soon as the best solution is found, then it will stop.

o Divide and conquer: It is a very implementation of an algorithm. It allows you to design an algorithm in a
step-by-step variation. It breaks down the algorithm to solve the problem in different methods. It allows you
to break down the problem into different methods, and valid output is produced for the valid input. This
valid output is passed to some other function.

o Greedy algorithm: It is an algorithm paradigm that makes an optimal choice on each iteration with the
hope of getting the best solution. It is easy to implement and has a faster execution time. But, there are very
rare cases in which it provides the optimal solution.

o Dynamic programming: It makes the algorithm more efficient by storing the intermediate results. It follows
five different steps to find the optimal solution for the problem:

1. It breaks down the problem into a subproblem to find the optimal solution.

2. After breaking down the problem, it finds the optimal solution out of these subproblems.

3. Stores the result of the subproblems is known as memorization.

4. Reuse the result so that it cannot be recomputed for the same subproblems.

5. Finally, it computes the result of the complex program.

 o Branch and Bound Algorithm: The branch and bound algorithm can be applied to only integer

programming problems. This approach divides all the sets of feasible solutions into smaller subsets. These
subsets are further evaluated to find the best solution.

o Randomized Algorithm: As we have seen in a regular algorithm, we have predefined input and required
output. Those algorithms that have some defined set of inputs and required output, and follow some
described steps are known as deterministic algorithms. What happens that when the random variable is
introduced in the randomized algorithm?. In a randomized algorithm, some random bits are introduced by
the algorithm and added in the input to produce the output, which is random in nature. Randomized
algorithms are simpler and efficient than the deterministic algorithm.

o Backtracking: Backtracking is an algorithmic technique that solves the problem recursively and removes the
solution if it does not satisfy the constraints of a problem.

The major categories of algorithms are given below:

o Sort: Algorithm developed for sorting the items in a certain order.

o Search: Algorithm developed for searching the items inside a data structure.

o Delete: Algorithm developed for deleting the existing element from the data structure.

o Insert: Algorithm developed for inserting an item inside a data structure.

o Update: Algorithm developed for updating the existing element inside a data structure.

Algorithm Analysis

The algorithm can be analyzed in two levels, i.e., first is before creating the algorithm, and second is after creating the
algorithm. The following are the two analysis of an algorithm:

o Priori Analysis: Here, priori analysis is the theoretical analysis of an algorithm which is done before
implementing the algorithm. Various factors can be considered before implementing the algorithm like
processor speed, which has no effect on the implementation part.

o Posterior Analysis: Here, posterior analysis is a practical analysis of an algorithm. The practical analysis is

achieved by implementing the algorithm using any programming language. This analysis basically evaluate
that how much running time and space taken by the algorithm.

Algorithm Complexity

The performance of the algorithm can be measured in two factors:

 o Time complexity: The time complexity of an algorithm is the amount of time required to complete the
execution. The time complexity of an algorithm is denoted by the big O notation. Here, big O notation is the
asymptotic notation to represent the time complexity. The time complexity is mainly calculated by counting
the number of steps to finish the execution. Let's understand the time complexity through an example.

1. sum=0;
2. // Suppose we have to calculate the sum of n numbers.
3. for i=1 to n
4. sum=sum+i;
5. // when the loop ends then sum holds the sum of the n numbers
6. return sum;

In the above code, the time complexity of the loop statement will be atleast n, and if the value of n increases, then the
time complexity also increases. While the complexity of the code, i.e., return sum will be constant as its value is not
dependent on the value of n and will provide the result in one step only. We generally consider the worst-time
complexity as it is the maximum time taken for any given input size.

o Space complexity: An algorithm's space complexity is the amount of space required to solve a problem and
produce an output. Similar to the time complexity, space complexity is also expressed in big O notation.

For an algorithm, the space is required for the following purposes:

1. To store program instructions

2. To store constant values

3. To store variable values

4. To track the function calls, jumping statements, etc.

Auxiliary space: The extra space required by the algorithm, excluding the input size, is known as an auxiliary space.
The space complexity considers both the spaces, i.e., auxiliary space, and space used by the input.

So,

Space complexity = Auxiliary space + Input size.

Types of Algorithms

The following are the types of algorithm:

 o Search Algorithm

o Sort Algorithm

Search Algorithm

On each day, we search for something in our day to day life. Similarly, with the case of computer, huge data is stored
in a computer that whenever the user asks for any data then the computer searches for that data in the memory and
provides that data to the user. There are mainly two techniques available to search the data in an array:

o Linear search

o Binary search

Linear Search

Linear search is a very simple algorithm that starts searching for an element or a value from the beginning of an array
until the required element is not found. It compares the element to be searched with all the elements in an array, if
the match is found, then it returns the index of the element else it returns -1. This algorithm can be implemented on
the unsorted list.

Binary Search

A Binary algorithm is the simplest algorithm that searches the element very quickly. It is used to search the element
from the sorted list. The elements must be stored in sequential order or the sorted manner to implement the binary
algorithm. Binary search cannot be implemented if the elements are stored in a random manner. It is used to find the
middle element of the list.

Sorting Algorithms

Sorting algorithms are used to rearrange the elements in an array or a given data structure either in an ascending or
descending order. The comparison operator decides the new order of the elements.

Big oh Notation (O)

o Big O notation is an asymptotic notation that measures the performance of an algorithm by simply providing
the order of growth of the function.

o This notation provides an upper bound on a function which ensures that the function never grows faster

than the upper bound. So, it gives the least upper bound on a function so that the function never grows
faster than this upper bound.
It is the formal way to express the upper boundary of an algorithm running time. It measures the worst case of time
complexity or the algorithm's longest amount of time to complete its operation. It is represented as shown below:

For example:

If f(n) and g(n) are the two functions defined for positive integers,

then f(n) = O(g(n)) as f(n) is big oh of g(n) or f(n) is on the order of g(n)) if there exists constants c and no such
that:

f(n)≤c.g(n) for all n≥no

This implies that f(n) does not grow faster than g(n), or g(n) is an upper bound on the function f(n). In this case, we are
calculating the growth rate of the function which eventually calculates the worst time complexity of a function, i.e.,
how worst an algorithm can perform.

Let's understand through examples

Example 1: f(n)=2n+3 , g(n)=n

Now, we have to find Is f(n)=O(g(n))?

To check f(n)=O(g(n)), it must satisfy the given condition:

f(n)<=c.g(n)

First, we will replace f(n) by 2n+3 and g(n) by n.

2n+3 <= c.n

Let's assume c=5, n=1 then

2*1+3<=5*1

5<=5

For n=1, the above condition is true.

If n=2

2*2+3<=5*2

7<=10

For n=2, the above condition is true.

We know that for any value of n, it will satisfy the above condition, i.e., 2n+3<=c.n. If the value of c is equal to 5, then
it will satisfy the condition 2n+3<=c.n. We can take any value of n starting from 1, it will always satisfy. Therefore, we
can say that for some constants c and for some constants n0, it will always satisfy 2n+3<=c.n. As it is satisfying the
above condition, so f(n) is big oh of g(n) or we can say that f(n) grows linearly. Therefore, it concludes that c.g(n) is the
upper bound of the f(n). It can be represented graphically as:
The idea of using big o notation is to give an upper bound of a particular function, and eventually it leads to give a
worst-time complexity. It provides an assurance that a particular function does not behave suddenly as a quadratic or
a cubic fashion, it just behaves in a linear manner in a worst-case.