• Algorithm: sequence of steps that describe how a problem is solved.

• Time complexity of algorithm: amount of time taken by the algorithm to run.

• Asymptotic notation: mathematical notations used to describe the running time of an
algorithm.
• Big O notation: describes the limiting behavior of a function when the argument tends towards
a particular value or infinity.
• Big Theta(Θ) notation: specifies asymptotic bounds for a function f(n) and provides the average
time complexity of an algorithm.
• Big Omega(Ω) function: used to describe the performance or complexity of an algorithm.
• Recursion: process in which a function calls itself directly or in directly. Corresponding function
is called recursive function.
• Recursive function: function with repeats itself to calculate subsequent terms.
• Searching: designed to check for an element or retrieve an element from any data structure
where it is stored.
• Sorting algorithm: used to rearrange a given array or list of elements according to a comparison
operator on the elements.
• Bubble: simplest sorting algorithm. Works by repeatedly swapping the adjacent elements if they
are in wrong order.
• Selection: sorts an array by repeatedly finding the minimum element from unsorted part and
putting it at the beginning.
• Insertion: array is virtually split into sorted and unsorted part. Values from the unsorted part are
picked and placed at the correct position. Just like playing cards.
• Quick sort: array is split into subarrays and are recursively called to sort the element.
• Merge sort: repeatedly breaks down a list into several sublist unit each sublist consists of a
single element and merging those sublist in a manner that results in a sorted list.
• Linear search: it finds an element in the by searching the element sequentially until element is
found in the list.
• Binary search: finds the middle element in the list recursively until the middle element is
matched with a searched element.
• Hash algorithm: function that converts a data string into a numeric string output of a fixed
length.
• Divide-and-conquer approach: algorithm recursively breaks down a problem into 2 or more
sub-problems of the same or related type, until these become simple enough to be solved.
• Pseudo code: generic way to represent logic.