Big O Notation Python Cheat Sheet

Posted : admin On 1/29/2022
  1. Big O Notation And Algorithm Analysis With Python Examples
  2. Understanding Time Complexity With Python Examples By ...
  3. See Full List On Stackabuse.com

See full list on stackabuse.com. Learn about Big O notation, an equation that describes how the run time scales with respect to some input variables. This video is a part of HackerRank's Cra. Aug 29, 2019 Big-O Complexity Chart. First, we consider the growth rate of some familiar operations, based on this chart, we can visualize the difference of an algorithm with O(1) when compared with O(n 2). As the input larger and larger, the growth rate of some operations stays steady, but some grow further as a straight line, some operations in the rest.

When measuring the efficiency of an algorithm, we usually take into account the time and space complexity. In this article, we will glimpse those factors on some sorting algorithms and data structures, also we take a look at the growth rate of those operations.

Big-O Complexity Chart

Big O Notation And Algorithm Analysis With Python Examples

First, we consider the growth rate of some familiar operations, based on this chart, we can visualize the difference of an algorithm with O(1) when compared with O(n2). As the input larger and larger, the growth rate of some operations stays steady, but some grow further as a straight line, some operations in the rest part grow as exponential, quadratic, factorial.

PythonSheet

Sorting Algorithms

In order to have a good comparison between different algorithms we can compare based on the resources it uses: how much time it needs to complete, how much memory it uses to solve a problem or how many operations it must do in order to solve the problem:

  • Time efficiency: a measure of the amount of time an algorithm takes to solve a problem.
  • Space efficiency: a measure of the amount of memory an algorithm needs to solve a problem.
  • Complexity theory: a study of algorithm performance based on cost functions of statement counts.
Sorting AlgorithmsSpace ComplexityTime Complexity
Worst case Best case Average case Worst case

Bubble Sort
O(1)O(n)O(n2)O(n2)
HeapsortO(1)O(n log n)O(n log n)O(n log n)
Insertion SortO(1)O(n)O(n2)O(n2)
MergesortO(n)O(n log n)O(n log n)O(n log n)
QuicksortO(log n)O(n log n)O(n log n)O(n log n)
Selection SortO(1)O(n2)O(n2)O(n2)
ShellSortO(1)O(n)O(n log n2)O(n log n2)
Smooth SortO(1)O(n)O(n log n)O(n log n)
Tree SortO(n)O(n log n)O(n log n)O(n2)
Counting SortO(k)O(n + k)O(n + k)O(n + k)
CubesortO(n)O(n)O(n log n)O(n log n)

Data Structure Operations

Big O Notation Python Cheat SheetBig O Notation Python Cheat Sheet

In this chart, we consult some popular data structures such as Array, Binary Tree, Linked-List with 3 operations Search, Insert and Delete.

Big O Notation Python Cheat Sheet
Data StructuresAverage CaseWorst Case
SearchInsertDeleteSearchInsertDelete
ArrayO(n)N/AN/AO(n)N/AN/A
AVL TreeO(log n)O(log n)O(log n)O(log n)O(log n)O(log n)
B-TreeO(log n)O(log n)O(log n)O(log n)O(log n)O(log n)
Binary SearchTreeO(log n)O(log n)O(log n)O(n)O(n)O(n)
Doubly Linked ListO(n)O(1)O(1)O(n)O(1)O(1)
Hash tableO(1)O(1)O(1)O(n)O(n)O(n)
Linked ListO(n)O(1)O(1)O(n)O(1)O(1)
Red-Black treeO(log n)O(log n)O(log n)O(log n)O(log n)O(log n)
Sorted ArrayO(log n)O(n)O(n)O(log n)O(n)O(n)
StackO(n)O(1)O(1)O(n)O(1)O(1)

Growth of Functions

The order of growth of the running time of an algorithm gives a simple characterization of the algorithm’s efficiency and also allows us to compare the relative performance of alternative algorithms.

Understanding Time Complexity With Python Examples By ...

Below we have the function n f(n) with n as an input, and beside it we have some operations which take input n and return the total time to calculate some specific inputs.

See Full List On Stackabuse.com

n f(n)log nnn log nn22nn!
100.003ns0.01ns0.033ns0.1ns1ns3.65ms
200.004ns0.02ns0.086ns0.4ns1ms77years
300.005ns0.03ns0.147ns0.9ns1sec8.4×1015yrs
400.005ns0.04ns0.213ns1.6ns18.3min
500.006ns0.05ns0.282ns2.5ns13days
1000.070.1ns0.644ns0.10ns4×1013yrs
1,0000.010ns1.00ns9.966ns1ms
10,0000.013ns10ns130ns100ms
100,0000.017ns0.10ms1.67ms10sec
1’000,0000.020ns1ms19.93ms16.7min
10’000,0000.023ns0.01sec0.23ms1.16days
100’000,0000.027ns0.10sec2.66sec115.7days
1,000’000,0000.030ns1sec29.90sec31.7 years