quicksort

¡Supera tus tareas y exámenes ahora con Quizwiz!

O(n * log(n))

quicksort's average case time complexity

random

quicksort's best case scenario

O(log(n))

space complexity for quicksort's best case

O(n)

time complexity for merge

O(n * log(n))

time complexity for merge SORT

O(n * log(n))

time complexity for quicksort's average case

O(n * log(n))

time complexity for quicksort's best case

O(n^2)

time complexity for quicksort's worst case

stable sorts

2 items with the same value cannot switch positions

unstable sorts

2 items with the same value may switch positions

1. insertion sort 2. selection sort 3. merge sort 4. heapsort 5. quicksort 6. bubble sort 7. Timsort

7 sorting algorithms

random value, or the median of several values

how to choose a pivot in quicksort

O(n^2)

insertion sort's average case time complexity

already sorted

insertion sort's best case scenario

O(n)

insertion sort's best case time complexity

O(1)

insertion sort's space complexity

sorted backwards

insertion sort's worst case scenario

O(n^2)

insertion sort's worst case time complexity

O(n)

merge sort's space complexity

O(n * log(n))

merge sort's time complexity

quicksort can be done in-place without requiring extra space

one advantage quicksort has over mergesort

quicksort

- a sorting algorithm where in each step, it picks a value called the pivot and divides the array into 2 parts: values larger than the pivot and values smaller - this continues until arrays of size 1 are reached, at which point the entire array is sorted - we want to divide the array into smaller and larger parts and put the pivot in between them - if we see a smaller value, increase the size of the smaller part and put the value in the smaller part - when we're done, we'll know where to put the pivot - in the worst case the problem only gets 1 unit smaller in each step - good implementations try to avoid picking bad pivot values

Timsort

- the adaptive sorting algorithm used by Python and now Java - far more complex than any of the algorithms we've discussed, but tries to take advantage of runs of already-sorted values in the data - internally it uses both merge sort and insertion sort to sort smaller arrays and combine them together

adaptive sorting algorithm

a type of sorting algorithm that adjusts its behavior to features of the data

nope

does merge sort have a "best case" or a "worst case"?

divide and conquer

an algorithm design paradigm based on multi-branched recursion. This algorithm works by recursively breaking down a problem into 2 or more sub-problems of the same or related type, until these become simple enough to be solved directly. The solutions to the sub-problems are then combined to give a solution to the original problem.

O(n * log(n))

quicksort's best case time complexity

O(log(n))

quicksort's space complexity

sorted (order depends on pivot choice)

quicksort's worst case scenario

O(n^2)

quicksort's worst case time complexity

O(n)

space complexity for merge SORT

O(log(n))

space complexity for quicksort's average case

O(n)

space complexity for quicksort's worst case

quicksort, because it's best-case performance is as good as merge sort but it can be done using much less memory

what sorting algorithm do you use if you are short on space?

insertion sort, because it avoids the recursive calls made by merge sort and quick sort and is fastest on small arrays

what sorting algorithm do you use if you have a very small array?

merge sort, because it's performance doesn't vary based on its inputs, although it requires O(n) space

what sorting algorithm do you use if you want predictable performance?


Conjuntos de estudio relacionados

Azure Infrastructure and Networking

View Set

Microeconomics -- Chapter 8 (Part 1): Short-Run Costs and Output Decisions

View Set

Entrepreneurial Small Business 5th Edition; Chapter 7

View Set

Addition Set 5: Plus 9 Combinations

View Set

Geometry, Section 3, Transformations & Tessellations

View Set