Scribd
Upload
9 views

Sorting Searching Algorithms Notes

Uploaded by

Danny Zhang
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
9 views

Sorting Searching Algorithms Notes

Uploaded by

Danny Zhang
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Basic Sorting Algorithms: Example Designs

Swapping Elements

1 procedure SWAP(XS, I, J) This procedure simply explains what we


mean by swapping two elements in an
2 TEMP = XS[I]
array, which is a useful action in many
3 XS[I] = XS[J] sorting algorithms.
4 XS[J] = TEMP
5 end procedure

Selection Sort

1 procedure SELECTION_SORT(XS, N) Notice in line 4 that J starts looping from I


instead of 0; this is because we know that
2 loop I from 0 to N - 1 the elements from 0 to I are already
3 LEAST_INDEX = I sorted.
4 loop J from I to N - 1
5 if XS[J] < XS[LEAST_INDEX] then
6 LEAST_INDEX = J
7 end if
8 end loop
9 SWAP(XS, LEAST_INDEX, I)
10 end loop
11 end procedure

Bubble Sort
Notice in line 2 that we only loop I to the
1 procedure BUBBLE_SORT(XS, N) second last position of the array; this is
2 loop I from 0 to N - 2 because we are comparing each element
3 loop J from 0 to N - 2 - I to the element on its right and we don't
4 if XS[J] > XS[J + 1] then want to go out of bounds.
5 SWAP(XS, J, J + 1)
Also notice in line 3 that we subtract I
6 end if
from the upper bound of J; this is because
7 end loop we know that the elements after this point
8 end loop are already sorted.
9 end procedure

Insertion Sort
Notice in line 2 that we start from index 1
1 procedure INSERTION_SORT(XS, N)
so that we can safely compare the
2 loop I from 1 to N - 1 previous element without going out of
3 J = I bounds.
4 loop while J > 0 and XS[J - 1] > XS[J]
5 SWAP(XS, J, J - 1) Also notice in line 4 that we only continue
6 J = J - 1 swapping elements while the previous
element is greater than the element we
7 end loop
are inserting; this is because we know that
8 end loop all elements after that are already sorted.
9 end procedure
Basic Searching Algorithms: Example Designs

Sequential Search (Random Access)


Here, HAYSTACK is an array
1 function SEQUENTIAL_SEARCH(HAYSTACK, N, NEEDLE)
that is not necessarily
2 loop I from 0 to N - 1 already sorted.
3 if HAYSTACK[I] = NEEDLE then
4 return true
5 end if
6 end loop
7 return false
8 end function

Sequential Search (Sequential Access)

1 function SEQUENTIAL_SEARCH(HAYSTACK, NEEDLE) Here, HAYSTACK is a


2 HAYSTACK.resetNext() collection (and hence
cannot be randomly
3 loop while HAYSTACK.hasNext()
accessed).
4 if HAYSTACK.getNext() = NEEDLE then
5 return true
6 end if
7 end loop
8 return false
9 end function

Binary Search

1 function BINARY_SEARCH(HAYSTACK, N, NEEDLE) Here, HAYSTACK is an array


2 // Precondition: HAYSTACK is sorted that is assumed to already
3 START = 0 have been sorted.
4 END = N - 1
5 loop while START ≤ END
6 MID_POINT = (START + END) div 2
7 if HAYSTACK[MID_POINT] = NEEDLE then
8 return true
9 else
10 if HAYSTACK[MID_POINT] < NEEDLE then
11 START = MID_POINT + 1
12 else
13 END = MID_POINT - 1
14 end if
15 end if
16 end loop
17 return false
18 end function
Binary Search (Recursive)
The array HAYSTACK is
1 function BINARY_SEARCH(HAYSTACK, START, END, NEEDLE)
assumed to already be
2 // Precondition: HAYSTACK is sorted sorted.
3 if START > END then
4 return false Notice the breakout
5 end if condition in lines 3—5.
6 MID_POINT = (START + END) div 2
7 if HAYSTACK[MID_POINT] = NEEDLE then
8 return true
9 else
10 if HAYSTACK[MID_POINT] < NEEDLE then Recursion occurs in lines 10
11 return BINARY_SEARCH( and 18. (Notice that all
variables are treated as
12 HAYSTACK,
constants.)
13 MID_POINT + 1,
14 END,
15 NEEDLE
16 ) When we implement binary
17 else search in languages that
pass by value by default, we
18 return BINARY_SEARCH(
should explicitly pass
19 HAYSTACK, HAYSTACK by reference to
20 START, prevent a copy of
21 MID_POINT - 1, HAYSTACK from being
22 NEEDLE passed in each call. For
example, C++ passes vector
23 )
objects by value whereas
24 end if Python passes list objects
25 end if by reference.
26 end function

You might also like