Please enable JavaScript.

Coggle requires JavaScript to display documents.

Algorithms - Coggle Diagram

- - - - for (lorem) { for (ipsum) {} } is O(n²)
      - loop inside of a loop inside of a loop would likewise be O(n³).
      - If we have no loops and just do something and exit/return, then it's said we're doing it in constant time, or O(1).
  - - - the higher the scope of the project/its userbase, the more important/crucial Big O is
  - - - "If I nest a for loop in another for loop, that could be bad."
      - There are no rules. "Always do blank". Everything has context.
      - There are frequently multiple good choices and almost never a perfect, "right" choice.
      - readability and maintainability are the most important things about code
- - - - O(1)
  - - - for every new zip code we add, we'd have to add 42,000 new items
        
        O(n²)
  - - - O(log n)
  - - - O(n)
  - - - very frequently you need to make the trade off of computational complexity vs spatial
- - - - we break it into two smaller lists and sort those
      - and so one, recursively
      - we stop when the list length is 1 or 0
        
        those are our base cases
      - afterwards, we start merging the small lists
    - - log n: the larger the list gets, we get diminishing amounts of more things to do.
  - - - a recursive definition is when you try to define a word using the words themselves
      - A recursive function is a function that calls itself
      - When is it useful
        
        Fibonacci sequence
        
        fibonacci(n) = fibonacci(n - 1) + fibonacci(n - 2)
- - - - sort by index of arr[i].len [901,224, 58, 109]
      - sort by index of arr[i].len-1 [901, 109, 224, 58]
      - sort by index of arr[i].len-2 [58, 109, 224, 901
- - - - by definition, a list of 1 elem is sorted
    - - Is the element that I'm looking to insert larger than what's here?
        
        1) if !, work your way to the back of the array
        
        2) if you land at the first element of the sorted part of the list, what you have is smaller than everything else and you put it at the start
        
        3) you then repeat this until you've done it over the whole list!
      - The mechanism by which we'll do this is that we'll keep moving bigger elements to the right by swapping items in the array as we move across the element
      - When we come to the place where we're going to insert, we'll stop doing those swaps/
    - - Best case: O(n), usually O(n²)
      - Spatial complexity: O(1)
  - - - If they're out of order, swap them
      - Then move forward one index, compare again, swap if needed, and continue to the next item in the array
      - Once we've reached the end of the array, we pass through it again, and stop only when we pass through it without any swaps
    - - Best case, O(n)
      - Usually it's O(n²)