Assorted Minutiae Bug in Project 3 files reuploaded at midnight on Monday Project 2 scores Canvas groups is garbage updated tonight Extra credit P1 done and feedback soon P3 EC posted to website ID: 784108 Download

In closed word sorts the teacher defines the process for categorizing the words This requires students to engage in critical thinking as they examine sight vocabulary corresponding concepts or word structure In open word sorts the students determine

Noun Adjective V erb bi ly month legal legalize fract fracture flex flexible eleg elegance elegant re ation sign Word HistoriesStudents might sort words based on their origin: Dutch Eskimo Fr ench Spa

Revising& November November November November PI/PDsrole November November November Novemberstatement

Aleksandra Szenrok, Gabriela Filip &. Jakub Szydłowski. Poland. There are 23 National Parks in Poland located in all parts of our country. We are going to talk about Wielkopolski National Park. .

So why are rocks important?. So why are rocks important?. Rocks can be used to BUILD walls, buildings, bridges…..all sorts of things. . So why are rocks important?. Rocks can be used to BUILD walls, buildings, bridges…..all sorts of things. .

Collecting and making similarity data. Profile matrices. Most data analysis is about how properties of things are related to one another. . “Is the ability to hunt related to the number of wives a man has?” .

Before and After November 1, 2013 Lynda Woolbert, MSN, RN, CPNP - PC, FAANP SB 406 is the new prescriptive authority law governing delegation of prescriptive authority to Advanced Practice Registered

Steven Haussmann, Garrett Barnes, Shayna Oriold. Challenges of Sorting. Execution time. Memory usage. Stability. Adaptivity. Online capability. Common Sort Types. Bubble sort:. Simple to design. Easy to understand.

Assessment of Ionizing Radiation. L.Trichtchenko, L.Nikitina and A. Trishchenko. Natural Resources Canada. Presentation at ESWW11, Liege, November 17-22, 2014. CONTENTS:. Motivation. Introduction. Orbital Parameters.

COMPARISON OF ADJECTIVES DEGREES OF COMPARISON DEGREES OF COMPARISON COMPARATIVE DEGREE (Grau Comparativo) Compara UM elemento com OUTRO . Nessa comparação poderá haver IGUALDADE, DESIGUALDADE, SUPERIORIDADE

Assorted Minutiae. Bug in Project 3 files--. reuploaded. at midnight on Monday. Project 2 scores. Canvas groups is garbage – updated tonight. Extra credit. P1 – done and feedback soon. P3 – EC posted to website.

Embed :

Download Link

Download - The PPT/PDF document "Cse 373 November 8 th – Comparison S..." is the property of its rightful owner. Permission is granted to download and print the materials on this web site for personal, non-commercial use only, and to display it on your personal computer provided you do not modify the materials and that you retain all copyright notices contained in the materials. By downloading content from our website, you accept the terms of this agreement.

Slide1

Cse 373

November 8

th

– Comparison Sorts

Slide2Assorted Minutiae

Bug in Project 3 files--

reuploaded

at midnight on Monday

Project 2 scores

Canvas groups is garbage – updated tonight

Extra credit

P1 – done and feedback soon

P3 – EC posted to website

Midterm

regrades

– next Wednesday 12:00-2:00

Slide3Sorting

Problem statement:

Collection of Comparable data

Result should be a sorted collection of the data

Slide4Sorting

Problem statement:

Collection of Comparable data

Result should be a sorted collection of the data

Motivation?

Slide5Sorting

Problem statement:

Collection of Comparable data

Result should be a sorted collection of the data

Motivation?

Pre-processing v. find times

Sorting v. Maintaining

sortedness

Slide6Sorting

Important definitions

Slide7Sorting

Important definitions

In-place: Requires only O(1) extra memory

usually means the array is mutated

Slide8Sorting

Important definitions

In-place: Requires only O(1) extra memory

usually means the array is mutated

Stable: For any two elements have the same comparative value, then after the sort, which ever came first will stay first

Sorting by first name and then last name will give you

last then first

with a stable sort.

The most recent sort will always be the primary

Slide9Sorting

Important definitions

Interruptable

(top k): the algorithm can run only until the first

k

elements are in sorted order

Slide10Sorting

Important definitions

Interruptable

(top k): the algorithm can run only until the first

k

elements are in sorted order

Comparison sort: utilizes comparisons between elements to produce the final sorted order.

Slide11Sorting

Important definitions

Interruptable

(top k): the algorithm can run only until the first

k

elements are in sorted order

Comparison sort: utilizes comparisons between elements to produce the final sorted order.

Bogo

sort is not a comparison sort

Slide12Sorting

Important definitions

Interruptable

(top k): the algorithm can run only until the first

k

elements are in sorted order

Comparison sort: utilizes comparisons between elements to produce the final sorted order.

Bogo

sort is not a comparison sort

Comparison sorts are

Ω

(n log n), they cannot do better than this

Slide13Sorting

What are the sorts we’ve seen so far?

Slide14Sorting

What are the sorts we’ve seen so far?

Selection sort:

Slide15Sorting

What are the sorts we’ve seen so far?

Selection sort

Algorithm?

Slide16Sorting

What are the sorts we’ve seen so far?

Selection sort

Algorithm? For each element, iterate through the array and select the lowest remaining element and place it at the end of the sorted portion.

Slide17Sorting

What are the sorts we’ve seen so far?

Selection sort

Algorithm? For each element, iterate through the array and select the lowest remaining element and place it at the end of the sorted portion.

Runtime:

Slide18Sorting

What are the sorts we’ve seen so far?

Selection sort

Algorithm? For each element, iterate through the array and select the lowest remaining element and place it at the end of the sorted portion.

Runtime:

First run, you must select from

n

elements, the second, from

n-1, and the

kth

from

n-(k-1)

.

Slide19

Sorting

What are the sorts we’ve seen so far?

Selection sort

Runtime:

First run, you must select from

n

elements, the second, from

n-1, and the

kth

from

n-(k-1)

.

What is this summation?

n(n-1)/2

Stable?

Slide20Sorting

What are the sorts we’ve seen so far?

Selection sort

Runtime:

First run, you must select from

n

elements, the second, from

n-1, and the

kth

from

n-(k-1)

.

What is this summation?

n(n-1)/2

Stable?

Not usually

Slide21Sorting

What are the sorts we’ve seen so far?

Selection sort

Runtime:

First run, you must select from

n

elements, the second, from

n-1, and the

kth

from

n-(k-1)

.

What is this summation?

n(n-1)/2

Stable? How?

Slide22Sorting

What are the sorts we’ve seen so far?

Selection sort

Runtime:

First run, you must select from

n

elements, the second, from

n-1, and the

kth

from

n-(k-1)

.

What is this summation?

n(n-1)/2

Stable? How?

When you have your lowest candidate, shift other candidates over (similar to bubble sort)

Slide23Sorting

What are the sorts we’ve seen so far?

Selection sort

Runtime:

First run, you must select from

n

elements, the second, from

n-1, and the

kth

from

n-(k-1)

.

What is this summation?

n(n-1)/2

Stable? How?

When you have your lowest candidate, shift other candidates over (similar to bubble sort)

In place?

Slide24Sorting

What are the sorts we’ve seen so far?

Selection sort

Runtime:

First run, you must select from

n

elements, the second, from

n-1, and the

kth

from

n-(k-1)

.

What is this summation?

n(n-1)/2

Stable? How?

When you have your lowest candidate, shift other candidates over (similar to bubble sort)

In place? Can be, but can also create a separate collection (if we only want the top 5, for example)

Slide25Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Algorithm?

Slide26Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Algorithm? Maintain a sorted portion at the beginning of the array. For each new element, we swap it into the sorted portion until it reaches it’s correct location

Slide27Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Algorithm? Maintain a sorted portion at the beginning of the array. For each new element, we swap it into the sorted portion until it reaches it’s correct location

Runtime?

Slide28Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Algorithm? Maintain a sorted portion at the beginning of the array. For each new element, we swap it into the sorted portion until it reaches it’s correct location

Runtime?

Worst-case: O(n

2

) – what case is this?

Slide29Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Slide30Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case:

Slide31Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case: O(n)

Slide32Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case: O(n) – sorted order

Slide33Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case: O(n) – sorted order

Where does this difference come from?

Slide34Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case: O(n) – sorted order

Where does this difference come from?

When “swapping” into the sorted array, it can stop when it reaches the correct position, possibly terminating early. Selection sort must check all

k

elements to be sure it has the correct one

Slide35Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case: O(n) – sorted order

Where does this difference come from?

When “swapping” into the sorted array, it can stop when it reaches the correct position, possibly terminating early. Selection sort must check all

k

elements to be sure it has the correct one

Stable?

Slide36Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case: O(n) – sorted order

Where does this difference come from?

When “swapping” into the sorted array, it can stop when it reaches the correct position, possibly terminating early. Selection sort must check all

k

elements to be sure it has the correct one

Stable? Yes, if we maintain sorted order in case of ties.

Slide37Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case: O(n) – sorted order

Where does this difference come from?

k

elements to be sure it has the correct one

Stable?

Yes, if we maintain sorted order in case of ties.

In-place?

Slide38Sorting

What are the sorts we’ve seen so far?

Insertion Sort:

Runtime?

Worst-case: O(n

2

) – reverse sorted order

Best-case: O(n) – sorted order

Where does this difference come from?

k

elements to be sure it has the correct one

Stable?

Yes, if we maintain sorted order in case of ties.

In-place? Can be easily. Since not

interruptable

, having a duplicate array is only necessary if you don’t want the original array to be mutated

Slide39Sorting

What other sorting techniques can we consider?

Slide40Sorting

What other sorting techniques can we consider?

We know O(n log n) is possible. How do we do it?

Slide41Sorting

What other sorting techniques can we consider?

We know O(n log n) is possible. How do we do it?

Heap sort works on principles we already know.

Slide42Sorting

What other sorting techniques can we consider?

We know O(n log n) is possible. How do we do it?

Heap sort works on principles we already know.

Building a heap from an array takes O(n) time

Slide43Sorting

What other sorting techniques can we consider?

We know O(n log n) is possible. How do we do it?

Heap sort works on principles we already know.

Building a heap from an array takes O(n) time

Removing the smallest element from the array takes

O(log n)

Slide44Sorting

What other sorting techniques can we consider?

We know O(n log n) is possible. How do we do it?

Heap sort works on principles we already know.

Building a heap from an array takes O(n) time

Removing the smallest element from the array takes

O(log n)

There are n elements.

Slide45Sorting

What other sorting techniques can we consider?

We know O(n log n) is possible. How do we do it?

Heap sort works on principles we already know.

Building a heap from an array takes O(n) time

Removing the smallest element from the array takes

O(log n)

There are n elements.

N + N*log N = O(N log N)

Slide46Sorting

What other sorting techniques can we consider?

We know O(n log n) is possible. How do we do it?

Heap sort works on principles we already know.

Building a heap from an array takes O(n) time

Removing the smallest element from the array takes

O(log n)

There are n elements.

N + N*log N = O(N log N)

Using Floyd’s method does not improve the asymptotic runtime for heap sort, but it is an improvement.

Slide47Heap Sort

How do we actually implement this sort?

Can we do it in place?

Slide48Heap Sort

How do we actually implement this sort?

Can we do it in place?

Slide49In-place Heap

S

ort

Treat the initial array as a heap (via

buildHeap

)

When you delete the

i

th

element, put it at

arr

[n-

i

]

That array location isn’t needed for the heap anymore!

4

7

5

9

8

6

10

3

2

1

sorted part

heap part

arr

[n-

i

]=

deleteMin

()

5

7

6

9

8

10

4

3

2

1

sorted part

heap part

put the min at the end of the heap data

Slide50Heap Sort

How do we actually implement this sort?

Can we do it in place?

Is this sort stable?

Slide51Heap Sort

How do we actually implement this sort?

Can we do it in place?

Is this sort stable?

No. Recall that heaps do not preserve FIFO property

Slide52Heap Sort

How do we actually implement this sort?

Can we do it in place?

Is this sort stable?

No. Recall that heaps do not preserve FIFO property

If it needed to be stable, we would have to modify the priority to indicate its place in the array, so that each element has a unique priority.

Slide53In-place Heap

S

ort

4

7

5

9

8

6

10

3

2

1

sorted part

heap part

arr

[n-

i

]=

deleteMin

()

5

7

6

9

8

10

4

3

2

1

sorted part

heap part

put the min at the end of the heap data

What is undesirable about this method?

Slide54In-place Heap

S

ort

4

7

5

9

8

6

10

3

2

1

sorted part

heap part

arr

[n-

i

]=

deleteMin

()

5

7

6

9

8

10

4

3

2

1

sorted part

heap part

put the min at the end of the heap data

What is undesirable about this method?

You must reverse the array at the end.

Slide55Heap Sort

Can implement with a max-heap, then the sorted portion of the array fills in from the back and doesn’t need to be reversed at the end.

Slide56“AVL

sort”? “Hash sort”?

AVL Tree

: sure, we can also

use

an AVL tree

to:

Slide57“AVL

sort”? “Hash sort”?

AVL Tree

: sure, we can also

use

an AVL tree

to:

insert

each element: total time

O

(

n

log

n

)

Repeatedly

deleteMin

:

total time

O

(

n

log

n

)

Better: in-order traversal

O

(

n

), but still

O

(

n

log

n

)

overall

But this cannot be done in-place and has worse constant factors than heap

sort

Slide58“AVL

sort”? “Hash sort”?

AVL Tree

: sure, we can also

use

an AVL tree

to:

insert

each element: total time

O

(

n

log

n

)

Repeatedly

deleteMin

:

total time

O

(

n

log

n

)

Better: in-order traversal

O

(

n

), but still

O

(

n

log

n

)

overall

But this cannot be done in-place and has worse constant factors than heap

sort

Hash Structure

: don’t

even think about trying to sort with a hash

table!

Slide59“AVL

sort”? “Hash sort”?

AVL Tree

: sure, we can also

use

an AVL tree

to:

insert

each element: total time

O

(

n

log

n

)

Repeatedly

deleteMin

:

total time

O

(

n

log

n

)

Better: in-order traversal

O

(

n

), but still

O

(

n

log

n

)

overall

But this cannot be done in-place and has worse constant factors than heap

sort

Hash Structure

: don’t

even think about trying to sort with a hash

table!

Finding min item in a

hashtable

is

O

(n), so this would be a slower, more complicated selection sort

Slide60Sorting: The Big Picture

Simple

algorithms:

O(

n

2

)

Fancier

algorithms:

O(

n

log

n

)

Comparison

lower bound:

(

n

log

n

)

Specialized

algorithms:

O(

n

)

Handling

huge data

sets

Insertion sort

Selection sort

Shell

sort

…

Heap sort

Merge sort

Quick

sort (

avg

)

…

Bucket sort

Radix sort

External

sorting

Slide61Divide and conquer

Divide-and-conquer is a useful technique for

solving many kinds

of

problems (not just sorting).

It consists of the following steps:

1. Divide your work up into smaller pieces (recursively)

2. Conquer the individual pieces (as base cases)

3. Combine the results together (recursively)

algorithm

(input) {

if

(small enough) {

CONQUER

, solve, and return input

}

else {

DIVIDE

input into multiple pieces

RECURSE

on each piece

COMBINE

and return results

}

}

Slide62Divide-and-Conquer Sorting

Two great sorting methods are fundamentally divide-and-conquer

Mergesort

:

Sort the left half of the elements (recursively)

Sort the right half of the elements (recursively)

Merge the two sorted halves into a sorted whole

Quicksort:

Pick a “pivot” element

Divide elements into less-than pivot and greater-than pivot

Sort the two divisions (recursively on each)

Answer is: sorted-less-than....pivot....sorted-greater-than

Slide63

Merge Sort

Unsorted

Unsorted

Unsorted

Divide

: Split array roughly into half

S

orted

S

orted

Sorted

Conquer

: Return array when length ≤ 1

Combine:

Combine two sorted arrays using merge

Slide64Merge Sort: Pseudocode

Core idea: split array in half, sort each half, merge

back together

. If the array has size 0 or 1, just return it unchanged

mergesort

(input) {

if

(

input.length

< 2) {

return

input;

}

else {

smallerHalf

= sort(input[0, ..., mid]);

largerHalf

= sort(input[mid + 1, ...]);

return

merge(

smallerHalf

,

largerHalf

);

}

}

Slide65Merge

S

ort Example

7

2

8

4

5

3

1

6

7

2

8

4

7

2

7

2

8

4

8

4

5

3

1

6

5

3

1

6

5

3

1

6

Slide66Merge

S

ort Example

66

1

2

3

4

5

6

7

8

2

4

7

8

2

7

7

2

4

8

8

4

1

3

5

6

3

5

1

6

5

3

1

6

Slide67Merge Sort Analysis

Runtime:

subdivide

the array in half

each time: O(log(n)) recursive calls

merge is an O(n) traversal at each level

So

, the best and

worst case

runtime is the

same:

O(n log(n))

O(log(n)) levels

Slide68Merge Sort Analysis

Stable?

Yes! If

we implement the merge function correctly, merge

sort will be

stable.

In-place?

No. Merge

must construct a new array

to contain the output

, so merge sort is not in-place

.

W

e’re

constantly copying and creating new arrays

at each

level

...

One Solution

: create

a single auxiliary array and swap

between it

and the original on each level.

Slide69Quick Sort

5

2

8

4

7

3

1

6

Divide

:

Split array around a ‘pivot’

5

2

4

3

7

6

8

1

numbers <= pivot

numbers > pivot

pivot

Slide70Quick Sort

Unsorted

<= P

> P

Divide

:

Pick a pivot, partition into groups

S

orted

<= P

> P

Conquer

: Return array when length ≤ 1

Combine:

Combine

sorted partitions and pivot

P

P

Slide71Quick Sort Pseudocode

Core idea: Pick some item from the array and call it the

pivot. Put

all items smaller in the pivot into one group and all

items larger

in the other and recursively sort. If the array has size

0 or

1, just return it unchanged.

quicksort

(input) {

if

(

input.length

< 2) {

return

input;

}

else {

pivot

=

getPivot

(input);

smallerHalf

= sort(

getSmaller

(pivot, input));

largerHalf

= sort(

getBigger

(pivot, input));

return

smallerHalf

+ pivot +

largerHalf

;

}

}

Slide72QuickSort

13

81

92

43

65

31

57

26

75

0

S

select pivot value

13

81

92

43

65

31

57

26

75

0

S

1

S

2

partition

S

13

43

31

57

26

0

S

1

81

92

75

65

S

2

Quicksort(S

1

) and

Quicksort(S

2

)

13

43

31

57

26

0

65

81

92

75

S

Presto!

S

is sorted

[Weiss]

Slide73Quicksort

73

2 4 3 1

8 9 6

2 1

9

4

6

2

1

2

1 2

3

4

1 2 3 4

5

6 8 9

Conquer

Conquer

Conquer

Divide

Divide

Divide

1

Element

8

2

9

4

5

3

1

6

5

8

3

1

6

8

9

Slide74Details

Have not yet explained:

Slide75Details

Have not yet explained:

How to pick the pivot element

Any choice is correct: data will end up sorted

But as analysis will show, want the two partitions to be about equal in size

Slide76Details

Have not yet explained:

How to pick the pivot element

Any choice is correct: data will end up sorted

But as analysis will show, want the two partitions to be about equal in size

How to implement partitioning

In linear time

In place

© 2021 docslides.com Inc.

All rights reserved.