1 understanding the need for sorting records sequential order: records are arranged based on the...
TRANSCRIPT
1
Understanding the Need for Sorting Records
• Sequential order: records are arranged based on the value in a field– Examples: Student Id, Social Security Number,
employee ID• Random order: records are in the order in which
they were added• Sorting: placing the records in order, based on the
values in one or more fields• Ascending order: arranged from lowest to highest• Descending order: arranged from highest to lowest
2
Understanding the Need for Sorting Records (continued)
• Median value: the middle item when values are listed in order
• Mean value: arithmetic average
• Computer always sorts based on numeric values– Character data is sorted by its numeric code value– “A” is less than “B”– Whether “A” is greater than “a” is system dependent
3
Understanding How to Swap Two Values
• Swapping two values central to most sorting techniques
• When swapping two variables, reverse their position
• Use a temporary variable to hold one value
4
Figure 9-1 Program segment that swaps two values
Swap to numberint main(){
int No1,No2,temp;No1=6;No2=10;temp=No1;No1=No2;No2=temp;printf(“No1=%d”,No1);printf(“No2=%d”,No2);return 0;
}
5
6
Using a Bubble Sort
• Bubble sort: one of the simplest sorting techniques• Items in a list compared in pairs• If an item is out of order, it swaps places with the
item below it• In an ascending sort, after a complete pass through
the list:– Largest item “sunk” to the bottom – Smallest item “bubbled” to the top
7
Figure 9-2 The SortScores program
Program to sort test score
int main()
{
const int SIZE=5;
int score[SIZE];
fillArray(score,SIZE);
sortArray(score,SIZE);
displayArray(score,SIZE);
return 0;
}
8
9
Figure 9-3 The fillArray() method
fillArray() method
void fillArray(int score[],int size)
{
int i=0;
while(i<size)
{
printf(“Enter score”);
scanf(“%d”,&score[i];
i=i+1;
}
}10
11
Figure 9-4 The incomplete sortArray() method
Incomplete sortArray() functionvoid sortArray(int score[],int SIZE)
{
int x=0;
int comps=size-1;
while(x<comps)
{
if(score[x]>score[x+1])
swap(score,x);
x=x+1;
}
}12
13
Figure 9-5 The swap() method
Swap() method
void swap(int score[],int x)
{
int temp;
temp=score[x+1];
score[x+1]=score[x];
score[x]=temp;
}
14
15
Using a Bubble Sort (continued)• Start with x = 0, compare first pair and swap
score[0] = 90score[1] = 85score[2] = 65score[3] = 95score[4] = 75
score[0] = 85score[1] = 90score[2] = 65score[3] = 95score[4] = 75
• x = 1, compare with next and swap
score[0] = 85score[1] = 90score[2] = 65score[3] = 95score[4] = 75
score[0] = 85score[1] = 65score[2] = 90score[3] = 95score[4] = 75
16
Using a Bubble Sort (continued)• With x = 2, no swap needed
score[0] = 85score[1] = 65score[2] = 90score[3] = 95score[4] = 75
score[0] = 85score[1] = 65score[2] = 90score[3] = 95score[4] = 75
• x = 3, compare with x = 4 and swap
score[0] = 85score[1] = 65score[2] = 90score[3] = 95score[4] = 75
score[0] = 85score[1] = 65score[2] = 90score[3] = 75score[4] = 95
17
Figure 9-6 The completed sortArray() method
The complete sortArray()void sortArray(int score[],int SIZE){
int x=0,y=0;int comps=size-1;while(y<comps){
x=0;while(x<comps){
if(score[x]>score[x+1])swap(score,x);
x=x+1;}y=y+1;
}}
18
19
Using a Bubble Sort (continued)
• Use nested loops for sorting an array
• Inner loop makes the pair comparisons
• Greatest number of comparisons is one less than the number of array elements
• Outer loop controls the number of times to process the list– One less than the number of array elements
20
Figure 9-6 The displayArray() method
displayArray()void displayArray(int score[],int SIZE)
{
int x=0;
while(x<SIZE);
{
printf(“%d”,score[x]);
x=x+1;
}
}
21
22
Sorting a List of Variable Size
• Use a variable to hold the number of array elements• Declare the array with a large fixed size• Count the number of input elements• Store count in variable• Use the variable to determine size of array
23
Refining the Bubble Sort by Reducing Unnecessary Comparisons
• After the first pass through the array:– Largest item must be at the end of array– Second largest item must be at the second-to-last
position in the array
• Not necessary to compare those two values again
• On each subsequent pass through the array, stop the pair comparisons one element sooner
24
Figure 9-9 Flowchart and pseudocode for sortArray() method using pairsToCompare variable
25
Refining the Bubble Sort by Eliminating Unnecessary Passes
• Need one fewer pass than the number of elements to completely sort the array
• Can reduce the number of passes if array is somewhat ordered already
• Use a flag variable to indicate if there were any swaps during a single pass
• If no swaps, the array is completely sorted
26Figure 9-10 Flowchart and pseudocode for sortArray() method using switchOccurred variable
27Figure 9-10 Flowchart and pseudocode for sortArray() method using switchOccurred variable (continued)
28
Using an Insertion Sort
• Bubble sort is one of the least efficient sorting methods
• Insertion sort requires fewer comparisons• Compare a pair of elements• If an element is smaller than the previous one, search
the array backward from that point– Insert this element at the proper location
29
Figure 9-11 Movement of the value 75 to a “better” array position in an insertion point
30
Figure 9-12 Insertion sort
31
Using a Selection Sort
• Selection sort: two variables store the smallest value and its position in the array
• Store first element value and its position in variables• Compare it to the next element
– If next element is smaller, put its value and position in the variables
• Continue until end of array, at which time the smallest value and its position are in the variables
• Swap the first element value and position with the element and position stored in the variables
32
Using a Selection Sort (continued)
• Start at the second element in the array and repeat the process
• Continue until all elements except the last have been designated as the starting point
• After making one fewer pass than the number of elements, the array is sorted
33
Figure 9-13 A selection sort method
34
Figure 9-13 A selection sort method (continued)
35
Using Multidimensional Arrays
• One-dimensional (single-dimensional) array– Represents a single list of values
• Multidimensional array – A list with two or more related values in each position
• Two-dimensional array– Represents values in a table or grid containing rows
and columns– Requires two subscripts
• Three-dimensional array– Supported by many programming languages– Requires three subscripts
36
Figure 9-14 View of a single-dimensional array in memory
37
Table 9-1 Rent schedule based on floor and number of bedrooms
38
Figure 9-15 Two-dimensional rent array based on rent schedule in Table 9-1
39
Figure 9-16 A program that determines rents
40
Using a Built-In ARRAY Class
• Similar tasks frequently performed on different arrays– Example: filling and sorting
• Modern programming languages provide an Array class
• Newer languages have vast libraries– Contain built-in methods
• Most useful Array class contains overloaded versions of each method call for each data type– Different versions of sort() for numeric and string
elements• If no Array class available, write your own
41
Table 9-2 Typical useful methods of the Array class
42
Using Indexed Files
• Large data file to be accessed in sorted order; usually one field determines the sorting
• Key field: field whose contents make the record unique
• Indexing records: list of key fields paired with corresponding file position
• Sorting indexes faster than physically sorting actual records
• Random-access storage device: records accessed in any order
43
Table 9-3 Sample index
44
Using Indexed Files (continued)
• Address: location within computer memory or storage
• Every data record on disk has an address
• Index: holds physical addresses and key field values
• Data file in physical order– Index sorted in logical order
• When a record is removed from an indexed file, deleted from the index file– Not physically removed
45
Using Linked Lists
• Linked list: requires one extra field in every record– Holds the physical address of next logical record
• Add a new record:– Search the linked list for the correct logical location– Insert the new record
• Link previous record to new record• Link new record to next record
• Delete a record by unlinking it• More sophisticated linked lists store a next and a
previous field– Traversed both forward and backward
46
Table 9-4 Sample linked customer list
47
Table 9-5 Updated customer list
48
Summary
• Sort data records based on the contents of one or more fields– Ascending order– Descending order
• Swap two values– Temporary variable holds one of the values
• Bubble sort – Compares pairs– Swaps with item below– Ascending bubble sort, largest item sinks to bottom
• Smallest item rises to the top
49
Summary (continued)
• Bubble sort (continued)– Eliminate unnecessary comparisons in each pass and
eliminate unnecessary passes to improve bubble sort– Size of list to be sorted may vary
• Count values to be sorted
• Initialize array with count variable when value is known
– Bubble sort improved by stopping comparisons one element sooner on each pass
– Bubble sort improved by stopping when all items sorted• Flag variable indicates when any item is swapped
– Indicates when no items swapped in one pass through
50
Summary (continued)
• Insertion sort usually requires fewer comparisons– Pairwise comparisons– Locate out-of-order element
• Search array backward to a smaller element• Move each element down one• Insert out-of-order element into open position
51
Summary (continued)
• Ascending selection sort– First element assumed to be smallest
• Value and position stored in variables– Every subsequent element tested
• Smallest element found, value and position saved– Lowest value in first position after one pass through
array
52
Summary (continued)
• One-dimensional array– Also called single-dimensional array– Single column of values– Accessed with a single subscript
• Most object-oriented languages support two-dimensional arrays– Both rows and columns– Two subscripts
53
Summary (continued)
• Array class contains useful methods for manipulating arrays
• Indexed files access data records in a logical order– Differs from physical order– Must identify key field for each record
• Linked list contains extra field within every record– Extra field holds physical address of next logical
record