Chapter 11 - Sorting and Searching

Editor's Notes

• #7: Note: In the case of unsuccessful search, all elements in the array are compared against the search value, so the total number of comparisons is N. However, the actual number of times the while loop is executed is N+1 because we need one more go around to determine that loc becomes equal to number.length .
• #18: Note: The value of log 2 N is a real number. Since the number of comparisons done is an integer, the result of log 2 N is rounded up to an integer in the third column.
• #21: The figure shows the whole eight passes. The illustration for each pass shows the state right BEFORE the exchange was made for that pass. The illustrations in the slide show the state AFTER the exchange was made for that pass.
• #25: What is the meaning behind the name “bubble” sort? Notice the effect of one pass is to migrate the largest element to the last position of the array. In addition, because we are exchanging the pairs if they are out of order, other elements migrate toward the end of the array. If we view the array vertically with the first position at the bottom and the last position at the top, the data movements we see is like bubbles moving toward the surface of water.
• #26: The bubble sort routine is implemented by exploiting the following two properties: 1. After one pass through the array, the largest element will be at the end of the array. 2. During one pass, if no pair of consecutive entries is out of order, then the array is sorted.
• #27: The selection sort will carry out N-1 passes no matter what. Whether the array is already sorted or very close to being sorted does not matter to the selection sort. It will carry out the same number of comparisons in sorting a given array. The bubble sort, on the other hand, can detect if the array is or has become sorted during the sorting process. So the bubble sort is adaptable, it does fewer comparisons for the arrays that are closer to being sorted than those that are not. In addition to the larger number of data movements during a single pass, the capability of checking the “sortedness” of the array enables the bubble sort routine to complete the whole sorting process much quicker than the selection sort. Indeed, the only situation that causes the bubble sort routine to execute the worst case number of comparisons is when the original array is in the reverse order (i.e., in descending order).
• #29: We use integers as data values for the examples in this section. The topmost node is called the root of a heap. Nodes in a heap are indexed 0, 1, 2, and so forth in the top-to-bottom, left-to-right order starting from the root. A node in a heap has either zero, one, or two children. The children of a node are distinguished as the node’s left and right children. If a node has only one child, then it is the left child of the node.
• #37: The heap structure can be characterized as an abstract data structure because the Java language (and others) does not include such data structure as a part of its language definition. An array is a concrete data structure that is a part of the Java language and the one which we can use effectively here to implement the abstract data structure heap. This slide shows the correspondence between the heap and the array representation. An important aspect in deciding which data structure to use is the ease of locating a given node’s left and right child. With an array implementation, we can locate any node’s left and right child easily. A node with index I has its left child at index 2ÞI + 1 and right child at index 2ÞI + 2.
• #38: private void construct( ) { int current, maxChildIndex; boolean done; for (int i = (heap.length-2) / 2; i >= 0; i--) { current = i; done = false; while ( !done ) {//perform one rebuild step //with the node at index i if ( 2*current+1 > heap.length-1 ) { //current node has no children, so stop done = true; } else { //current node has at least one child, //get the index of larger child maxChildIndex = maxChild( current, heap.length-1 ); if ( heap[current] < heap[maxChildIndex] ) { //a child is larger, so swap and continue swap( current, maxChildIndex ); current = maxChildIndex; } else { //the value relationship constraint //is satisfied, so stop done = true; } } } } testPrint( heap.length ); //TEMP }
• #39: private void extract( ) { int current, maxChildIndex; boolean done; for (int size = heap.length-1; size >= 0; size--) { //remove the root node data sortedList[size] = heap[ 0 ]; //move the last node to the root heap[ 0 ] = heap[size]; //rebuild the heap with one less element current = 0; done = false; while ( !done ) { if ( 2*current+1 > size ) {//current node has no children, so stop done = true; } else { //current node has at least one child, //get the index of larger child maxChildIndex = maxChild( current, size ); if ( heap[current] < heap[maxChildIndex] ) { //a child is larger, so swap and continue swap( current, maxChildIndex ); current = maxChildIndex; } else { //value relationship constraint //is satisfied, so stop done = true; } } } testPrint( size ); //TEMP } }
• #48: public int compareTo( Person person ) { int comparisonResult; if ( compareAttribute == AGE ) { int p2age = person.getAge( ); if (this.age < p2age) { comparisonResult = LESS; } else if (this.age == p2age) { comparisonResult = EQUAL; } else { //this.age > p2age comparisonResult = MORE; } } else { //compare names with String’s compareTo String p2name = person.getName( ); comparisonResult = this.name.compareTo( p2name ); } return comparisonResult; }
• #49: public Person[ ] sort ( int attribute ) { Person[ ] sortedList = new Person[ count ]; Person p1, p2, temp; //copy references to sortedList; see Figure 10.17 for (int i = 0; i < count; i++) { sortedList[i] = entry[i]; } //Set the comparison attribute Person.setCompareAttribute( attribute ); //begin the bubble sort on sortedList int bottom, i, comparisonResult; boolean exchanged = true; bottom = sortedList.length - 2; while ( exchanged ) { exchanged = false; for (i = 0; i <= bottom; i++) { p1 = sortedList[i]; p2 = sortedList[i+1]; comparisonResult = p1.compareTo(p2, attribute); if ( comparisonResult > 0 ) { //p1 is 'larger' sortedList[i] = p2; //than p2,so sortedList[i+1] = p1; //exchange exchanged = true; //exchange is made } } bottom--; } return sortedList; }
• #51: Please use your Java IDE to view the source files and run the program.
• #56: Please use your Java IDE to view the source files and run the program.
• #59: Please use your Java IDE to view the source files and run the program.