class 14 review sorting searching n.
Download
Skip this Video
Download Presentation
Class 14 - Review: Sorting & searching

Loading in 2 Seconds...

play fullscreen
1 / 16

Class 14 - Review: Sorting & searching - PowerPoint PPT Presentation


  • 95 Views
  • Uploaded on

Class 14 - Review: Sorting & searching. What are sorting and searching? Simple sorting algorithms Selection sort Insertion sort “Asymptotic” efficiency of algorithms Faster sorting algorithms Quicksort Mergesort. Sorting.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Class 14 - Review: Sorting & searching' - ali-gentry


Download Now 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
class 14 review sorting searching
Class 14 - Review:Sorting & searching
  • What are sorting and searching?
  • Simple sorting algorithms
    • Selection sort
    • Insertion sort
  • “Asymptotic” efficiency of algorithms
  • Faster sorting algorithms
    • Quicksort
    • Mergesort
sorting
Sorting
  • Given array or list of values, and an ordering on the elements (e.g. “<“ on numbers, alphabetical ordering on string), put the elements of the array or list into increasing order.
    • In-place sorting: rearrange the elements without allocating a new array
    • Non-destructive sorting: create new array or list with the reordered elements.
sorting cont
Sorting (cont.)
  • In-place sort: void sort (double[] A)Suppose A = After calling sort(A),A =
  • Non-destructive sort:double[] sort (double[] A)If A is as above before call, then callsort(A) returns:

17

9

4

7

10

22

23

5

4

5

7

9

10

17

22

23

4

5

7

9

10

17

22

23

searching
Searching
  • Given a set of elements (possibly with associated attributes, e.g. names with associated phone numbers), and given an element, find the element in the set.
  • E.g. we know how to find an element in a list:

boolean find (int x, IntList L) {

if (L == L.empty()) return false;

else if (x == L.hd()) return true;

else return find(x, L.tl());

}

searching cont
Searching (cont.)
  • However, above method is not efficient enough for some applications (such as finding a phone number in an entire phone book).
  • Searching can be made more efficient by using different data structures to store the data. We will not talk about searching in today’s class.
sorting algorithms
Sorting algorithms
  • Many algorithms are known for sorting elements in a list or array. They include:
    • Selection sort
    • Insertion sort
    • Quicksort
    • Mergesort
  • Efficiency - that is, run time - can vary dramatically from one to another.
selection sort
Selection sort
  • Idea is simple and intuitive, and easy to program. (We will assume we are sorting an array of length n, although the method could also be applied to sorting lists.)
    • Find smallest element among A[0]...A[n-1]. Suppose it is A[i]. Swap A[0] and A[i].
    • Find smallest element among A[1]...A[n-1]. Suppose it is A[j]. Swap A[1] and A[j].
    • Continue up to A[n-2]...A[n-1].
selection sort cont

17

9

4

7

10

22

23

5

Selection sort (cont.)

Starting state of A:

After step 1:

4

9

17

7

10

22

23

5

After step 2:

4

5

17

7

10

22

23

9

After step 3:

4

5

7

17

10

22

23

9

After step 4:

4

5

7

9

10

22

23

17

After step 5:

4

5

7

9

10

22

23

17

After step 6:

4

5

7

9

10

17

23

22

After step 7:

4

5

7

9

10

17

22

23

selection sort cont1
Selection sort (cont.)
  • As with any array-processing method, can use iteration or recursion. For the moment, we will use iteration. Basic algorithm:

void selectionSort (double[] A) {

for (i=0; i<n-1; i++) {

// Invariant: A[0]..A[i-1] is sorted, and

// elements in A[0]..A[i-1] are all less than

// elements in A[i]..A[n-1]

minloc = ... location of smallest value in A[i]...A[n-1]

... swap A[i] with A[minloc]

}

}

selection sort cont2
Selection sort (cont.)
  • Fill in specific parts by making method calls; then define those methods.

void selectionSort (double[] A) {

int i, minloc;

int n = A.length;

for (i=0; i<n-1; i++) {

// Invariant: A[0]..A[i-1] is sorted, and

// elements in A[0]..A[i-1] are all less than

// elements in A[i]..A[n-1]

minloc = findMin(A, i);

swap(A, i, minloc);

}

}

selection sort cont3
Selection sort (cont.)

int findMin (double[] A, int i) {

int j, min = i;

for (j=i+1; j<A.length; j++)

// A[min] <= all elements in A[i]..A[j-1]

if (A[j] < A[min]) min = j;

return min;

}

void swap (double[] A, int i, int j) {

double temp = A[i];

A[i] = A[j];

A[j] = temp;

}

insertion sort
Insertion sort
  • Like selection sort, insertion sort is an easy algorithm to understand and program.
    • Swap A[0] and A[1], if necessary, so that A[0]...A[1] is sorted.
    • Move A[2], if necessary, so that A[0]...A[2] is sorted.
    • Move A[3], if necessary, so that A[0]...A[3] is sorted.
    • Continue, finally moving A[n-1], if necessary, so that entire array is sorted.
insertion sort cont
Insertion sort (cont.)

Starting state of A:

17

9

4

7

10

22

23

5

After step 1:

9

17

4

7

10

22

23

5

After step 2:

4

9

17

7

10

22

23

5

After step 3:

4

7

9

17

10

22

23

5

After step 4:

4

7

9

10

17

22

23

5

After step 5:

4

7

9

10

17

22

23

5

After step 6:

4

7

9

10

17

22

23

5

After step 7:

4

5

7

9

10

17

22

23

insertion sort cont1
Insertion sort (cont.)
  • Basic algorithm:
  • As before, fill in the informal part with a method call:

void insertionSort (double[] A) {

for (i=1; i<n; i++) {

// Invariant: A[0]..A[i-1] is sorted

... insert A[i] into correct location in A[0]... A[i]

}

}

insertion sort cont2
Insertion sort (cont.)

void insertionSort (double[] A) {

int i, n = A.length;

for (i=1; i<n; i++) {

// Invariant: A[0]..A[i-1] is sorted

insertInOrder(A[i], A, i);

}

}

insertion sort cont3
Insertion sort (cont.)

void insertInOrder(double x, double[] A, int hi) {

int j = hi;

while (j > 0 && x < A[j-1]) {

// Invariant: the elements originally in

// A[0]..A[hi-1] are now in A[0]..A[j-1] and

// A[j+1]..A[hi], and x < A[j+1]

A[j] = A[j-1];

j--;

}

A[j] = x;

}