chapter i - vernon computer sciencevernonmath.com/wp/wp-content/uploads/2014/04/text1… · web...

Chapter XIII

Algorithms

Chapter XIII Topics

13.1 Introduction

13.2 Using Java's Random Class

13.3 The List Case Study

13.4 Improving Input and Output

13.5 The Linear Search

13.6 The Bubble Sort

13.7 Understanding the Binary Search

13.8 Summary

Chapter XIII Algorithms Page 459

13.1 Introduction

We need to take a Java break with this chapter. There will be no significant new Java language features introduced. Do keep in mind that you are learning introductory computer science concepts and the language Java is used to teach these concepts. At most high schools BASIC, Pascal, C and C++ were used in computer science before switching to Java. In college you will see a bigger variety in introductory computer science classes. Java is certainly popular, but so are Scheme, Visual BASIC, C++ and other languages, and the choice of the introductory computer science programming language changes quite frequently.

This chapter, however, focuses on an area that does not have many changes: the algorithms used in computer programming. The algorithms that are presented in this chapter are essentially unchanged from earlier chapters in BASIC, Pascal and C++ books. Sure the language syntax is different, but the essence of the algorithm is unchanged. Do you remember what an algorithm is?

Algorithm Definition

An algorithm is a step-by-step solution to a problem.

Niklaus Wirth’s Programming Language Definition

Niklaus Wirth, the creator of the programming language Pascal, made the following equation about data structures and algorithms.

Data Structures + Algorithms = Programs

You have done quite a variety of program assignments at this stage and each program required the creation of an algorithm. There were times when you repeated the same types of algorithms for different assignments. The aim of this chapter is to look at a group of practical algorithms that are commonly used in computer science. In particular, we want to look at computer program algorithms that are used to process array information.

This chapter also emphasizes the recurring theme of computer science, not to reinvent the wheel. If practical algorithms have been created for certain situations, use them, store them, and reuse them as some later date. Time is too precious to start from scratch with every program when useful tools have already been created. By the end of this chapter I hope that your programming toolbox will be considerably expanded.

Page 460 Exposure Java 2012, PreAPCS Edition 04-30-12

13.2 Using Java's Random Class

This section will seem somewhat strange. You are going to learn how to generate random numbers that are not random. It probably sounds quite weird, but later in the chapters you will see good reasons for controlling the random numbers.

Right now for starters let us review generating true random integers with the Expo.random(min,max) method. Program Java1301.java, in figure 13.1, generates "true" random numbers. This means that each time you execute the program, there will be a set of numbers that is different and you will not be able to predict the next set of random numbers. The output is shown twice with two different sets of numbers. This is an example of using the random method that was used in earlier program examples using the Expo class.

Figure 13.1// Java1301.java// This program reviews generating random numbers with// the <Expo.random> method.

public class Java1301{

public static void main(String args[]){

System.out.println("\nGenerating numbers in the [10..99] range\n");for (int k = 0; k < 100; k++){

int randInt1 = Expo.random(10,99);System.out.print(randInt1 + " ");

}System.out.println("\n\n");







}}


Figure 13.1 Output #1


62 Exposure Java 2012, PreAPCS Edition 04-30-12

Introducing Java's Random Class

The Expo class random number generating is simple, but it has its limitations. Furthermore, let's face it, you are at the end of this course and you can certainly handle some greater complexity.

All the methods in the Expo class are class methods, which is by design. It is easier to call class methods since you do not have to start by instantiating an object first. Java's Random class requires that an object is constructed and program Java1302.java, in figure 13.2 generates three sets of numbers in three different ranges. Note that after the object rand is created, method nextInt generates a random integer. The parameter of nextInt is an upper limit. A call, like nextInt(100) will generate integers in the [0..99] or more generally speaking you can say that a call to nextInt(n) generates numbers in the [0..n-1] range.

Figure 13.2// Java1302.java// This program introduces the <Random> class and the <nextInt> method.// The <nextInt> method generates a random integer in the [0..n-1] range,// if n is the integer parameter passed to <nextInt>.

import java.util.Random;



Random rand = new Random();


int randInt1 = rand.nextInt(100);System.out.print(randInt1 + " ");



int randInt1 = rand.nextInt(10000);System.out.print(randInt1 + " ");


}}


Random Class and nextInt Method

Java has a Random class to generate random integers.An object must be constructed first like:

Random rand = new Random();

Random integers are then generated with method nextInt, like

int n1 = rand.nextInt(100); // random integer in [0..99] rangeint n2 = rand.nextInt(500]; // random integer in [0..499] rangeint n3 = rand.nextInt(n); // random integer in [0..n-1] range

Random numbers that are always in a range starting with 0 are not very practical. How does the Random class handle other ranges? Program Java1303.java, in figure 13.3, shows various examples. You will note that the secret is to add an integer value to the result of the nextInt method call. In each case the integer value added will be the minimum number in the requested range.

Figure 13.3// Java1303.java// This program shows that the <Random> object, like all objects,// can be any name, and frequently the lower-case class name is used.// It also shows how to control the random integer range.




Random random = new Random();


int randInt1 = random.nextInt(90) + 10;System.out.print(randInt1 + " ");

}System.out.println();System.out.println("\nGenerating numbers in the [100..999] range\n");for (int k = 0; k < 100; k++){

int randInt1 = random.nextInt(900) + 100;System.out.print(randInt1 + " ");

}System.out.println();System.out.println("\nGenerating numbers in the [1000..9999] range\n");for (int k = 0; k < 100; k++){

int randInt1 = random.nextInt(9000) + 1000;


System.out.print(randInt1 + " ");}System.out.println();

}}




Program Java1304.java, in figure 13.4, shows that there is an algorithm to manipulate random numbers. This program also allows the user to enter the minimum and maximum values from the keyboard.

Random Integer Algorithm

1. Determine how many different integers will be generated, called the range, which is done using:

int range = max - min + 1;

2. Use the range value in the parameter of nextInt, like:int randomInt = rand.nextInt(range);

3. Add the minimum value to step 2, like:int randomInt = rand.nextInt(range) + min;

Figure 13.4// Java1304.java// In this program the program user is able to enter the minimum// and the maximum integer value of the random number range.// Essentially, the program now behaves like the <Expo.random> method.




Random random = new Random();

System.out.print("Enter minimum random integer ===>> ");int min = Expo.enterInt();System.out.print("Enter maximum random integer ===>> ");int max = Expo.enterInt();

int range = max - min + 1;System.out.println("\nGenerating numbers in the ["+ min + ".." + max + "] range\n");for (int k = 0; k < 200; k++){

int randomInt = random.nextInt(range) + min;System.out.print(randomInt + " ");


}}




Finally, we come to the point of this section, which is the ability to generate random numbers that are not random. Have the Schrams finally lost it or did that happen some time ago? Have patience, it will make sense. Program Java1305.java, in figure 13.5, makes a very significant change from the previous program. A different Random constructor is used with a parameter. You will note in the three output samples that the first output looks random as before, but the second and third output are identical to the first one.

Figure 13.5// Java1305.java// A small, but significant change is made in this program.// In line-13 the <Random> constructor now has a parameter value.// The result is that each time the random number set will// be identical. This is called a "RANDOM SEED".




Random random = new Random(12345); // Note the different constructor

System.out.print("Enter minimum random integer ===>> ");int min = Expo.enterInt();


System.out.print("Enter maximum random integer ===>> ");int max = Expo.enterInt();

System.out.println("\nGenerating numbers in the ["+min+".."+max+"] range\n");for (int k = 0; k < 100; k++){

int range = max - min + 1;int randomInt = random.nextInt(range) + min;System.out.print(randomInt + " ");


}}

Figure 13.5, Output #1




Now we come to a logical question. Why would anybody want to have random numbers that seem to be predictable? It actually occurs in many situations. Imagine that multiple teams compete in some randomly generated card game or any other video game for that matter. To eliminate the element of luck by drawing good cards or bad cards, everybody draws the same cards. For the players the cards will seem random. The lack of randomness will only appear if the same program is run a second or third time.

Another example occurs when students in a computer science course need to write a challenging lab assignment. They must write a program that manages to find a path from a randomly generated maze. The instructor may want to test this program with the same maze for every student to get a proper comparison.

The final stage in our random quest is a program enhancement. You are now convinced that controlling random numbers is a worthwhile project. You have decided, or your instructor has decided, to create a class to handle random numbers.

This class is called MyRandom. It will have the simplicity of the Expo class since you can enter minimum and maximum values, but it will also let you select true random values or pseudo random values. MyRandom.java, in figure 13.6 shows the user-defined class and Java1306.java, in figure 13.7, is used to test the MyRandom class.

Any MyRandom object constructed without seed parameter will be truly random and an object constructed with a seed will be pseudo random.

Figure 13.6// MyRandom.java// This class is an example of a user-defined class that// simplifies operating with some Java class, like <Random>.


public class MyRandom{

private Random random;

public MyRandom() { random = new Random(); }

public MyRandom(int seed) { random = new Random(seed); }

public int nextRandom(int min, int max){

int range = max - min + 1;int randomInt = random.nextInt(range) + min;return randomInt;

}}


Figure 13.7// Java1306.java// This program tests the user-defined <MyRandom> class.// The first group of numbers will be different in both executions.// The second group of numbers will be identical in both executions.



System.out.print("Enter minimum random integer ===>> ");int min = Expo.enterInt();System.out.print("Enter maximum random integer ===>> ");int max = Expo.enterInt();MyRandom rand1 = new MyRandom();System.out.println("\nGenerating true random numbers in the ["+min+".."+max+"] range\n");for (int k = 0; k < 100; k++){

int randomInt = rand1.nextRandom(min,max);System.out.print(randomInt + " ");


MyRandom rand2 = new MyRandom(1234);System.out.println("\nGenerating pseudo random numbers in the ["+min+".."+max+"] range\n");for (int k = 0; k < 100; k++){

int randomInt = rand2.nextRandom(min,max);System.out.print(randomInt + " ");

}}

}




Truly Random and Pseudo Random

Truly Random Values

Random rand1 = new Random();

Pseudo Random Values

Random rand2 = new Random(12345);

The parameter value used in the Random constructor is the starting seed of the random number generation. The same sequence of integers will be generated every time the same starting seed value is used.

13.3 The List Case Study

Back in Chapter XI, arrays were introduced. However, we had our arrays separate from the methods. This is not in the true flavor of OOP Encapsulation. Before we get too involved with Algorithms, we will create and build a List class.


The creation of a List class allows storage of array elements along with the actions or methods that process the array.

In this chapter you will learn some of the common algorithms used in computer science. These algorithms are independent of a programming language. The syntax implementation in sample programs may be specific to Java, but the algorithmic considerations carry across all program languages.

The List case study will grow with each new algorithm. This first stage is shown in program Java1307.java, shown in figure 13.8. The main method of the program tests the List class. Each stage of the case study has a number. This class has four methods right now, two constructors, an assign method and a display method.

The first constructor has one parameter to indicate the number of array elements. The second constructor has two parameters. The first parameter is for the array size, the second parameter indicates the initial value for each array element.

The assign method assigns new values to each array element, using random values in the [1000..9999] range, using our brand new MyRandom class. The display method shows the value for each element of a List object, called array1 and array2 in this program.

This program and a few later programs will include the entire List class with the program. As the case study advances and grows with each additional method, only the main method and the latest addition of the List class will be shown by itself. Some methods, which are not used in future program examples, will be deleted from the List class. This approach will create greater program clarity and allows more focus on the newest methods.

Figure 13.8// Java1307.java// List case study #1// The first stage of the <List> case study



List1 array1 = new List1(15);array1.display();List1 array2 = new List1(15,999);array2.display();array2.assign();array2.display();System.out.println();

}}


class List1{

private int intArray[]; // stores array elementsprivate int size; // number of elements in the array

public List1(int s){

System.out.println("\nCONSTRUCTING NEW LIST OBJECT WITH DEFAULT VALUES");size = s;intArray = new int[size];

}

public List1(int s, int n){

System.out.println("\nCONSTRUCTING NEW LIST OBJECT WITH SPECIFIED VALUES");size = s;intArray = new int[size];for (int k = 0; k < size; k++)

intArray[k] = n;}

public void assign(){

System.out.println("\nASSIGNING RANDOM VALUES TO LIST OBJECT");MyRandom rand = new MyRandom(12345);for (int k = 0; k < size; k++)

intArray[k] = rand.nextRandom(1000,9999);}

public void display(){

System.out.println("\nDISPLAYING ARRAY ELEMENTS");for (int k = 0; k < size; k++)

System.out.print(intArray[k] + " ");System.out.println();

}}

Figure 13.3 Continued


List Case Study #2, Adding a Third Constructor

The assign method provides a set of random values for a List object. These values are always in the [1000..9999] range. Our next step is to create a third constructor that can control the kind of random values that will be assigned to a new List object.

Three parameters are necessary for this new constructor. The first parameter specifies the size of the new List object. The second parameter indicates the smallest possible random integer value. The third parameter passes the value of the largest upper bound value of the random integer range. Program Java1308.java, in figure 13.9, demonstrates the use of this new constructor. Four objects are instantiated with four different random integer ranges. The range of the integers is displayed by the constructor method.

Figure 13.9

// Java1308.java// List case study #2// This stage adds a third constructor, which instantiates an array object with// a specified set of random numbers. Old methods, like the first two constructors,// which are not tested are removed for better program brevity and clarity.



List2 array1 = new List2(15,0,100);array1.display();List2 array2 = new List2(15,100,999);array2.display();List2 array3 = new List2(15,0,1);array3.display();List2 array4 = new List2(15,500,505);array4.display();System.out.println();

}}

class List2{

private int intArray[]; // stores array elementsprivate int size; // number of elements in the arrayprivate int minInt; // smallest random integerprivate int maxInt; // largest random integer

public List2(int s, int min, int max)


{size = s;System.out.println("\nCONSTRUCTING LIST WITH VALUES in ["

+ min + ".." + max + "] range");intArray = new int[size];MyRandom rand = new MyRandom(12345);for (int k = 0; k < size; k++)

intArray[k] = rand.nextRandom(min,max);}


System.out.println("\nDISPLAYING ARRAY ELEMENTS");

for (int k = 0; k < size; k++)System.out.print(intArray[k] + " ");

System.out.println();}

}


13.4 Improving Input and Output


Before we go too much further with some new algorithms, it is time to make the List class more user-friendly in the input/output department. Output of any sizeable list will fly by on the monitor without allowing proper viewing of the intermediate values. Input right now does not exist. The size of the List objects and the range of the values are hard coded in the programs. This is not a satisfactory arrangement.

The first issue of too much output is handled by program Java1309.java, in figure 13.10. This program adds the pause method, of the Expo class, to the List class. We are not looking at a breaking news method, but a small, practical method, which stops program execution until the <Enter> key is pressed. The programmer can select where to call this method to control program output. In the case of the current program example, pause is called after the display of each list. The result is that the elements of each separate list can be viewed before displaying the next list.

Figure 13.10// Java1309.java// List case study #3// This program uses <Expo.pause>, which freezes output display until// the Enter key is pressed. This method allows output viewing on the// monitor when the display becomes too large.



List3 array1 = new List3(60,100,200);array1.display();Expo.pause();



List3 array4 = new List3(40,500,505);array4.display();Expo.pause();System.out.println();

}}

class List3{


public List3(int s, int min, int max){

size = s;


System.out.println("\nCONSTRUCTING LIST WITH VALUES in ["+ min + ".." + max + "] range");

intArray = new int[size];MyRandom rand = new MyRandom(12345);for (int k = 0; k < size; k++)





}}Figure 13.10 Continued


List Case Study #4, Keyboard Input

This stage is quite significant. The program user now can take control of the program execution process. The three List constructor parameters of listSize, listMin and listMax will be prompted and entered at the keyboard. The input process will be handled by the main method and the input values will then be used to construct the requested List objects. Program Java1310.java, in figure 13.11, executes the program and then prompts for user input.

Figure 13.11

// Java1310.java// List case study #4// This program allows all list information to be entered at the keyboard// before a list object is constructed.



System.out.print("\nEnter list size ===>> ");int listSize = Expo.enterInt();System.out.print("Enter minimum value ===>> ");int listMin = Expo.enterInt();System.out.print("Enter maximum value ===>> ");int listMax = Expo.enterInt();

List4 array = new List4(listSize,listMin,listMax);array.display();Expo.pause();System.out.println();

}}

class List4{



size = s;System.out.println("\nCONSTRUCTING LIST WITH VALUES in ["







}

}


13.5 The Linear Search

Now let us look at what happens in the real world. In a moment of weakness your mother or father gives you a credit card to do shopping at the local mall. You are excited and tightly clutch the piece of plastic in your hands. At each one of the stores you hand the credit card for payment. Is your new purchase now yours? No it is not. First you have to wait while the store clerk determines if your credit card can handle the purchase. Is the card valid? Does the card have sufficient credit left in its balance? These questions can only be answered by finding the information record associated with your parents’ credit card. In other words, a computer needs to perform a search to find the proper credit card record.


The credit card is but one example. In an auto parts store, a clerk punches in some part number and the computer searches to see if the part exists in inventory. And now in the modern Internet world searching takes on a new meaning when special programs, called search engines, look for requested topics on the ever- expanding World Wide Web. In other words, searching is a major big deal and in this chapter we start to explore various ways that you can search for requested elements in an array.

There is no simpler search than the Inefficient Linear Search. In this search you start at the beginning of a list and traverse to the end, comparing every element along the way. A Boolean variable is set to true if a match is found. The linearSearch method is shown first, by itself in figure 13.12. Then program Java1311.java, in figure 13.13, demonstrates this first searching approach. In just a moment we will explain why this search is called inefficient. This algorithm is called linear or sometimes sequential because it starts at one end and goes in a linear or sequential progression to the end. There are two program outputs, one for an existing number and a second output for a non-existing number.

Figure 13.12

public boolean linearSearch(int sn) { boolean found = false; for (int k = 0; k < size; k++) if (intArray[k] == sn) found = true; return found; }

Figure 13.13

// Java1311.java// List case study #5// This program introduces the "inefficient" Linear Search algorithm.





List5 array = new List5(listSize,listMin,listMax);array.display();Expo.pause();

System.out.print("\nEnter search number ===>> ");int searchNumber = Expo.enterInt();if (array.linearSearch(searchNumber))

System.out.println(searchNumber + " is in the list");else

System.out.println(searchNumber + " is not in the list");System.out.println();

}}

class List5{



size = s;System.out.println("\nCONSTRUCTING LIST WITH VALUES in [" +

min + ".." + max + "] range");intArray = new int[size];MyRandom rand = new MyRandom(12345);for (int k = 0; k < size; k++)





}

public boolean linearSearch(int sn){

boolean found = false;for (int k = 0; k < size; k++)

if (intArray[k] == sn)found = true;

return found;}

}




Did you understand why this Linear Search algorithm is called inefficient? What happens when the search number is the very first number in the list? The loop still continues and compares every element in the array until the end. This is flat silly. Imagine that you are at a car repair shop and after your file is found, the clerk continues to check every file. The next search algorithm is a more civilized Linear Search and uses a Boolean variable both to signal that the requested element is found as well as a loop condition to terminate the search. Figure 13.9 compares the previous Linear Search with the improved algorithm and program.

Figure 13.14Inefficient Linear Search Efficient Linear Search


public boolean linearSearch(int SN) { boolean found = false; for (int k = 0; k < Size; k++) if (intArray[k] == sn) found = true; return found; }

public boolean linearSearch(int sn) { boolean found = false; int k = 0; while (k < size && !found) { if (intArray[k] == sn) found = true; else k++; } return found; }


Java1312.java, in figure 13.15, demonstrates the altered algorithm. Do not expect to see any difference in execution speed. With today's computers, you will need to search a rather substantial list size to make any measurable comparisons.

Figure 13.15// Java1312.java// List case study #6// The inefficient <linearSearch> is improved with a conditional loop, which stops// the repetition once the searchNumber is found.




List6 array = new List6(listSize,listMin,listMax);array.display();Expo.pause();

System.out.print("\nEnter search number ===>> ");int searchNumber = Expo.enterInt();if (array.linearSearch(searchNumber))

System.out.println(searchNumber + " is in the list");else

System.out.println(searchNumber + " is not in the list");System.out.println();

}}

class List6{



size = s;System.out.println("\nCONSTRUCTING LIST WITH VALUES in [" + min + ".." + max + "] range");intArray = new int[size];MyRandom rand = new MyRandom(12345);for (int k = 0; k < size; k++)





}


public boolean linearSearch(int sn){

boolean found = false;int k = 0;while (k < size && !found){


elsek++;

}return found;

}}


You might be satisfied with the improved Linear Search, but we are not. The actual Java implementation of the search is really not very practical. You are told that some requested number exists or it does not exist. In real life searches normally provide information about the location of a successful search. Imagine a very large warehouse with stocked inventory. Your trusty computer has told you that Inventory part #548321-A is stocked. Well you are so pleased since there are only 200,000 parts stored and finding 548321-A should be a breeze. The next stage, program Java1313.java, in figure 13.16, of the case study uses the efficient Linear Search algorithm and returns the index value of the array element if the item is found. An index value of -1 is returned if the search item is not in the list.


Figure 13.16

// Java1313.java// List case study #7// This program makes the <linearSearch> method more practical// by returning the index of the <searchNumber> or -1 if not found.



System.out.print("\nEnter list size ===>> ");int listSize = Expo.enterInt();System.out.print("Enter minimum value ===>> ");int listMin = Expo.enterInt();System.out.print("Enter maximum value ===>> ");int listMax = Expo.enterInt();List7 array = new List7(listSize,listMin,listMax);array.display();Expo.pause();System.out.print("\nEnter search number ===>> ");int searchNumber = Expo.enterInt();int index = array.linearSearch(searchNumber);if (index == -1)

System.out.println(searchNumber + " is not in the list");else

System.out.println(searchNumber + " is found at index " + index);System.out.println();

}}

class List7{



size = s;System.out.println("\nCONSTRUCTING LIST WITH VALUES in ["






}


public int linearSearch(int sn){

boolean found = false;int k = 0;while (k < size && !found){


elsek++;

}if (found)

return k;else

return -1;}

}




13.6 The Bubble SortWe will return to more searching in a later section. Right now we need to leave searching behind to learn some other algorithms. Any additional improvements on searching algorithms will require that the data are sorted. Do you believe that anybody is really interested in sorting? Do not get confused, sorting is extremely important, but only because we desire searching. File cabinets have files neatly alphabetized or organized according to account numbers or some other order. These files are organized according to a sorting scheme for the purpose of finding the files easily. It is the same with library books that are organized in categories and sorted according to some special library number.

Why Do We Sort?

Sorting does not exist in a vacuum.

The reason for sorting is to allow more efficient searching.

The first sort in this chapter is the Bubble Sort. This humble sort gets a lot of bad press. The poor Bubble Sort is banned from many textbooks and not allowed to be uttered in certain computer science environments. Why? It is by far the most inefficient sort in a large arsenal of sorts. However, it also happens to be the easiest sort to explain to students first introduced to sorting algorithms. There is a secondary motivation. This chapter does not have as its primary motivation to study algorithmic efficiency. You are only getting started. This does not prevent a gentle introduction, and a small taste, of certain efficiency considerations. Starting with an inefficient algorithm like the Bubble Sort helps to point out certain efficiency problems and how they can be improved. The Bubble Sort gets its name because data bubbles to the top, one item at a time.

Consider the following small array of five numbers, shown in figure 13.17. It will be used to demonstrate the logic of the Bubble Sort step-by-step. At every stage, adjacent numbers are compared, and if two adjacent numbers are not in the correct place, they are swapped. Each pass through the number list places the largest number at the top. It has bubbled to the surface. The illustrations show how numbers will be sorted from smallest to largest. The smallest number will end up in the left-most array location, and the largest number will end up in the right-most location.


Figure 13.17

45 32 28 57 38

45 is greater than 32; the two numbers need to be swapped.

32 28 45 57 38

45 is greater than 28; the two numbers need to be swapped.

32 28 45 57 38

45 is not greater than 57; the numbers are left alone.57 is greater than 38; the two numbers need to be swapped.

32 28 45 38 57

One pass is now complete. The largest number, 57, is in the correct place.A second pass will start from the beginning with the same logic.32 is greater than 28; the two numbers need to be swapped.

28 32 45 38 57

32 is not greater than 45; the numbers are left alone.45 is greater than 38; the two numbers need to be swapped.

28 32 38 45 57

We can see that the list is now sorted. Our current algorithm does not realize this.It is not necessary to compare 45 and 57. The second pass is complete, and 45 is in the correct place.The third pass will start.28 is not greater than 32; the numbers are left alone.32 is not greater than 38; the numbers are left alone.

28 32 38 45 57

The third pass is complete, and 38 is “known” to be in the correct place.The fourth - and final - pass will start.28 is not greater than 32; the numbers are left alone.

28 32 38 45 57


The fourth pass is complete, and 32 is “known” to be in the correct place.A fifth pass is not necessary. 28 is the only number left.With 5 numbers there will be 4 comparison passes.With N numbers there will be N-1 comparison passes.

Bubble Sort Logic

Compare adjacent array elements.Swap the elements if they are not ordered correctly.

Continue this process until the largest element is inthe last element of the array.

Repeat the comparison process in the same manner.During the second pass make one less comparison,and place the second-largest number in the second-to-lastelement of the array.

Repeat these comparison passes with N elements,N-1 times. Each pass makes one less comparison.

You are armed with the logic of a Bubble Sort routine. Now how do you translate such an algorithm into Java program code? How about in gentle stages? Program Java1314.java, in figure 13.18, adds the partialSort method. It is an incomplete Bubble Sort that only places one element, the largest, in the correct location. If we can understand this step, then it will be easier to see how the entire sort works.

Figure 13.18// Java1314.java// List case study #8// This program introduces a "partial-sort" algorithm.// Only the largest number is places at the end of the list.




List8 array = new List8(listSize,listMin,listMax);array.display();Expo.pause();array.partialSort();array.display();System.out.println();

}}


class List8{








}

public void partialSort(){

int temp;for (int q = 0; q < size-1; q++)

if (intArray[q] > intArray[q+1]){

temp = intArray[q];intArray[q] = intArray[q+1];intArray[q+1] = temp;

}}

}



The partialSort method shows the required code for placing one array element in the correct place. It represents one so-called comparison pass. How many of these passes need to be made? You are correct. There are n-1 comparison passes, with n equal to the number of elements in the list. If we take the previous PartialSort method and package that inside another loop structure, which executes n-1 times, we might just be in business. Program Java1315.java, in figure 13.19, demonstrates the completed bubbleSort method.

Figure 13.19// Java1315.java// List case study #9// This program sorts in ascending order using the Bubble Sort.// This version of the BubbleSort is very inefficient.// It compares numbers that are already in the correct location.

import java.util.*;




List9 array = new List9(listSize,listMin,listMax);array.display();Expo.pause();array.bubbleSort();array.display();System.out.println();

}}

class List9{








}


public void bubbleSort(){

int temp;for (int p = 1; p < size; p++)

for (int q = 0; q < size-1; q++)if (intArray[q] > intArray[q+1]){

temp = intArray[q];intArray[q] = intArray[q+1];intArray [q+1] = temp;

}}

}


At the start of the Bubble Sort section we mentioned that it is good to start with an inefficient sort. This helps to appreciate efficiency and thinking about efficiency as improvements are made. So can you think of any improvements? We bet there are some clever students who realize that each comparison pass makes the same number of comparisons. Now, that is not very clever, because after each pass there is another number in the correct location. Some mechanism needs to be used to reduce comparisons for each pass.

There is also the issue of readability. Readability is an odd type of efficiency. When a program is made more readable it does not execute faster, but it debugs and updates faster. The ability to fix or update a program is a different, but also very important efficiency consideration. Our bubbleSort method includes some lines of code that swap the adjacent list items. We can gain readability by creating a swap method. Furthermore, we should make this method private,


because it is only used within the List class by the member bubbleSort method. Program Java1316.ava, in figure 13.20, addresses both improvements. Do you understand why the number of comparison passes are reduced with each iteration?

Figure 13.20// Java1316.java// List case study #10// This program introduces the private <swap> method that is used by the// <bubbleSort> and other methods.// The improved <bubbleSort> also improves the algorithm by// reducing the number of comparisons made on each pass.

import java.util.*;




List10 array = new List10(listSize,listMin,listMax);array.display();Expo.pause();array.bubbleSort();array.display();System.out.println();

}}

class List10{








}

private void swap(int x, int y){

int temp = intArray[x];intArray[x] = intArray[y];


intArray[y] = temp;}

public void bubbleSort(){

for (int p = 1; p < size; p++)for (int q = 0; q < size-p; q++)

if (intArray[q] > intArray[q+1])swap(q,q+1);

}}



13.7 Understanding The Binary Search

We are now ready to return to the all-important business of searching. It was mentioned that searching can benefit from sorting, which is why the whole sorting issue became a big deal in the first place. We now have sorted a variety of ways and this means you are anxious to see what you have gained with all this newly found knowledge.

Imagine a thick telephone book. It has 2000 pages. Do you perform a sequential search when you look for a phone number? Such an approach would be horrendous. You approximate the location of the number and open the book. Now there are three possibilities. You have the correct page; the number is on an earlier page; the number is on a later page. You repeat the process of guessing until you find the correct page.

Now imagine that you have a really bad guessing ability. Who knows, maybe you are alphabetically challenged. All you know how to do is find mid point pages by splitting pages in two. So consider the following arithmetic.

Start with a 2000 page telephone book.

Split in two, and ignore 1000 pages and search in the remaining 1000 pages.









Split in two, and ignore 1 page and search in the remaining 1 page.


This splitting in half is telling us that even with a bad guessing techniques, and splitting each section in half, it will at most require looking at 11 pages for a book with 2000 pages. This is a worst case scenario. With a sequential search starting at page 1, it will take looking at 2000 pages in a worst case scenario. This is quite a difference, and this difference is the logic used by the Binary Search.Let us apply this logic to a list of 12 numbers and see what happens when we search for a given element in figure 13.21

Figure 13.21

[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14]10 15 20 25 30 35 40 45 50 55 60 65 70 75 80

Suppose we wish to find element 55.

We take the first and last element index and divide by 2. (0 + 14)/2 = 7

We check list[7].

[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14]10 15 20 25 30 35 40 45 50 55 60 65 70 75 80

We see that list[7] = 45 and realize that the List[0]..List[7] can now be ignored.

We continue the search with List[8]..List[14].


We check List[11].

We see that List[11] = 65 and realize that the List[11]..List[14] can be ignored.

We continue the search with List[8]..List[10].


We check List[9].

We see that List[9] = 55. We have found the search item.


Binary Search Logic

The Binary Search only works with sorted lists.

Start by making the smallest index small and thelargest index large.

Find the midpoint index with (small + large) / 2

Compare the midpoint value with the search item.If the value is found you are done.

Otherwise re-assign small or large.

If the searchItem is greater you have a new small,otherwise you have a new large

Repeat the same process.Continue the process until the searchItem is found orlarge becomes less than small.

The Binary Search is more complicated than the Linear Search, but the extra work is worth it. A list of one million elements is quite large and even such a large list requires only at most 24 comparisons with a Binary Search. The Linear Search may take up to 1,000,000 comparisons in a worst case scenario, when the element is at the end of the list.

You will not be shown an example of a Binary Search algorithm in Java code in this course. You will see it in the AP Computer Science class, which you may take next school year. You also may remember that there was a binarySearch method in the Arrays class back in Chapter 11. Even if you cannot yet write your own binary search, nothing prevents you from using one already created.


13.8 Summary

An algorithm is a logical sequence of unambiguous instruction to accomplish a specified goal. An algorithm is program language independent. Algorithms can be explained, analyzed and implemented in any program language.

In this chapter the List case study of the array chapter is used to show a variety of algorithms that operate on a list of data. For most of the program examples the List object contains random integers.

The first algorithm is the Linear Search. This algorithm searches a list of data sequentially from start to end to find the requested data. The Linear Search can find data in a list regardless of its sorting order.

Sorting algorithms are both common and important in computer science. Arranging data in a desired order makes it easier and more efficient to find data.

The Bubble Sort is the easiest sorting algorithm. It is also the most inefficient way to sort data. With today's computers this is not a concern for small lists of data of 1000 or less elements. The Bubble Sort compares adjacent elements and swaps them if they are not in the proper sequence.

Inserting an array element in an existing array requires that you first use a search routine to find the correct insert location. This is followed by shifting array elements to open up space for the new array element. Special consideration needs to be given that the list has additional memory available for the insertion of a new array element.

Deleting an array element is quite similar to the insertion process. The primary difference is the possibility that the delete item does not exist in the list. Like insertion, a search must be processed first to find the delete item. Now array elements need to be shifted to eliminate the delete element.


chapter i - vernon computer sciencevernonmath.com/wp/wp-content/uploads/2014/04/text1… · web...

Documents