Hashing is a technique to convert a range of key values into a range of
indexes of an array. By using hash tables, we can create an associative
data storage where data index can be find by providing its key values.
Tower of Hanoi, is a mathematical puzzle which consists of three tower
(pegs) and more than one rings. All rings are of different size and
stacked upon each other where the large disk is always below the small
disk. The aim is to move the tower of disk from one peg to another,
without breaking its properties.
A recursive function is one which calls itself, directly or calls a
function that in turn calls it. Every recursive function follows the
recursive properties − base criteria where functions stops calling itself and progressive approach where the functions tries to meet the base criteria in each iteration.
Heap is a special balanced binary tree data structure where root-node
key is compared with its children and arranged accordingly. A min-heap, a
parent node has key value less than its childs and a max-heap parent
node has value greater than its childs.
This algorithm treats the graph as a forest and every node it as an
individual tree. A tree connects to another only and only if it has
least cost among all available options and does not violate MST
properties.
A spanning tree is a subset of Graph G, which has all the vertices
covered with minimum possible number of edges. A spanning tree does not
have cycles and it can not be disconnected.
AVL trees are height balancing binary search tree. AVL tree checks
the height of left and right sub-trees and assures that the difference
is not more than 1. This difference is called Balance Factor.
Tree traversal is a process to visit all the nodes of a tree.
Because, all nodes are connected via edges (links) we always start from
the root (head) node. There are three ways which we use to traverse a
tree −
A binary search tree is a binary tree with a special provision where a
node's left child must have value less than its parent's value and
node's right child must have value greater than it's parent value
Breadth First Search algorithm(BFS) traverses a graph in a breadthwards
motion and uses a queue to remember to get the next vertex to start a
search when a dead end occurs in any iteration.
Depth First Search algorithm(DFS) traverses a graph in a depthward
motion and uses a stack to remember to get the next vertex to start a
search when a dead end occurs in any iteration.
A graph is a pictorial representation of a set of objects where some
pairs of objects are connected by links. The interconnected objects are
represented by points termed as vertices, and the links that connect the
vertices are called edges.
Quick sort uses divide and conquer approach. It divides the list in
smaller 'partitions' using 'pivot'. The values which are smaller than
the pivot are arranged in the left partition and greater values are
arranged in the right partition. Each partition is recursively sorted
using quick sort.
Shell sort can be said a variant of insertion sort. Shell sort divides the list into smaller sublist based on some gap variable and then each sub-list is sorted using insertion sort. In best cases, it can perform upto Ο(n log n).
Merge sort is sorting algorithm based on divide and conquer programming
approach. It keeps on dividing the list into smaller sub-list until all
sub-list has only 1 element. And then it merges them in a sorted way
until all sub-lists are consumed. It has run-time complexity of Ο(n log
n) and it needs Ο(n) auxiliary space.
Both sorting techniques maintains two sub-lists, sorted and unsorted and
both take one element at a time and places it into sorted sub-list.
Insertion sort works on the current element in hand and places it in the
sorted array at appropriate location maintaining the properties of
insertion sort. Whereas, selection sort searches the minimum from the
unsorted sub-list and replaces it with the current element in hand.
Selection sort is in-place sorting technique. It divides the data set
into two sub-lists: sorted and unsorted. Then it selects the minimum
element from unsorted sub-list and places it into the sorted list. This
iterates unless all the elements from unsorted sub-list are consumed
into sorted sub-list.
Insertion sort divides the list into two sub-list, sorted and unsorted.
It takes one element at time and finds it appropriate location in sorted
sub-list and insert there. The output after insertion is a sorted
sub-list. It iteratively works on all the elements of unsorted sub-list
and inserts them to sorted sub-list in order
Bubble sort is comparison based algorithm in which each pair of adjacent
elements is compared and elements are swapped if they are not in order.
Because the time complexity is Ο(n2), it is not suitable for large set of data.
A binary search works only on sorted lists or arrays. This search
selects the middle which splits the entire list into two parts. First
the middle is compared.
This search first compares the target value to the mid of the list. If it is not found, then it takes decision on whether.
Linear search tries to find an item in a sequentially arranged data
type. These sequentially arranged data items known as array or list, are
accessible in incrementing memory location. Linear search compares
expected data item with each of data items in list or array.
The average
case time complexity of linear search is Ο(n) and worst case complexity
is Ο(n2). Data in target arrays/lists need not to be sorted.
As queues follows FIFO method, they are used when we need to work on
data-items in exact sequence of their arrival. Every operating system
maintains queues of various processes. Priority queues and breadth first
traversal of graphs are some examples of queues.
Queue is an abstract data structure, somewhat similar to stack. In
contrast to stack, queue is opened at both end. One end is always used
to insert data (enqueue) and the other is used to remove data (dequeue).
Queue follows First-In-First-Out methodology, i.e., the data item
stored first will be accessed first.
Stacks follows LIFO method and addition and retrieval of a data item
takes only Ο(n) time. Stacks are used where we need to access data in
the reverse order or their arrival. Stacks are used commonly in
recursive function calls, expression parsing, depth first traversal of
graphs etc.
A linked-list is a list of data-items connected with links i.e. pointers
or references. Most modern high-level programming language does not
provide the feature of directly accessing memory location, therefore,
linked-list are not supported in them or available in form of inbuilt
functions.
A linear data-structure has sequentially arranged data items. The next
time can be located in the next memory address. It is stored and
accessed in a sequential manner. Array and list are example of linear
data structure.
Asymptotic analysis of an algorithm, refers to defining the mathematical
boundation/framing of its run-time performance. Using asymptotic
analysis, we can very well conclude the best case, average case and
worst case scenario of an algorithm.
An algorithm are generally analyzed on two factors − time and space. That is, how much execution time and how much extra space required by the algorithm.
A problem can be solved in more than one ways. So, many solution
algorithms can be derived for a given problem. We analyze available
algorithms to find and implement the best suitable algorithm.
Data structure is a way of defining, storing & retrieving of data in a
structural & systematic way. A data structure may contain different
type of data items.