Please enable JavaScript.

Coggle requires JavaScript to display documents.

algorithms (measures methods to determine efficiency (data strutures…

- - - - O(n)best:1,worst n
    - - O(log(n)) best 1, worst log(n)
- - - - video
      - go to item one at a time until item is found
    - - video
      - lower bound mid point and upper bound used
        half every time
        can use recurstion
  - - - Video
      - two lists one sorted one not
        take the first item in unsorted
        move item to correct location in sorted list
      - use back end and front end of array
      - good if list is already pre sorted and adding items
    - - Video
      - divide and conquer, recursive
      - data is broken down in to one item lists
        recursivly recombined
        (focus on one half at a time)
        split then combine by comparing fist items then second etc.
    - - Video
      - pivots are used
        items larger move to the right and smaller to the left
        pointers are used to manipulate pivots
        two distinct one moving and one stationary pointers are used
        a swap is made if the pointers are in the wrong order
        when the numbers swap so do the pointers
        when the pointers meet the pivot is found
      - can use concurancy
      - more memory efficent
    - - video
      - swaps two agasent items if out of order unitil, a sorted list is formed
      - easy to impilment but ineffecent
  - - - breadth first similarties
      - video
      - mark each node a distance of infatine from start node
        while the destination node is unvisted
        go to closet unvisted node
        calulate distance to current node pluse the distance to the start node
        if distance is less then the current distance update it
        go to next node
    - - works the same as dyctras but chooses its next node by the lowest hysteric value
      - hysterics for exam closet by distance as the crow flys
      - or hysterics of previous knolege
      - faster
      - f+g is used
- - - - if recursion is used space complexity will be high