Algorithm is a stepbystep procedure, which defines a set of instructions to be executed in a certain order to get the desired output. Algorithms are generally created independent of underlying languages, i.e., an algorithm can be implemented in more than one programming language.
Before starting my video I hope you have already subscribed
to my channel, if not then subscribe now and press the bell icon to stay updated
with our upcoming exciting videos.
From the data structure point of view, the following are some
important categories of algorithms 
·
Search
 Algorithm to search an item in a data structure.
·
Sort
 Algorithm to sort items in a certain order.
·
Insert
 Algorithm to insert an item in a data structure.
·
Update
 Algorithm to update an existing item in a data structure.
·
Delete
 Algorithm to delete an existing item from a data structure.
Characteristics of an Algorithm
Not all procedures can be called an algorithm. An algorithm
should have the following characteristics 
·
Unambiguous
 Algorithm should be clear and unambiguous. Each of its steps (or phases), and
their inputs/outputs should be clear and must lead to only one meaning.
·
Input
 An algorithm should have 0 or more welldefined inputs.
·
Output
 An algorithm should have 1 or more welldefined outputs and should match the
desired output.
·
Finiteness
 Algorithms must terminate after a finite number of steps.
·
Feasibility
 Should be feasible with the available resources.
·
Independent
 An algorithm should have stepbystep directions, which should be independent
of any programming code.
How to Write an Algorithm?
There are no welldefined standards for writing algorithms.
Rather, it is a problem and resourcedependent. Algorithms are never written to
support a particular programming code.
As we know that all programming languages share basic code
constructs like loops (do, for, while), flowcontrol (ifelse), etc. These
common constructs can be used to write an algorithm.
We write algorithms in a stepbystep manner, but it is not
always the case. Algorithm writing is a process and is executed after the
problem domain is welldefined. That is, we should know the problem domain, for
which we are designing a solution.
Example
Let's try to learn algorithmwriting by using an example.
Problem  Design an algorithm to add two numbers and display the result.

Algorithms tell the programmers how to code the program. Alternatively, the algorithm can be written as 

In the design and analysis of algorithms, usually, the second method is used to describe an algorithm. It makes it easy for the analyst to
analyze the algorithm ignoring all unwanted definitions. He can observe what
operations are being used and how the process is flowing.
Writing step numbers is optional.
We design an algorithm to get a solution to a given problem.
A problem can be solved in more than one way.
Hence, many solution algorithms can be derived for a given
problem. The next step is to analyze those proposed solution algorithms and
implement the best suitable solution.
Algorithm Analysis
The efficiency of an algorithm can be analyzed at two different stages, before implementation, and after implementation. They are the following 
 A Priori Analysis  This is a theoretical analysis of an algorithm. The efficiency of an algorithm is measured by assuming that all other factors, for example, processor speed, are constant and have no effect on the implementation.
 A Posterior Analysis  This is an empirical analysis of an algorithm. The selected algorithm is implemented using a programming language. This is then executed on the target computer machine. In this analysis, actual statistics like running time and space required, are collected.
We shall learn about a priori algorithm analysis. Algorithm
analysis deals with the execution or running time of various operations involved.
The running time of an operation can be defined as the number of computer
instructions executed per operation. Algorithm Complexity
Suppose X is an algorithm and n is the size of input data,
the time and space used by the algorithm X are the two main factors, which
decide the efficiency of X.
 Time Factor  Time is measured by counting the number of key operations such as comparisons in the sorting algorithm.
 Space Factor  Space is measured by counting the maximum memory space required by the algorithm.
The complexity of an algorithm f(n) gives the running time and/or the storage space required
by the algorithm in terms of n as the size of input data.
Space Complexity
The space complexity of an algorithm represents the amount of
memory space required by the algorithm in its life cycle. The space required by
an algorithm is equal to the sum of the following two components 
A fixed part is a space required to store certain data
and variables that are independent of the size of the problem. For example,
simple variables and constants used, program size, etc.
A variable part is a space required by variables, whose size
depends on the size of the problem. For example, dynamic memory allocation,
recursion stack space, etc.
Space complexity S(P) of any algorithm P is S(P) = C + SP(I), where
is the fixed part and S(I) is the
variable part of the algorithm, which depends on instance characteristic I.
Following is a simple example that tries to explain the concept 

Here we have three variables A, B, and C, and one constant.
Hence S(P) = 1 + 3. Now, space depends on data types of given variables and
constant types and it will be multiplied accordingly.
Time Complexity
The time complexity of an algorithm represents the amount of
time required by the algorithm to run to completion. Time requirements can be
defined as a numerical function T(n),
where T(n) can be measured as the
number of steps, provided each step consumes constant time.
For example, the addition of two nbit integers takes n steps.
Consequently, the total computational time is T(n) = c*n, where c is the time taken for the addition of two bits.
Here, we observe that T(n) grows
linearly as the input size increases.
Post a Comment
If you have any doubts or any queries you can specify here.