Please enable JavaScript.

Coggle requires JavaScript to display documents.

Data Structures :zap:, Algorithms :zap:, JavaScript Fundamentals :zap: -…

- - - - Single
        
        Head:red_flag:
        
        Next Point :arrow_left:
        
        Tail
        
        Null
      - Doubly
        
        Head:red_flag:
        
        Previous Point :arrow_left:
        
        Tail
        
        Null
        
        Next Point :arrow_right:
      - Linear Arhitecture
    - - Perfect Binary Tree
      - Full Binary Tree
      - Algorithm
        
        Left branch alway decreasing
        
        Right Branch increasing
      - Unbalanced
        O(n)
      - Balanced BST
        O(log n)
        
        Pros & Cons
        
        Berrter Than (0)
        
        Orderd
        
        Flexible
        
        No O(1) operations
        
        AVL Tree
        Link visual
        
        Red Black Tree
        Link visual
    - - Min Root Heap
      - Max Root Heap
      - Pros & Cons
        
        Better than O(n)
        
        Priority
        
        Flexible Size
        
        Fast Insertion
        
        Slow Lookup
        
        Slow deletion
        
        less ordered then Binary Search
      - Priority Queue:star:
        
        Each elemet has priority
        
        Lower Priority
        
        Higher priority
        
        Linear Arhitecture
        
        Pros & Cons
        
        Better than O(n)
        
        Ordered
        
        Flexeble Size
      - How Build?
        
        use Array
    - - searching text
        
        Pros & Cons
        
        faster then:
        
        binary search
        
        hash tables
        etc
    - - Be mindful of Space Complexity! (Stack overflow)
        
        Use recurstion for Search ?
  - - - Need take each node ?
- - - - store keys
    - - store key-value
  - - - HASH function
        
        Unique VALUE
- - - - use Linked List Stack
      - use Array Stack
    - - First remuved
  - - - use Array Queue (BAD)
      - use Linked List Queue
    - - First remuved
- - - - class Player
        
        Class Wizard Extends Player
  - - - String "MAX"
        
        string.split() => ["M", "A"...]
        
        [...string]
        
        array.reverse()
        
        array.map()
        
        array.join()
        
        String ["X", "A", "M"]
    - - not for JS
    - - Is it sorted ?
        
        Yes - Devide and Conquer
        
        Binary Search O(log N)
        
        No Will sorting make it faster?
        
        If still no?
        
        Linear Search O(n)
        
        No Is it a String ?
        
        See if a Trie data structure helpls
- - - - Time complexity
        Average Case | Worst Case O(n)
        
        Algorithm
        
        iterates through each element
        
        compares each elemen
        
        partitions the array into two subarrays according to the pivot
        
        until a match is found or the list is exhausted
        
        Pros & Cons
        
        simple
        
        easy to implement
        
        useful for small datasets
  - - - Time complexity
        Average Case | Worst Case O(log n)
        
        Algorithm
        
        divide-and-conquer
        
        searches for a target value
        
        middle element of the array and reduces the search space by half based on the comparison
        
        target value is found or the search space is empty
        
        Pros & Cons
        
        divide-and-conquer
        
        efficient
  - - - Graph Traversal ||Tree Traversal
        Anim DFS AND BFS
        
        Breadth First Search :file_folder:(BFS)
        O(n)
        
        Pros & Cons
        
        More Memory :warning:
        
        Shortest Path :check:
        
        Closer Nodes :check:
        
        Who’s your closest friend on Facebook ?
        
        Algorithm
        
        Going left to right, level by level
        
        Depth First Search :file_folder:
        (DFS)
        O(n)
        
        Pros & Cons
        
        Less Memory :check:
        
        Closer Nodes :check:
        
        If something exist ?
        
        Can get Slow if too deep graph :warning:
        
        Algorithm
        
        Going as deep as possible down
        
        Implemintation ?
        
        Postorder
        
        Algorithm
        
        Traverse the left subtree
        
        1 more item...
        
        Preorder
        
        Algorithm
        
        Visit the root
        
        1 more item...
        
        Inorder
        
        Algorithm
        
        Traverse the left subtree
        
        1 more item...
  - - - Graph Traversl
        
        Dijkstra
        
        Bellman-Ford
- - - - [...].sort() === Merge for Mozila
        
        [...].sort() === QuickSort and Insertion for V8 Chrome
  - - - Bubble :no_entry:
        
        Algorithm
        
        repeatedly steps through the list
        
        swaps them if they are in the wrong order
        
        Pros & Cons
        
        useful for small datasets
        
        easy to understand
        
        ease to implement
      - Selection :no_entry:
        
        Algorithm
        
        divides the input list into two parts
        
        sorted part
        
        unsorted part
        
        selects the smallest element
        
        swaps it with the first element
      - Insertion :no_entry:
        
        Algorithm
        
        unsorted part
        
        selects an element from the unsorted part
        
        sorted part
        
        inserts it into its correct position in the sorted part
    - - Merge :check:
        
        Algorithm
        
        divide-and-conquer
        
        merges the sorted halves
        
        divide-and-conquer
        
        merges the sorted halves
        
        Pros & Cons
        
        preserves the relative order of equal elements
        
        stable
      - QuickSort :check:
        
        Algorithm
        
        divide-and-conquer
        
        selects a pivot element from the input array
        
        partitions the array into two subarrays according to the pivot
        
        recursively sorts the subarrays
        
        Pros & Cons
        
        does not require additional space
        
        Piviot tehnique
  - - - Radix :dizzy_face:
        Animation
        
        Pros & Cons
        
        efficient :check:
        
        only with numbers :warning:
        
        hard to understand :warning:
        
        requires additional space :warning:
      - Counting :dizzy_face:
        Animation
- - - - Dynamic Programming:fire:
        
        Algorithm
        
        Devide & concure
        Breaking it down into simpler subproblems
        
        Cashing to store the results of the subproblems
        
        A lot of calculation ?
        (recusion!)
        
        O(n^2) or bigger?
        
        Memoization
        (Cashing)
        
        Algorithm
        O(N)
        
        create object to store the results
        
        1 more item...
- - - - JS Engine :fire_engine:
        
        One Call Stack (LIFO)
        
        Single Thread
        
        Why one Thread?
        
        No deadlocks
        
        Ease to manage
        
        Manage Work proces
        
        First In Last out
        
        WebAPI
        
        Timeout (SetTimeout)
        
        DOM (document)
        
        AJAX ( XMLHttpRequest)
        
        Callback Queue (Wait)
        
        OnClick
        
        OnLoad
        
        OnDone
        
        Memory Heap