1. Introduction to Sorting
By Saad Malik

2. What is Sorting?
Sorting: an operation that segregates items into groups according to specified criterion.
A = { }
A = { }

3. Why Sort and Examples Consider:
Sorting Books in Library (Dewey system)
Sorting Individuals by Height (Feet and Inches)
Sorting Movies in Blockbuster (Alphabetical)
Sorting Numbers (Sequential)

4. Types of Sorting Algorithms
There are many, many different types of sorting algorithms, but the primary ones are:
Bubble Sort
Selection Sort
Insertion Sort
Merge Sort
Shell Sort
Heap Sort
Quick Sort
Radix Sort
Swap Sort

5. Review of Complexity
Most of the primary sorting algorithms run on different space and time complexity.
Time Complexity is defined to be the time the computer takes to run a program (or algorithm in our case).
Space complexity is defined to be the amount of memory the computer needs to run a program.

6. Complexity (cont.)
Complexity in general, measures the algorithms efficiency in internal factors such as the time needed to run an algorithm.
External Factors (not related to complexity):
Size of the input of the algorithm
Speed of the Computer
Quality of the Compiler

7. O(n), Ω(n), & Θ(n)
An algorithm or function T(n) is O(f(n)) whenever T(n)'s rate of growth is less than or equal to f(n)'s rate.
An algorithm or function T(n) is Ω(f(n)) whenever T(n)'s rate of growth is greater than or equal to f(n)'s rate.
An algorithm or function T(n) is Θ(f(n)) if and only if the rate of growth of T(n) is equal to f(n).

8. Common Big-Oh’s Front (Binary) Finding 8: (Linear) Finding 8: Initial:
Time complexity
Example
O(1)
constant
Adding to the front of a linked list
O(log N )
log
Finding an entry in a sorted array O(
linear
Finding an entry in an unsorted array
n-log-n
Sorting n items by ‘divide-and-conquer’ 2
quadratic
Shortest path between two nodes in a graph 3
cubic
Simultaneous linear equations
Front
(Binary) Finding 8: 9 50 22 21 8 5 1
(Linear) Finding 8: 9 50 22 21 8 5 1
Initial: 1
Final: 6 3

9. Big-Oh to Primary Sorts
Bubble Sort = n²
Selection Sort = n²
Insertion Sort = n²
Merge Sort = n log(n)
Quick Sort = n log(n)

10. Time Efficiency How do we improve the time efficiency of a program?
The 90/10 Rule
90% of the execution time of a program is spent in
executing 10% of the code
So, how do we locate the critical 10%?
software metrics tools
global counters to locate bottlenecks (loop executions,
function calls)

11. Time Efficiency Improvements
Possibilities (some better than others!)
Move code out of loops that does not belong there
(just good programming!)
Remove any unnecessary I/O operations (I/O operations
are expensive time-wise)
Code so that the compiled code is more efficient
Moral - Choose the most appropriate algorithm(s) BEFORE
program implementation

12. Stable sort algorithms
Bob
Ann
Joe
Zöe
Dan
Pat
Sam 90 98 86 75
original array
Bob
Ann
Joe
Zöe
Dan
Pat
Sam 90 98 86 75
stably sorted
A stable sort keeps equal elements in the same order
This may matter when you are sorting data according to some characteristic
Example: sorting students by test scores
Slides/searching.ppt

13. Unstable sort algorithms
An unstable sort may or may not keep equal elements in the same order
Stability is usually not important, but sometimes it is important
Bob
Ann
Joe
Zöe
Dan
Pat
Sam 90 98 86 75
original array
Bob
Ann
Joe
Zöe
Dan
Pat
Sam 90 98 86 75
unstably sorted
Slides/searching.ppt

14. Selection Sorting Step: 1. select the smallest element
among data[i]~ data[data.length-1];
2. swap it with data[i];
3. if not finishing, repeat 1&2 20 8 5 10 7 5 8 20 10 7 5 7 20 10 8 5 7 8 10 20
rio.ecs.umass.edu/ece242/slides/lect-sorting.ppt 5 7 8 10 20

15. Pseudo-code for Insertion Sorting
Place ith item in proper position:
temp = data[i]
shift those elements data[j] which greater than temp to right by one position
place temp in its proper position
rio.ecs.umass.edu/ece242/slides/lect-sorting.ppt

16. Insert Action: i=1 temp 8 20 8 5 10 7 i = 1, first iteration 8 20 20 5
--- 8 20 5 10 7
rio.ecs.umass.edu/ece242/slides/lect-sorting.ppt

17. Insert Action: i=2 temp 5 8 20 5 10 7 i = 2, second iteration 5 8 20
--- 5 8 20 10 7
rio.ecs.umass.edu/ece242/slides/lect-sorting.ppt

18. Insert Action: i=3 temp 10 5 8 20 10 7 i = 3, third iteration 10 5 8
--- 5 8 10 20 7
rio.ecs.umass.edu/ece242/slides/lect-sorting.ppt

19. Insert Action: i=4 temp 7 5 8 10 20 7 i = 4, forth iteration 7 5 8 10
--- 5 7 8 10 20
rio.ecs.umass.edu/ece242/slides/lect-sorting.ppt

20. Sorting Webpage