DEFINE: ALGORITHM & TIME AND SPACE COMPLEXITY OF AN ALGORITHM

 DEFINE: ALGORITHM

An algorithm is a set of well-defined, step-by-step instructions or procedures designed to perform a specific task or solve a particular problem.

Characteristics of Algorithms:

1. Finite - An algorithm must complete in a limited number of steps.

2. Well-Defined - Each step should be clear and unambiguous.

3. Effective - Each operation is feasible and can be carried out within a practical timeframe.

4. Input - It should accept zero or more inputs to work with.

5. Output - It should produce at least one output (result).

Types of Algorithms:

Sorting Algorithms: Organize data in a certain order (e.g., quicksort, mergesort, bubblesort).

Search Algorithms: Locate specific data within a structure (e.g., binary search, linear search).

Graph Algorithms: Solve problems related to graphs, like finding the shortest path (e.g., Dijkstra’s algorithm, BFS, DFS).

Dynamic Programming Algorithms: Solve problems by breaking them down into overlapping sub-problems (e.g., Fibonacci sequence, knapsack problem).

Greedy Algorithms: Make the best choice at each step with the hope of finding a global optimum (e.g., Kruskal’s algorithm for minimum spanning tree).

Backtracking Algorithms: Use a trial-and-error approach to solve constraint satisfaction problems (e.g., n-queens, Sum of subset).

 

TIME AND SPACE COMPLEXITY OF AN ALGORITHM

Measuring time and space complexity of an algorithm helps us understand how efficiently it performs, especially as the size of input data grows. Here’s a simple way to think about each:

 

1. Time Complexity (How fast an algorithm runs)

Goal: Measure how the runtime of an algorithm changes as the input size increases.

Big O Notation (O): We express time complexity in terms of "Big O" notation, which describes the upper bound of the algorithm’s growth rate. Common time complexities include:

O(1): Constant time (e.g., accessing an array element).

  O(log n): Logarithmic time (e.g., binary search).

O(n): Linear time (e.g., looping through an array).

  O(n^2): Quadratic time (e.g., nested loops).

  O(2^n): Exponential time (e.g., some recursive solutions).

Example: For a list of `n` numbers, if an algorithm loops through the list once, its time complexity is O(n). If it has nested loops (like checking pairs), it might be O(n^2).

 

2. Space Complexity (How much memory an algorithm uses)

Goal: Measure how much extra memory (space) the algorithm requires as input size increases.

Like time complexity, we use Big O notation to describe space complexity.

O(1): Constant space (no extra memory used for input size, e.g., a few variables).

O(n): Linear space (extra memory grows linearly with input, e.g., storing an array of size `n`).

Example: An algorithm that sorts a list in place (like quicksort) uses O(1) extra space. But if it creates a new list to store sorted elements, it might use O(n) space.

By analyzing time and space complexity, you can predict how well an algorithm will scale as data size grows!

Comments

Post a Comment

Popular posts from this blog

Backtracking - N-Queens Problem, Sum of Subsets, Graph Colouring, Hamiltonian Cycle

Image
UNIT - V : BACKTRACKING General Method – 8-Queens Problem – Sum Of Subsets – Graph Coloring –  Hamiltonian Cycles General Method Backtracking is a problem-solving technique used in algorithms to find solutions by exploring all possible options. In backtracking, a state-space tree is a tree-like structure that represents all possible states (solutions or non-solutions) of a problem. Backtracking algorithms explore this tree using a depth-first search approach, systematically checking each path until a solution is found or all possibilities have been exhausted.  Here’s how it works, step-by-step: Start with a choice : Make a decision and move forward. Check feasibility : If this choice leads to a solution or partial solution, continue. If not, stop exploring this path. Go back and try a different path : If you reach a dead end, go back to the last point where you made a choice. Try a different path from there. Repeat until you find a solution ...
Read more

Divide and Conquer Technique - Binary Search, Quick Sort, Merge Sort

Image
  UNIT II - DIVIDE AND CONQUER TECHNIQUE General Method – Binary Search – Merge Sort – Quick Sort.  GENERAL METHOD The divide and conquer technique is a problem-solving approach that works in three main steps: 1.       Divide : Break down a large problem into smaller, simpler sub-problems. 2.       Conquer : Solve each of the sub-problems individually. This can often be done recursively if the sub-problems are still large. 3.     Combine : Combine the solutions of the sub-problems to get the solution to the original, larger problem. This approach is commonly used in algorithms like binary search, merge sort and quick sort, where breaking down a problem makes it easier and faster to solve.   BINARY SEARCH Binary search is an efficient algorithm for finding a target value within a sorted list. Here’s how it works: Start in the Middle : Look at the middle element of the list. Compare : ...
Read more

GRAPH THEORY

Image
  GRAPH THEORY DEFINITION A graph G = (V, E) consists of a non-empty set V, called the set of vertices (points, nodes) and a set  of ordered or unordered pairs of elements of V, called the edges E set (links), such that there is a mapping from the set E to the set of ordered or unordered pairs of elements of V. Example In the first graph, V = { A , B , C , D } E = {(A,B) , (A,C) , (A,D), (B,C), (B,D) , (C,D)} In the second graph, V = { E, F, G } E = {(F,E) , (E,G) , (G,F)} If an edge e ∈ E is associated with an ordered pair (u,v) or an unordered pair (u,v), where u,v ∈ V, then e is said to connect or join the nodes u and v.  The edge e that connects the nodes u and v is said to be incident on each of the nodes.  The pair of each node that is connected by an edge is called adjacent nodes . Isolated Nodes If any node has no edges connected with any other node then its degree will be zero(0) and it will be called as isolated node. Adjacent Nodes Her...
Read more