O(1) <= O(a(n)) < O(log n) < O(√n) < O(n) < 
O(n log n) < O(n*(n+1)/2) <= O(n^2) < O(2^n) < O(n!) < O(A(n))

📉 Inverse Ackermann function Time: O(a(N))

• It grows extremely slow ~O(1)

📉 Logarithmic Time: O(log N)

• Logarithmic problem size is reduced exponentially.
• Logarithmic Time is faster O(log N) = O(2 log√N)

Source: https://stackoverflow.com/questions/42038294/is-complexity-ologn-equivalent-to-osqrtn

func binarySearch(node *Node, target int) bool {
	curr := node
	for curr != nil {
		if curr.value == target {
			return true
		}
		if curr.value < target {
			return BinarySearch(curr.left)
		} else {
			return BinarySearch(curr.right)
		}
	}
	
	return false
}

📉 Square Root Time: O(√N)

• Often appears when dividing N by increasing values up to √N
• https://youtu.be/-Yqgg3qMNvE

for i := 1; i*i <= n; i++ {
    if n % i == 0 {
        // some constant-time operation
    }
}

🔁 Triangular Time: O(N(N+1)/2)*

• Usually involves two nested loops over the input.
• Typical when comparing all pairs of elements.
• It is consider the same as Quadratic Time.
• O(n + n-1 + n-2 + … + n-(n-1)) = O(n*(n+1)/2)

for i := 0; i < n; i++ {
    for j := i + 1; j < n; j++ {
        // some constant-time operation
    }
}

🔁 Quadratic Time: O(N^2)

• Usually involves two nested loops over the input.