Types of Algorithms and their Uses

 Algorithms are an integral part of the internet and search engine platform which enhances your search and also is responsible for boosting page rankings online. So what are Algorithms?

Algorithms are a set of instructions that solve problems. They can be applied to any problem and have various applications. There are various types of algorithms, which can be divided into two categories: search and divide and conquer (DC). 

Search algorithms help us find something in an array or table, and DC algorithms help us solve problems by breaking them down into smaller pieces and solving them one at a time.

Search algorithm

The search algorithm is a process that helps in finding the location of an element in an array. A search algorithm can be defined as a computer program that solves a problem by scanning through all possible results that best suit your search query. 

The simplest example could be when you want to find out how many numbers there are between 1 and 100:

- You have an array with 100 elements (1..100).

- Your goal is to find out how many numbers are between 1 and 100 (1..100)

Divide and Conquer Algorithm

The divide and conquer algorithm works by dividing the problem into subproblems, each of which can be solved easily. The project that you are working on may be too large to solve using one algorithm. In these cases, you will use several different algorithms at once to make it easier for your computer to work on them all at once.

Binary Search

Binary Search is a search algorithm that finds the location of an element in an array. It is an O(log N) time complexity sorting algorithm, which means it takes logarithmic time to complete on average. The average case complexity is O(2n), where n equals the number of elements in your array—but if you have a very small array (like one or two), then the binary search will run much faster than any other algorithm you could use!

Sort Algorithm

Sorting algorithms are used to sort data. They can be classified as in-place and not in-place, meaning that they do not alter the original data structure but merely rearrange it according to their own rules. 

The most common sorting algorithm is quicksort, which uses divide and conquer to sort an array into two subarrays based on some criteria. 

This process can be repeated until all elements have been sorted into their final position or there are no more groups left over from previous iterations (i.e., when you reach a point where you've exhausted all your possible combinations).

Another common approach is merge sorting. This method divides an array into two subsets, then merges them together again so that each subset contains only one copy of each element (the first subset has all odd numbers while the second has all even).

 This process continues until no more subsets remain for merging with each other. At this point, we have finally reached our goal! Let's discuss the time complexities of sorting algorithms and its details.

= Quicksort - Merge sort

A divide and conquer algorithm is quicksort. The array is split into two subarrays, and the algorithm repeats the process on each subarray until all the data has been sorted.

Merge sort is an example of a recursive algorithm that sorts data by repeatedly merging smaller sets together until they are big enough to be sorted by themselves. 

The key insight behind merge sort is that once you’ve merged two equal-sized sets, subsequent merges can be performed in constant time (it doesn’t matter if you have to merge three times or 100 times).

= Graph Algorithm

A graph is a collection of vertices, which are connected by edges. This means that if you add an edge between two vertices, then these two vertices are now connected.

Graph algorithms allow us to find the shortest path between two vertices in a graph. We can also use them to find the minimum spanning tree (MST).

An MST is an undirected graph that contains all its edges and no cycles (a cycle is formed when there are multiple paths from one vertex to another). In other words, it has no self-loops or backtracks. It's just one big looping thing!

= Backtracking Algorithm

The backtracking algorithm is a recursive algorithm that uses the minimum of its arguments as its own. This means that for every step in the algorithm, you start with your goal and then look for ways to get there. 

For example, let's say you want to find the minimum value from a given list of numbers:

- Find the first number on our list (1).

read more