• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Computer notes  - Sorting
 

Computer notes - Sorting

on

  • 1,259 views

Selection Sort, Insertion Sort, Bubble Sort Main idea: find the smallest element put it in the first position find the next smallest element put it in the second position

Selection Sort, Insertion Sort, Bubble Sort Main idea: find the smallest element put it in the first position find the next smallest element put it in the second position

Statistics

Views

Total Views
1,259
Views on SlideShare
1,259
Embed Views
0

Actions

Likes
2
Downloads
68
Comments
1

0 Embeds 0

No embeds

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

11 of 1 previous next

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • Thanks sir you sort my lot of problem
    you http://ecomputernotes.com
    site is amazine all i need are avail,there thanks to provide us
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • End of lecture 43. Start of 44
  • End of lecture 44.

Computer notes  - Sorting Computer notes - Sorting Presentation Transcript

  • Class No.38 Data Structures http://ecomputernotes.com
  • Sorting http://ecomputernotes.com
  • Sorting Integers 20 8 5 10 7 5 7 8 10 20 How to sort the integers in this array? http://ecomputernotes.com
  • Elementary Sorting Algorithms
    • Selection Sort
    • Insertion Sort
    • Bubble Sort
    http://ecomputernotes.com
  • Selection Sort
    • Main idea:
      • find the smallest element
      • put it in the first position
      • find the next smallest element
      • put it in the second position
    • And so on, until you get to the end of the list
    http://ecomputernotes.com
  • Selection Sort -- Example 19 12 7 5 http://ecomputernotes.com 1 2 3 0 7 12 19 5 a: 1 2 3 0 7 19 12 5 a: 1 2 3 0 19 7 12 5 a: 1 2 3 0 7 12 19 5 a: 1 2 3 0 5 7 12 19 a: a: 1 2 3 0
  • Selection Sort: Code
    • void selectionSort(int *arr, int N)
    • {
    • int posmin, count, tmp;
    • for(count=0;count<N;count++)
    • {
    • posmin = findIndexMin(arr,count,N);
    • tmp=arr[posmin];
    • arr[posmin]=arr[count];
    • arr[count]=tmp;
    • }
    • }
    http://ecomputernotes.com
  • Selection Sort: Code
    • int findIndexMin(int *arr, int start, int N)
    • {
    • int posmin=start;
    • int index;
    • for(index=start; index < N; index++)
    • if (arr[index]<arr[posmin])
    • posmin=index;
    • return posmin;
    • }
    http://ecomputernotes.com
  • Swap Action (SelectionSorting) http://ecomputernotes.com 5 8 20 10 7 5 7 20 10 8 5 7 8 10 20 20 8 5 10 7 5 7 8 10 20
  • Selection Sort Analysis
    • What is the time complexity of this algorithm?
    • Worst case == Best case == Average case
    • Each iteration performs a linear search on the rest of the array
        • first element N +
        • second element N-1 +
        • penultimate element 2 +
        • last element 1
        • Total N(N+1)/2 = ( N 2 +N)/2
    http://ecomputernotes.com
  • Insertion Sort
    • Basic idea ( sorting cards ):
      • Starts by considering the first two elements of the array data, if out of order, swap them
      • Consider the third element, insert it into the proper position among the first three elements.
      • Consider the forth element, insert it into the proper position among the first four elements.
      • … …
    http://ecomputernotes.com
  • Insertion Sort -- Example http://ecomputernotes.com 1 2 3 0 12 5 7 19 a : 1 2 3 0 19 5 7 12 a : 1 2 3 0 12 19 7 5 a : 1 2 3 0 7 12 19 5 a :
  • Insertion Sort: Code
    • void insertionSort(int *arr, int N)
    • {
    • int pos, count, val;
    • for(count=1; count < N; count++)
    • {
    • val = arr[count];
    • for(pos=count-1; pos >= 0; pos--)
    • if (arr[pos] > val)
    • arr[pos+1]=arr[pos];
    • else break;
    • arr[pos+1] = val;
    • }
    • }
    http://ecomputernotes.com
  • Insertion Sort -- animation count val pos 1 12 0 1 12 -1 19 12 http://ecomputernotes.com 1 2 3 0 12 5 7 19 a : 1 2 3 0 19 5 7 19 a : 1 2 3 0 5 7 19 a : 12 1 2 3 0 19 5 7 12 a :
  • Insertion Sort -- animation (cont) count val pos 2 5 1 2 5 -1 19 12 2 5 0 5 http://ecomputernotes.com 1 2 3 0 12 19 7 5 a : 1 2 3 0 19 5 7 12 a : 1 2 3 0 5 7 12 a : 19 1 2 3 0 19 7 12 a : 19 1 2 3 0 12 19 7 12 a :
  • Insertion Sort -- animation (cont) count val pos 3 7 2 3 7 0 3 7 1 19 12 7 http://ecomputernotes.com 1 2 3 0 12 19 7 5 a : 1 2 3 0 12 19 7 5 a : 1 2 3 0 12 19 19 5 a : 1 2 3 0 12 12 19 5 a : 1 2 3 0 7 12 19 5 a :
  • Insertion Sort Analysis
    • What is the time complexity of this algorithm?
    • Worst case > Average case > Best case
    • Each iteration inserts an element at the start of the array, shifting all sorted elements along
        • second element 2 +
        • penultimate element N-1 +
        • last element N
        • Total (2+N)(N-1)/2 = O(N 2 )
    http://ecomputernotes.com
  • Bubble Sort
    • Basic idea ( lighter bubbles rise to the top ):
      • Exchange neighbouring items until the largest item reaches the end of the array
      • Repeat for the rest of the array
    http://ecomputernotes.com
  • Bubble Sort -- Example a: http://ecomputernotes.com 1 2 3 0 12 7 19 5 a: 1 2 3 0 12 7 19 5 a: 19 12 7 5 1 2 3 0 a: 12 19 7 5 a: 1 2 3 0 5 12 7 19 1 2 3 0 a: 1 2 3 0 12 7 19 5 a: 1 2 3 0 7 12 19 5 a: 1 2 3 0 7 12 19 5 a: 1 2 3 0 7 12 19 5 a: 1 2 3 0 7 12 19 5 a:
  • Bubble Sort: Code
    • void bubbleSort(int *arr, int N){
    • int i, temp, bound = N-1;
    • int swapped = 1;
    • while (swapped > 0 ) {
    • swapped = 0;
    • for(i=0; I < bound; i++) if ( arr[i] > arr[i+1] ) {
    • temp = arr[i];
    • arr[i] = arr[i+1];
    • arr[i+1] = temp;
    • swapped = i;
    • }
    • bound = swapped;
    • }
    • }
    http://ecomputernotes.com
  • Bubble Sort Analysis
    • What is the time complexity of this algorithm?
    • Worst case > Average case > Best case
    • Each iteration compares all the adjacent elements, swapping them if necessary
        • first iteration N +
        • second iteration N-1 +
        • last iteration 1
        • Total N(1+N)/2 = O(N 2 )
    http://ecomputernotes.com
  • Summary
    • Insertion, Selection and Bubble sort:
      • Worst case time complexity is proportional to N 2 .
    Best sorting routines are N log(N) http://ecomputernotes.com
  • NLogN Algorithms
    • Divide and Conquer
    • Merge Sort
    • Quick Sort
    • Heap Sort
    http://ecomputernotes.com
  • Divide and Conquer What if we split the list into two parts? 10 12 8 4 2 11 7 5 http://ecomputernotes.com 10 12 8 4 2 11 7 5
  • Divide and Conquer Sort the two parts: http://ecomputernotes.com 10 12 8 4 2 11 7 5 4 8 10 12 2 5 7 11
  • Divide and Conquer Then merge the two parts together: http://ecomputernotes.com 4 8 10 12 2 5 7 11 2 4 5 7 8 10 11 12