University of British Columbia CPSC 111, Intro to Computation Jan-Apr 2006 Tamara Munzner 1 2D Arrays, Sorting Lecture 16, Tue Mar 7 2006

Slides:



Advertisements
Similar presentations
Bubble Sort Algorithm 1.Initialize the size of the list to be sorted to be the actual size of the list. 2.Loop through the list until no element needs.
Advertisements

Sorting CMSC 201. Sorting In computer science, there is often more than one way to do something. Sorting is a good example of this!
CMPT 225 Sorting Algorithms Algorithm Analysis: Big O Notation.
CS 112 Introduction to Programming Sorting of an Array Debayan Gupta Computer Science Department Yale University 308A Watson, Phone:
Arrays part 2 Applications & such. Returning an array from a method A method can return an array, just like it can return any other kind of variable;
University of British Columbia CPSC 111, Intro to Computation Jan-Apr 2006 Tamara Munzner 1 Interfaces, Polymorphism II Lecture 21, Thu Mar
University of British Columbia CPSC 111, Intro to Computation Jan-Apr 2006 Tamara Munzner 1 Advanced Class Design Lecture 19, Thu Mar
Simple Sorting Algorithms
University of British Columbia CPSC 111, Intro to Computation Jan-Apr 2006 Tamara Munzner Arrays II Lecture 15, Thu Mar
Horstmann chapter 8 continued. Sorting arrays The telephone book is easy to use, because the entries are sorted Sorting is a common task, and many many.
1 Lecture 21 Introduction to Sorting I Overview  What is Sorting?  Some Useful Array Handling Methods.  Selection Sort and its Implementation.  Brief.
Computer Science 1620 Multi-Dimensional Arrays. we used arrays to store a set of data of the same type e.g. store the assignment grades for a particular.
1 Arrays b An array is an ordered list of values An array of size N is indexed from zero to N-1 scores.
Chapter 6Java: an Introduction to Computer Science & Programming - Walter Savitch 1 Chapter 6 l Array Basics l Arrays in Classes and Methods l Programming.
University of British Columbia CPSC 111, Intro to Computation 2009W2: Jan-Apr 2010 Tamara Munzner 1 Loops III Lecture 20, Fri Mar
CS 106 Introduction to Computer Science I 02 / 28 / 2007 Instructor: Michael Eckmann.
CS 106 Introduction to Computer Science I 03 / 07 / 2008 Instructor: Michael Eckmann.
University of British Columbia CPSC 111, Intro to Computation 2009W2: Jan-Apr 2010 Tamara Munzner 1 Arrays II Lecture 22, Wed Mar
University of British Columbia CPSC 111, Intro to Computation Jan-Apr 2006 Tamara Munzner Loops II Lecture 13, Thu Feb
CS 106 Introduction to Computer Science I 03 / 03 / 2008 Instructor: Michael Eckmann.
University of British Columbia CPSC 111, Intro to Computation 2009W2: Jan-Apr 2010 Tamara Munzner 1 More Class Design Lecture 30, Mon Mar
Lecture 14: A Programming Example: Sorting Yoni Fridman 7/24/01 7/24/01.
CS 106 Introduction to Computer Science I 03 / 08 / 2010 Instructor: Michael Eckmann.
University of British Columbia CPSC 111, Intro to Computation 2009W2: Jan-Apr 2010 Tamara Munzner 1 Loops III Lecture 19, Wed Mar
University of British Columbia CPSC 111, Intro to Computation 2009W2: Jan-Apr 2010 Tamara Munzner 1 Interfaces, Polymorphism Lecture 29, Fri Mar
University of British Columbia CPSC 111, Intro to Computation 2009W2: Jan-Apr 2010 Tamara Munzner 1 2D Arrays, Sorting Lecture 23, Fri Mar
University of British Columbia CPSC 111, Intro to Computation Jan-Apr 2006 Tamara Munzner 1 Arrays and Class Design Lecture 18, Tue Mar
University of British Columbia CPSC 111, Intro to Computation 2009W2: Jan-Apr 2010 Tamara Munzner 1 Arrays Lecture 21, Mon Mar
Arrays Data Structures - structured data are data organized to show the relationship among the individual elements. It usually requires a collecting mechanism.
Arrays in Java Selim Aksoy Bilkent University Department of Computer Engineering
University of British Columbia CPSC 111, Intro to Computation Jan-Apr 2006 Tamara Munzner Conditionals II Lecture 11, Thu Feb
University of British Columbia CPSC 111, Intro to Computation 2009W2: Jan-Apr 2010 Tamara Munzner 1 Yet More Array Practice Lecture 24, Mon Mar
CS 106 Introduction to Computer Science I 10 / 15 / 2007 Instructor: Michael Eckmann.
1 Two-Dimensional Arrays. 2 Can be visualized as consisting m rows, each of n columns Syntax: datatype arrayname [row] [ column] ; Example: int val[3]
1 Sorting Algorithms (Part I) Sorting Algoritms (Part I) Overview  What is Sorting?  Some Useful Array Handling Methods.  Selection Sort and its Implementation.
CS 106 Introduction to Computer Science I 10 / 16 / 2006 Instructor: Michael Eckmann.
CS 106 Introduction to Computer Science I 03 / 17 / 2008 Instructor: Michael Eckmann.
Simple Sorting Algorithms. 2 Bubble sort Compare each element (except the last one) with its neighbor to the right If they are out of order, swap them.
Simple Sorting Algorithms. 2 Outline We are going to look at three simple sorting techniques: Bubble Sort, Selection Sort, and Insertion Sort We are going.
CS1101: Programming Methodology Aaron Tan.
Week 11 Introduction to Computer Science and Object-Oriented Programming COMP 111 George Basham.
Lists in Python.
Teach.NET Workshop Series Track 4: AP Computer Science with.NET and J#
CSC141- Introduction to Computer programming Teacher: AHMED MUMTAZ MUSTEHSAN Lecture – 19 Thanks for Lecture Slides:
Arrays Module 6. Objectives Nature and purpose of an array Using arrays in Java programs Methods with array parameter Methods that return an array Array.
Programming Fundamentals I (COSC-1336), Lecture 8 (prepared after Chapter 7 of Liang’s 2011 textbook) Stefan Andrei 4/23/2017 COSC-1336, Lecture 8.
Arrays and Array Lists CSE 1310 – Introduction to Computers and Programming Vassilis Athitsos University of Texas at Arlington 1.
Lecture 6 Sorting Algorithms: Bubble, Selection, and Insertion.
Computer Programming 12 Mr. Jean April 24, The plan: Video clip of the day Upcoming Quiz Sample arrays Using arrays More about arrays.
Lec 20 More Arrays--Algorithms. Agenda Array algorithms (section 7.5 in the book) – An algorithm is a well-defined specification for solving a problem.
1 2. Program Construction in Java. 2.9 Sorting 3 The need Soritng into categories is relatively easy (if, else if, switch); here we consider sorting.
12. Sorting Intro Programming in C++ Computer Science Dept Va Tech August, 2002 © Barnette ND & McQuain WD 1 Sorting Many computer applications.
Lecture #9: Sorting Algorithms خوارزميات الترتيب Dr. Hmood Al-Dossari King Saud University Department of Computer Science 22 April 2012.
Arrays An array is a data object that can hold multiple objects, all of the same type. We can think of an array as a storage box which has multiple compartments.
CS 106 Introduction to Computer Science I 03 / 02 / 2007 Instructor: Michael Eckmann.
Sorting Sorting takes an unordered array and makes it an ordered one
1 BUILDING JAVA PROGRAMS CHAPTER 7.2 ARRAY TRAVERSAL ALGORITHMS.
1 Arrays and Methods Java always passes arguments by value – that is a copy of the value is made in the called method and this is modified in the method.
Arrays Chapter 7. MIS Object Oriented Systems Arrays UTD, SOM 2 Objectives Nature and purpose of an array Using arrays in Java programs Methods.
Computer Science 1620 Sorting. cases exist where we would like our data to be in ascending (descending order) binary searching printing purposes selection.
Chapter 8 Slides from GaddisText Arrays of more than 1 dimension.
Coming up Implementation vs. Interface The Truth about variables Comparing strings HashMaps.
1 compares each element of the array with the search key. works well for small arrays or for unsorted arrays works for any table slow can put more commonly.
Simple Sorting Algorithms
Introduction to Programming
Selection sort Given an array of length n,
Simple Sorting Algorithms
Simple Sorting Algorithms
Simple Sorting Algorithms
Ps Module 7 – Part II 2D Arrays and LISTS 8/29/2019 CSE 1321 Module 7.
Presentation transcript:

University of British Columbia CPSC 111, Intro to Computation Jan-Apr 2006 Tamara Munzner 1 2D Arrays, Sorting Lecture 16, Tue Mar based on slides by Kurt Eiselt

2 News n Remember CSLC available! n Mon-Thu 10-6, Fri 10-4, x150 (near Reboot) n extra TA lab coverage for A2 help: n Tue 4-6 Hastings, 6-8 Leavitt

3 Reading n This week: no new reading

Recap: Arrays and Object Design n Multiple array approach not very object-oriented n can create arrays of objects n can create objects of our own design "Chan Centre" "Law School" "Main Library" "Koerner Library" "Business" "Biology" "Education" "Applied Science" "Agriculture" "Computer Science" location cashIn cansSold

5 Recap: CokeEmpire n What does this return? myMachines.getCokematic(1).getCansSold() myMachines Cokematic numberOfCans: 100 location: "Chan Centre" cansSold: 185 cashIn: Cokematic numberOfCans: 150 location: "Law School" cansSold: 92 cashIn: Cokematic numberOfCans: 200 location: "Main Library" cansSold: 370 cashIn:

6 Objectives n Understanding when and how to use n 2D arrays

7 Arrays of Arrays

n In any given array, all data must be of same type

Arrays of Arrays n In any given array, all data must be of same type n All arrays in array of arrays must be of same type

Arrays of Arrays n In any given array, all data must be of same type n All arrays in array of arrays must be of same type n So easier to use a two-dimensional array!

11 Two-Dimensional Arrays n In Java, 2D array implemented internally as array of arrays n but externally syntax of 2D array may seem easier to use rows columns

12 Two-Dimensional Arrays n In Java, 2D array implemented internally as array of arrays n but externally syntax of 2D array may seem easier to use n Typical control structure for computing with 2D array is nested loop n loop within another loop n Let's write program to n load array with values shown n print contents of array rows columns

13 Two-Dimensional Arrays public class ArrayTest5 { public static void main(String[] args) { } rows columns

14 Two-Dimensional Arrays public class ArrayTest5 { public static void main(String[] args) { int[][] multTable = new int[4][3]; } rows columns

15 Two-Dimensional Arrays public class ArrayTest5 { public static void main(String[] args) { int[][] multTable = new int[4][3]; for (int col = 0; col < multTable[row].length; col++) { multTable[row][col] = row * col; } } rows columns

16 Two-Dimensional Arrays public class ArrayTest5 { public static void main(String[] args) { int[][] multTable = new int[4][3]; for (int row = 0; row < multTable.length; row++){ for (int col = 0; col < multTable[row].length; col++) { multTable[row][col] = row * col; } } rows columns

17 Two-Dimensional Arrays public class ArrayTest5 { public static void main(String[] args) { int[][] multTable = new int[4][3]; for (int row = 0; row < multTable.length; row++){ for (int col = 0; col < multTable[row].length; col++) { multTable[row][col] = row * col; } for (int col = 0; col < multTable[row].length; col++){ System.out.print(multTable[row][col] + " "); } } rows columns

18 Two-Dimensional Arrays public class ArrayTest5 { public static void main(String[] args) { int[][] multTable = new int[4][3]; for (int row = 0; row < multTable.length; row++){ for (int col = 0; col < multTable[row].length; col++) { multTable[row][col] = row * col; } for (int row = 0; row < multTable.length; row++){ for (int col = 0; col < multTable[row].length; col++){ System.out.print(multTable[row][col] + " "); } } rows columns

19 Two-Dimensional Arrays public class ArrayTest5 { public static void main(String[] args) { int[][] multTable = new int[4][3]; for (int row = 0; row < multTable.length; row++){ for (int col = 0; col < multTable[row].length; col++) { multTable[row][col] = row * col; } for (int row = 0; row < multTable.length; row++){ for (int col = 0; col < multTable[row].length; col++){ System.out.print(multTable[row][col] + " "); } System.out.println(); } rows columns

20 Example: Per-Student Averages n 2D array n each row is student in course n values in each row represent student's quiz scores in course n Print average quiz score for each student n for each row of scores n add up scores n divide by number of quizzes in a row n approach: nested loop scores average of row 0 is 71.5 average of row 1 is average of row 2 is 76.5 average of row 3 is 50.0 average of row 4 is 53.25

21 Example: Per-Student Averages public class ArrayEx4 { public static void main(String[] args) { double[][] scores = {{95, 82, 13, 96}, {51, 68, 63, 57}, {73, 71, 84, 78}, {50, 50, 50, 50}, {99, 70, 32, 12}}; double average; // here's where we control looping row by row (student by student) for (int row = 0; row < scores.length; row++) { average = 0; // and here's where we control looping through the columns // (i.e., quiz scores) within each row for (int col = 0; col < scores[row].length; col++) { average = average + scores[row][col]; } average = average / scores[row].length; System.out.println("average of row " + row + " is " + average); }

22 Example: Per-Quiz Averages n Print average score for each quiz n for each column of scores n add up all scores n divide by number of students n approach: again, nested loop n Switch of outer loop with inner loop, vs. previous scores average of column 0 is 73.6 average of column 1 is 68.2 average of column 2 is 48.4 average of column 3 is 58.6

23 Example: Per-Quiz Averages public class ArrayEx5 { public static void main(String[] args) { double[][] scores = {{95, 82, 13, 96}, {51, 68, 63, 57}, {73, 71, 84, 78}, {50, 50, 50, 50}, {99, 70, 32, 12}}; double average; // here's where we control looping column by column (quiz by quiz) for (int col = 0; col < scores[0].length; col++) { average = 0; // and here's where we control looping through the rows // (i.e., students) within each column for (int row = 0; row < scores.length; row++) { average = average + scores[row][col]; } average = average / scores.length; System.out.println("average of column " + col + " is " + average); }

24 Sorting n Computers are essential for keeping track and finding large quantities of data n Finding data when necessary is much easier when data is sorted in some way n computer people think a lot about how to sort things: n finding medical records n banking information n income tax returns n driver's license information... n even names in a phone book... n all depend on the information being sorted

25 Selection sort n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort

26 Selection sort n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed

27 Selection sort The smallest value so far is 16 Its index is 0 n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed n Then look at every value in this unsorted array n find minimum value

28 Selection sort The smallest value so far is 3 Its index is 1 n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed n Then look at every value in this unsorted array n find minimum value

29 Selection sort The smallest value so far is 3 Its index is 1 n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed n Then look at every value in this unsorted array n find minimum value

30 Selection sort The smallest value so far is 3 Its index is 1 n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed n Then look at every value in this unsorted array n find minimum value

31 Selection sort The smallest value so far is 3 Its index is 1 n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed n Then look at every value in this unsorted array n find minimum value

32 Selection sort The smallest value so far is 3 Its index is 1 n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed n Then look at every value in this unsorted array n find minimum value n Once we've found the minimum value n swap that value with the one we selected at beginning

33 Selection sort n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed n Then look at every value in this unsorted array n find minimum value n Once we've found the minimum value n swap that value with the one we selected at beginning The smallest value so far is 3 Its index is 1 n Let's say want to sort array values in increasing order n one way to approach problem is to use algorithm called selection sort n Start by setting pointer to first element in array n this is where smallest value in array will be placed n Then look at every value in this unsorted array n find minimum value n Once we've found the minimum value n swap that value with the one we selected at beginning

34 Selection sort n At this point we know n smallest number in array is in first element (index 0) n first element is sorted n rest of array remains unsorted n Now select second element of array to be location which will hold next smallest value

35 Selection sort The smallest value so far is 16 Its index is 1 n At this point we know n smallest number in array is in first element (index 0) n first element is sorted n rest of array remains unsorted n Now select second element of array to be location which will hold next smallest value n In other words, do everything again to unsorted part of array n in this case, all but first element

36 Selection sort The smallest value so far is 16 Its index is 1 n At this point we know n smallest number in array is in first element (index 0) n first element is sorted n rest of array remains unsorted n Now select second element of array to be location which will hold next smallest value n In other words, do everything again to unsorted part of array n in this case, all but first element

37 Selection sort The smallest value so far is 8 Its index is 3 n At this point we know n smallest number in array is in first element (index 0) n first element is sorted n rest of array remains unsorted n Now select second element of array to be location which will hold next smallest value n In other words, do everything again to unsorted part of array n in this case, all but first element

38 Selection sort The smallest value so far is 8 Its index is 3 n At this point we know n smallest number in array is in first element (index 0) n first element is sorted n rest of array remains unsorted n Now select second element of array to be location which will hold next smallest value n In other words, do everything again to unsorted part of array n in this case, all but first element

39 Selection sort The smallest value so far is 8 Its index is 3 n At this point we know n smallest number in array is in first element (index 0) n first element is sorted n rest of array remains unsorted n Now select second element of array to be location which will hold next smallest value n In other words, do everything again to unsorted part of array n in this case, all but first element n Now swap minimum value with selected array value n in this case, second element

40 Selection sort The smallest value so far is 8 Its index is 3 n At this point we know n smallest number in array is in first element (index 0) n first element is sorted n rest of array remains unsorted n Now select second element of array to be location which will hold next smallest value n In other words, do everything again to unsorted part of array n in this case, all but first element n Now swap minimum value with selected array value n in this case, second element

41 Selection sort n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before

42 Selection sort The smallest value so far is 19 Its index is 2 n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before

43 Selection sort The smallest value so far is 16 Its index is 3 n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before

44 Selection sort The smallest value so far is 12 Its index is 4 n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before

45 Selection sort The smallest value so far is 12 Its index is 4 n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before n Again, swap values

46 Selection sort n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before n Again, swap values

47 Selection sort The smallest value so far is 16 Its index is 3 n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before n Again, swap values n then do whole thing again

48 Selection sort The smallest value so far is 16 Its index is 3 n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before n Again, swap values n then do whole thing again

49 Selection sort The smallest value so far is 16 Its index is 3 n Now first two elements of array are sorted n Select third element of array to be location of next smallest value n Search unsorted portion of array for that value, just like before n Again, swap values n then do whole thing again n Swap again n not actually necessary in this case n but we follow algorithm

50 Selection sort n Are we done? n could select last element of array n (index 4) n but all of array except for last element is already sorted n so last element is largest value in array n and that’s the right place n Yes, array is sorted, and we're done n no need to select last element

51 Selection sort n Showed arrows moving down array n red arrow on left represents one array index variable n yellow arrow on right represents different one n Consider variables being controlled by loop n red arrow shows outer loop n yellow arrow shows inner loop inside outer loop n Nested loop structure again

52 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j

53 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

54 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0

55 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0

56 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 0

57 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 1 0

58 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 1 0

59 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 1 0

60 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 1 1

61 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 2 1

62 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 2 1

63 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 2 1

64 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 3 1

65 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 3 1

66 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 3 1

67 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 4 1

68 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 4 1

69 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 4 1

70 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 5 1

71 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp 0 5 1

72 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

73 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

74 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

75 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

76 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

77 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

78 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

79 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

80 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

81 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

82 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

83 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

84 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

85 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

86 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

87 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

88 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

89 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

90 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

91 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

92 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

93 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

94 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

95 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

96 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

97 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

98 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

99 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

100 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

101 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

102 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

103 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

104 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

105 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

106 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

107 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

108 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

109 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

110 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

111 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

112 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

113 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

114 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

115 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

116 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

117 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

118 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

119 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

120 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

121 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

122 Selection sort // selection sort public class SortTest1 { public static void main(String[] args) { int[] numbers = {16,3,19,8,12}; int min, temp; //select location of next sorted value for (int i = 0; i < numbers.length-1; i++) { min = i; //find the smallest value in the remainder of //the array to be sorted for (int j = i+1; j < numbers.length; j++) { if (numbers[j] < numbers[min]) { min = j; } //swap two values in the array temp = numbers[i]; numbers[i] = numbers[min]; numbers[min] = temp; } System.out.println("Printing sorted result"); for (int i = 0; i < numbers.length; i++) { System.out.println(numbers[i]); } i j i j min temp

123 Tracing with the Debugger