Easy way to find the Time Complexity of an Algorithm

Time complexity is considered one of the toughest topics for beginners who are just starting with Problem-Solving. Here, I am providing the time complexity analysis cheat sheet. I hope this helps. Please let me know if you have any questions.

Time Complexity Analysis Cheatsheet

Quick Reference Table

O(1)       - Constant time
O(log n)   - Logarithmic (halving/doubling)
O(n)       - Linear (single loop)
O(n log n) - Linearithmic (efficient sorting)
O(n²)      - Quadratic (nested loops)
O(2ⁿ)      - Exponential (recursive doubling)
O(n!)      - Factorial (permutations)

Identifying Patterns

1. O(1) - Constant

# Look for:
- Direct array access
- Basic math operations
- Fixed loops
- Hash table lookups

# Examples:
arr[0]
x + y
for i in range(5)
hashmap[key]

2. O(log n) - Logarithmic

# Look for:
- Halving/Doubling
- Binary search patterns
- Tree traversal by level

# Examples:
while n > 0:
    n = n // 2

left, right = 0, len(arr)-1
while left 



<h3>
  
  
  3. O(n) - Linear
</h3>



<pre class="brush:php;toolbar:false"># Look for:
- Single loops
- Array traversal
- Linear search
- Hash table building

# Examples:
for num in nums:
    # O(1) operation
    total += num

for i in range(n):
    # O(1) operation
    arr[i] = i

4. O(n log n) - Linearithmic

# Look for:
- Efficient sorting
- Divide and conquer
- Tree operations with traversal

# Examples:
nums.sort()
sorted(nums)
merge_sort(nums)

5. O(n²) - Quadratic

# Look for:
- Nested loops
- Simple sorting
- Matrix traversal
- Comparing all pairs

# Examples:
for i in range(n):
    for j in range(n):
        # O(1) operation

# Pattern finding
for i in range(n):
    for j in range(i+1, n):
        # Compare pairs

6. O(2ⁿ) - Exponential

# Look for:
- Double recursion
- Power set
- Fibonacci recursive
- All subsets

# Examples:
def fib(n):
    if n 



<h2>
  
  
  Common Operations Time Complexity
</h2>

<h3>
  
  
  Array/List Operations
</h3>



<pre class="brush:php;toolbar:false"># O(1)
arr[i]              # Access
arr.append(x)       # Add end
arr.pop()           # Remove end

# O(n)
arr.insert(i, x)    # Insert middle
arr.remove(x)       # Remove by value
arr.index(x)        # Find index
min(arr), max(arr)  # Find min/max

Dictionary/Set Operations

# O(1) average
d[key]              # Access
d[key] = value      # Insert
key in d            # Check existence
d.get(key)          # Get value

# O(n)
len(d)              # Size
d.keys()            # Get keys
d.values()          # Get values

String Operations

# O(n)
s + t               # Concatenation
s.find(t)           # Substring search
s.replace(old, new) # Replace
''.join(list)       # Join

# O(n²) potential
s += char           # Repeated concatenation

Loop Analysis

Single Loop

# O(n)
for i in range(n):
    # O(1) operations

# O(n/2) = O(n)
for i in range(0, n, 2):
    # Skip elements still O(n)

Nested Loops

# O(n²)
for i in range(n):
    for j in range(n):
        # O(1) operations

# O(n * m)
for i in range(n):
    for j in range(m):
        # Different sizes

# O(n²/2) = O(n²)
for i in range(n):
    for j in range(i, n):
        # Triangular still O(n²)

Multiple Loops

# O(n + m)
for i in range(n):
    # O(1)
for j in range(m):
    # O(1)

# O(n + n²) = O(n²)
for i in range(n):
    # O(1)
for i in range(n):
    for j in range(n):
        # O(1)

Recursive Analysis

Linear Recursion

# O(n)
def factorial(n):
    if n 



<h3>
  
  
  Binary Recursion
</h3>



<pre class="brush:php;toolbar:false"># O(2ⁿ)
def fibonacci(n):
    if n 



<h3>
  
  
  Divide & Conquer
</h3>



<pre class="brush:php;toolbar:false"># O(n log n)
def mergeSort(arr):
    if len(arr) 



<h2>
  
  
  Optimization Red Flags
</h2>

<h3>
  
  
  Hidden Loops
</h3>



<pre class="brush:php;toolbar:false"># String operations
for c in string:
    newStr += c  # O(n²)

# List comprehension
[x for x in range(n) for y in range(n)]  # O(n²)

Built-in Functions

len()           # O(1)
min(), max()    # O(n)
sorted()        # O(n log n)
list.index()    # O(n)

Tips for Analysis

1. Count nested loops
2. Check recursive branching
3. Consider hidden operations
4. Look for divide & conquer
5. Check built-in function complexity
6. Consider average vs worst case
7. Watch for loop variables
8. Consider input constraints

Thank you for reading, please give the thumbs up on the post if you found this helpful. Cheers!

The above is the detailed content of Easy way to find the Time Complexity of an Algorithm. For more information, please follow other related articles on the PHP Chinese website!