Searching and sorting
This presentation is the property of its rightful owner.
Sponsored Links
1 / 45

Searching and Sorting PowerPoint PPT Presentation


  • 76 Views
  • Uploaded on
  • Presentation posted in: General

Searching and Sorting. Gary Wong. Prerequisite. Time complexity Pseudocode (Recursion). Searching Linear (Sequential) Search Binary Search. Sorting Bubble Sort Merge Sort Quick Sort Counting Sort. Agenda. Linear Search. One by one. Linear Search.

Download Presentation

Searching and Sorting

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Searching and sorting

Searching and Sorting

Gary Wong


Prerequisite

Prerequisite

  • Time complexity

  • Pseudocode

  • (Recursion)


Agenda

Searching

Linear (Sequential) Search

Binary Search

Sorting

Bubble Sort

Merge Sort

Quick Sort

Counting Sort

Agenda


Linear search

Linear Search

One by one...


Linear search1

Linear Search

  • Check every element in the list, until the target is found

  • For example, our target is 38:

Not found!

Found!


Linear search2

Linear Search

  • Initilize an index variable i

  • Compare a[i] with target

    • If a[i]==target, found

    • If a[i]!=target,

      • If all have checked already, not found

      • Otherwise, change i into next index and go to step 2


Linear search3

Linear Search

  • Time complexity in worst case?

    • If N is number of elements,

    • Time complexity = O(N)

  • Advantage?

  • Disadvantage?


Binary search

Binary Search

Chop by half...


Binary search1

L

R

Binary Search

  • Given a SORTED list:

  • (Again, our target is 38)

Smaller!

Found!

Larger!


Binary search2

Binary Search

  • Why always in the middle, but not other positions, say one-third of list?

    1) Initialize boundaries L and R

    2) While L is still on the left of R

    • mid = (L+R)/2

    • If a[mid]>Target, set R be m-1 and go to step 2

    • If a[mid]<Target, set L be m+1 and go to step 2

    • If a[mid]==Target, found


Binary search3

Binary Search

  • Time complexity in the worst case?

    • If N is the number of elements,

    • Time complexity = O(lg N)

    • Why?

  • Advantage?

  • Disadvantage?


Example three little pigs

Example: Three Little Pigs

  • HKOI 2006 Final Senior Q1

  • Given three lists, each with M numbers, choose one number from each list such that their sum is maximum, but not greater than N.

  • Constraints:

    • M ≤ 3000

    • Time limit: 1s


Example three little pigs1

Example: Three Little Pigs

  • How many possible triples are there?

  • Why not check them all?

  • Time complexity?

  • Expected score = 50


Example three little pigs2

Example: Three Little Pigs

  • A simpler question: How would you search for the maximum number in ONE SORTED list such that it is not greater than N?

  • Binary search!

    • With slight modification though

    • How?


Example three little pigs3

L

R

Example: Three Little Pigs

  • Say, N=37


Example three little pigs4

Example: Three Little Pigs

  • Let’s go back to original problem

  • If you have chosen two numbers a1[i] and a2[j] already, how would you search for the third number?

  • Recall: How would you search for the maximum number in ONE SORTED list such that it is not greater than N-a1[i]-a2[j]?


Example three little pigs5

Example: Three Little Pigs

  • Overall time complexity?

  • Expected score = 90

  • 


Example three little pigs6

Example: Three Little Pigs

  • Slightly harder: Given TWO lists, each with M numbers, choose one number from each list such that their sum is maximum, but not greater than N.

  • Linear search?

  • Sort one list, then binary search!

  • Time complexity = O(M lg M)

    • O(M2) if less efficient sorting algorithm is used

  • But, can it be better?


Example three little pigs7

Example: Three Little Pigs

  • Why is it so slow if we use linear search?

  • If a1[i] and a2[j] are chosen, and their sum is smaller than N:

    • Will you consider any number in a1 that is smaller than or equal a1[i]?

  • If a1[i] and a2[j] are chosen, and their sum is greater than N:

    • Will you consider any number in a2 that is greater than or equal to a2[j]?


Example three little pigs8

Example: Three Little Pigs

  • Recall: Why is it so slow if we use linear search?

    • Because you use it for too many times!

  • At which number in each list should you begin the linear search?

  • Never look back at those we do not consider!

  • Time complexity?

  • Expected score = 100 


What can you learn

What can you learn?

  • Improve one ‘dimension’ using binary search

  • Linear search for a few times can be more efficient than binary search for many times!

    • DO NOT underestimate linear search!!!


Points to note

Points to note

  • To use binary search, the list MUST BE SORTED (either ascending or decending)

    • NEVER make assumptions yourself

    • Problem setters usually do not sort for you

  • Sorting is the bottleneck of efficiency

  • But... how to sort?


How to sort

How to sort?

  • For C++: sort()

  • Time complexity for sort() is O(N lg N)

    • which is considered as efficient

  • HOWEVER...

    • Problem setters SELDOM test contestants on pure usage of efficient sorting algorithms

    • Special properties of sorting algorithms are essential in problem-solving

  • So, pay attention! 


Bubble sort

Bubble Sort

Smaller? Float! Larger? Sink!


Bubble sort1

Bubble Sort

  • Suppose we need to sort in ascending order...

  • Repeatedly check adjacent pairs sequentially, swap if not in correct order

  • Example:

  • The last number is always the largest

18

9

20

11

77

45

Incorrect order, swap!

Correct order, pass!


Bubble sort2

Bubble Sort

  • Fix the last number, do the same procedures for first N-1 numbers again...

  • Fix the last 2 numbers, do the same procedures for first N-2 numbers again...

  • ...

  • Fix the last N-2 numbers, do the same procedures for first 2 numbers again...


Bubble sort3

Bubble Sort

for i -> 1 to n-1

for j -> 1 to n-i

if a[j]>a[j+1], swap them

  • How to swap?


Merge sort quick sort

Merge Sort & Quick Sort

Many a little makes a mickle...


Merge sort

Merge Sort

  • Now given two SORTED list, how would you ‘merge’ them to form ONE SORTED list?

List 1:

8

14

22

List 2:

10

13

29

65

Temporary list:

8

8

10

10

13

13

14

14

22

22

29

29

65

65

Combined list:


Merge sort1

Merge Sort

Merge

  • While both lists have numbers still not yet considered

    • Compare the current first number in two lists

    • Put the smaller number into temporary list, then discard it

  • If list 1 is not empty, add them into temporary list

  • If list 2 is not empty, add them into temporary list

  • Put the numbers in temporary list back to the desired list


Merge sort2

Merge Sort

  • Suppose you are given a ‘function’ called ‘mergesort(L,R)’, which can sort the left half and right half of list from L to R:

  • How to sort the whole list?

  • Merge them!

  • How can we sort the left and right half?

  • Why not making use of ‘mergesort(L,R)’?

10

13

29

65

8

14

22

L

(L+R)/2

(L+R)/2+1

R


Merge sort3

Merge Sort

mergesort(L,R){

If L is equal to R, done;

Otherwise,

m=(L+R)/2;

mergesort(L,M);

mergesort(M+1,R);

Merge the lists [L,M] and [M+1,R];

}


Merge sort4

Merge Sort

mergesort(0,6)

mergesort(0,1)

mergesort(2,3)

mergesort(4,5)

mergesort(6,6)

65

10

29

13

14

8

22

mergesort(0,0)

mergesort(1,1)

mergesort(2,2)

mergesort(3,3)

mergesort(4,4)

mergesort(5,5)

mergesort(0,3)

mergesort(4,6)

8

10

10

65

13

10

13

29

13

14

29

65

22

8

8

14

29

14

65

22


Merge sort5

Merge Sort

  • Time complexity?

  • O(N lg N)

  • Why?


Quick sort

Quick Sort

  • Choose a number as a ‘pivot’

  • Put all numbers smaller than ‘pivot’ on its left side

  • Put all numbers greater than (or equal to) ‘pivot’ on its right side

10

13

29

65

8

14

22

10

13

8

14

22

65

29


Quick sort1

x

y

Quick Sort

a[y] < pivot! shift x, swap!

  • How?

  • y shifts to right by 1 unit in every round

  • Check if a[y] < pivot

    • If yes, shift x to right by 1 unit and swap a[x] and a[y]

  • If y is at 2nd last position, swap a[x+1] and pivot

  • Time complexity?

10

13

29

65

8

14

22


Quick sort2

Quick Sort

  • Use similar idea as in merge sort

  • If we have a function called ‘quicksort(L,R)’...

    • Make use of ‘quicksort(L,R)’ to sort the two halves!

10

13

8

14

22

65

29


Quick sort3

Quick Sort

quicksort(L,R){

If L is equal to R, done;

Otherwise,

Choose a number as a pivot, say a[p];

Perform pivoting action;

quicksort(L,p-1);

quicksort(p+1,R);

}


Quick sort4

Quick Sort

  • Time complexity in worst case?

  • O(N2) 

  • What is the worst case?

  • Preventions:

    • Choose a random number as pivot

    • Pick 3 numbers, choose their median

  • Under randomization, expected time complexity is O(N lg N)


Counting sort

Counting Sort

No more comparison...


Counting sort1

Counting Sort

  • Create a list, then tally!

  • Count the occurences of elements

  • Example:

    • Sort {2,6,1,4,2,1,9,6,4,1} in ascending order

    • A list from 1 to 9 (or upper bound of input no.)

    • Three ‘1’s, two ‘2’s, two ‘4’s, two ‘6’s and one ‘9’

    • List them all!


Counting sort2

Counting Sort

  • Time complexity?

  • O(range * N)

  • Good for numbers with small range


Searching and sorting

More...

If we have time...


Searching and sorting

More...

  • Lower bound of sorting efficiency?!

  • Guess the answer by binary search

  • Count the number of ‘inversions’

  • Find the kth largest number

  • Other sorting algorithms


Time for lunch

Time for lunch

Yummy!


  • Login