Presentation is loading. Please wait.

Presentation is loading. Please wait.

1 Understanding the Need for Sorting Records Sequential order: records are arranged based on the value in a field –Examples: Student Id, Social Security.

Similar presentations


Presentation on theme: "1 Understanding the Need for Sorting Records Sequential order: records are arranged based on the value in a field –Examples: Student Id, Social Security."— Presentation transcript:

1 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 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 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 4 Figure 9-1 Program segment that swaps two values

5 Swap to number int 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 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 7 Figure 9-2 The SortScores program

8 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 9 Figure 9-3 The fillArray() method

10 fillArray() method void fillArray(int score[],int size) { int i=0; while(i { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com/13/4054467/slides/slide_10.jpg", "name": "fillArray() method void fillArray(int score[],int size) { int i=0; while(i

11 11 Figure 9-4 The incomplete sortArray() method

12 Incomplete sortArray() function void sortArray(int score[],int SIZE) { int x=0; int comps=size-1; while(xscore[x+1]) swap(score,x); x=x+1; } 12

13 13 Figure 9-5 The swap() method

14 Swap() method void swap(int score[],int x) { int temp; temp=score[x+1]; score[x+1]=score[x]; score[x]=temp; } 14

15 15 Using a Bubble Sort (continued) Start with x = 0, compare first pair and swap score[0] = 90 score[1] = 85 score[2] = 65 score[3] = 95 score[4] = 75 score[0] = 85 score[1] = 90 score[2] = 65 score[3] = 95 score[4] = 75 x = 1, compare with next and swap score[0] = 85 score[1] = 90 score[2] = 65 score[3] = 95 score[4] = 75 score[0] = 85 score[1] = 65 score[2] = 90 score[3] = 95 score[4] = 75

16 16 Using a Bubble Sort (continued) With x = 2, no swap needed score[0] = 85 score[1] = 65 score[2] = 90 score[3] = 95 score[4] = 75 score[0] = 85 score[1] = 65 score[2] = 90 score[3] = 95 score[4] = 75 x = 3, compare with x = 4 and swap score[0] = 85 score[1] = 65 score[2] = 90 score[3] = 95 score[4] = 75 score[0] = 85 score[1] = 65 score[2] = 90 score[3] = 75 score[4] = 95

17 17 Figure 9-6 The completed sortArray() method

18 The complete sortArray() void sortArray(int score[],int SIZE) { int x=0,y=0; int comps=size-1; while(yscore[x+1]) swap(score,x); x=x+1; } y=y+1; } 18

19 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 20 Figure 9-6 The displayArray() method

21 displayArray() void displayArray(int score[],int SIZE) { int x=0; while(x { "@context": "http://schema.org", "@type": "ImageObject", "contentUrl": "http://images.slideplayer.com/13/4054467/slides/slide_21.jpg", "name": "displayArray() void displayArray(int score[],int SIZE) { int x=0; while(x

22 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 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 24 Figure 9-9 Flowchart and pseudocode for sortArray() method using pairsToCompare variable

25 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

26 26 Figure 9-10 Flowchart and pseudocode for sortArray() method using switchOccurred variable

27 27 Figure 9-10 Flowchart and pseudocode for sortArray() method using switchOccurred variable (continued)

28 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 29 Figure 9-11 Movement of the value 75 to a “better” array position in an insertion point

30 30 Figure 9-12 Insertion sort

31 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 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 33 Figure 9-13 A selection sort method

34 34 Figure 9-13 A selection sort method (continued)

35 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 36 Figure 9-14 View of a single-dimensional array in memory

37 37 Table 9-1 Rent schedule based on floor and number of bedrooms

38 38 Figure 9-15 Two-dimensional rent array based on rent schedule in Table 9-1

39 39 Figure 9-16 A program that determines rents

40 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 41 Table 9-2 Typical useful methods of the Array class

42 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 43 Table 9-3 Sample index

44 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 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 46 Table 9-4 Sample linked customer list

47 47 Table 9-5 Updated customer list

48 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 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 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 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 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 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


Download ppt "1 Understanding the Need for Sorting Records Sequential order: records are arranged based on the value in a field –Examples: Student Id, Social Security."

Similar presentations


Ads by Google