1 / 45

Sorted List

Sorted List. CS3240. Goals. Describe the Abstract Data Type Sorted List from three perspectives Implement the following Sorted List operations using an array-based implementation Create and destroy a list Determine whether the list is full Insert an element Retrieve an element

pcunningham
Télécharger la présentation

Sorted List

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Sorted List CS3240

  2. Goals • Describe the Abstract Data Type Sorted List from three perspectives • Implement the following Sorted List operations using an array-basedimplementation • Create and destroy a list • Determine whether the list is full • Insert an element • Retrieve an element • Delete an element

  3. Goals • Implement the list operations outlined above using a linked implementation • Implement the binary search algorithm • Compare the two implementations of the ADT Sorted List in terms of Big-O approximations • Compare the implementations of the Unsorted List ADT and the Sorted List ADT in terms of Big-O Analysis • Distinguish between bounded and unbounded ADTs at the logical and implementation levels • Identify and apply the phases of the object-oriented methodology

  4. ADT Sorted List Remember the difference between an unsorted list and a sorted list? Remember the definition of a key? If the list is a sorted list of names, what would be the key? of bank balances, what would be the key? of grades, what would be the key?

  5. ADT Unsorted List Operations • Transformers • MakeEmpty • InsertItem • DeleteItem • Observers • IsFull • GetLength • RetrieveItem • Iterators • ResetList • GetNextItem change state observe state process all

  6. ADT Sorted List • Which member function specifications and implementations must change to ensure that any instance of the Sorted List ADT remains sorted at all times? • InsertItem • DeleteItem What about the other transformer MakeEmtpy?

  7. Array Implementation What do you have to do to insert Clair into the following list? Anne Betty Mary Susan

  8. Array Implementation • Find proper location for the new element in the sorted list • Create space for the new element by moving down all the list elements that will follow it • Put the new element in the list • Increment length

  9. Array Implementation • InsertItem Initialize location to position of first item Set moreToSearch to (have not examined Info(last)) while moreToSearch switch (item.ComparedTo(Info(location))) case LESS : Set moreToSearch to false case EQUAL : // Cannot happen case GREATER : Set location to Next(location) Set moreToSearch to (have not examined Info(last)) for index going from length DOWNTO location + 1 Set Info(index ) to Info(index-1) Set Info(location) to item Increment length Why can't EQUAL happen?

  10. Array Implementation • What were the conversions from notation to array-based code? • info(last) • info(location) • Next(location)

  11. Array Implementation • DeleteItem Initialize location to position of first item Set found to false while NOT found switch (item.ComparedTo(Info(location))) case GREATER : Set location to Next(location) case LESS : // Cannot happen case EQUAL : Set found to true for index going from location +1 TO length -1 Set Info(index - 1) to Info(index) Decrement length Why can't LESS happen?

  12. Array Implementation • Can we improve searching in a sorted list? • With the Unsorted List ADT we examined each list element beginning with info[ 0 ], until we found a matching key or we examined all the elements

  13. Binary Search Algorithm • Examine the element in the middle of the array • Match item? • Stop searching • Middle element too small? • Search second half of array • Middle element too large? • Search first half of array Is it the sought item? • Repeat the process in half that should be examined next • Stop when item is found or when there is nowhere else to look

  14. Binary Search Algorithm • void SortedType::RetrieveItem ( ItemType& item, bool& found ) • // Pre: Key member of item is initialized. • // Post: If found, item’s key matches an element’s key and a copy • // of element has been stored in item; otherwise, item is • // unchanged. • { int midPoint; • int first = 0; • int last = length - 1 • bool moreToSearch = ( first <= last ); • found = false; • while ( moreToSearch && !found ) • { midPoint = ( first + last ) / 2; • switch ( item.ComparedTo(info[midPoint]) ) • { • case LESS : . . . // LOOK IN FIRST HALF NEXT • case GREATER : . . . // LOOK IN SECOND HALF NEXT • case EQUAL : . . . // ITEM HAS BEEN FOUND • } • } • }

  15. 15 26 38 57 62 78 84 91 108 119 info[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] LESS last = midPoint - 1 GREATER first = midPoint + 1 Trace of Binary Search item = 45 first midPoint last 15 26 38 57 62 78 84 91 108 119 info[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] first midPoint last

  16. 15 26 38 57 62 78 84 91 108 119 info[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] first, last midPoint GREATER first = midPoint + 1 15 26 38 57 62 78 84 91 108 119 info[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] LESS last = midPoint - 1 Trace continued item = 45 first, midPoint, last

  17. InsertItem Find O(1) O(N) search Put O(1) O(N) moving down Combined O(1) O(N) DeleteItem Find O(N) O(N) search Put O(1) swap O(N) moving up Combined O(N) O(N) Array-Based Big-O Comparison OPERATION UnsortedList SortedList RetrieveItem O(N) O(N) linear search O(log2N) binary search

  18. Dynamically Allocated Arrays • { • public: SortedType(int max); // max is maximum list size SortedType(); // Default size is 500 // Rest of the prototypes go here • private: int length; int maxList; // Maximum number of list items ItemType* info; // Pointer to dynamically // allocated memory int currentPos; • }; What does this structure look like?

  19. Dynamically Allocated Arrays How do you access the array elements ?

  20. Linked Implementation • Does replacing algorithm terms with linked code work for the linked implementation of searching?

  21. Linked Implementation What about passing spot where item would be if there?

  22. Linked Implementation • Is Inserting as easy? Let's see Set location to listData Set moreToSearch to (location != NULL) while moreToSearch switch (item.ComparedTo(location->info)) case GREATER : Set location to location->next Set moreToSearch to (location != NULL) case LESS : Set moreToSearch to false See the problem ?

  23. Linked Implementation We need a trailing pointer

  24. ‘C’ ‘L’ ‘X’ moreToSearch Inserting ‘S’ into a Sorted List predLoc location Private data: length 3 listData currentPos ?

  25. ‘C’ ‘L’ ‘X’ moreToSearch true Finding proper position for ‘S’ predLoc location NULL Private data: length 3 listData currentPos ?

  26. ‘C’ ‘L’ ‘X’ moreToSearch true Finding proper position for ‘S’ predLoc location Private data: length 3 listData currentPos ?

  27. ‘C’ ‘L’ ‘X’ moreToSearch false Finding Proper Position for ‘S’ predLoc location Private data: length 3 listData currentPos ?

  28. ‘S’ moreToSearch false Inserting ‘S’ into Proper Position predLoc location Private data: length 4 listData currentPos ‘C’ ‘L’ ‘X’

  29. Linked Implementation • Does DeleteItem have to be changed?

  30. Big-O Comparison Which array-based operations are O(1)? Which linked operations are O(1)? Which array-based operations are O(N)? Which linked operations are O(N)? Can you say which implementation is better? Which sorted operations differ in Big-O from unsorted operations?

  31. Bounded and Unbounded ADTs • Bounded ADT • An ADT for which there is a logical limit on the number of items in the structure • Unbounded ADT • An ADT for which there is no logical limit on the number of items in the structure How do you relate the logical limit to the physical limit?

  32. Object-Oriented Design Methodology • Object-oriented design decomposes a problem into classes • Four stages to the decomposition process • Brainstorming • Filtering • Scenarios • Responsibility algorithms

  33. Object-Oriented Design Methodology • Brainstorming • A group problem-solving technique that involves the spontaneous contribution of ideas from all members of the group • All ideas are potential good ideas • Think fast and furiously first, and ponder later • A little humor can be a powerful force • Brainstorming is designed to produce a list of candidate classes

  34. Object-Oriented Design Methodology • Filtering • Determine which are the core classes in the problem solution • There may be two classes in the list that have many common attributes and behaviors • There may be classes that really don’t belong in the problem solution

  35. Object-Oriented Design Methodology • Scenarios • Sequences of steps that describe an interaction between a client and an application or program • Simulate class interactions • Ask “What if?” questions • Assign responsibilities to each class • There are two types of responsibilities • What a class must know about itself (knowledge) • What a class must be able to do (behavior) • Use case • A collection of scenarios related to a common goal

  36. Object-Oriented Design Methodology Role playing

  37. Object-Oriented Design Methodology • Responsibility Algorithms • The algorithms must be written for the responsibilities • Knowledge responsibilities usually just return the contents of one of an object’s variables • Action responsibilities are a little more complicated, often involving calculations Responsibilities algorithms are often decomposed using top-down design

  38. Relationships Between Classes • Containment • “part-of” • An address class may be part of the definition of a student class • Inheritance • Classes can inherit data and behavior from other classes • “is-a”

  39. Computer Example • Let’s work through this problem-solving process by creating an address list • Brainstorming and filtering • Circling the nouns and underlining the verbs is a good way to begin

  40. Computer Example • First pass at a list of classes list name telephone number email address list order names list scraps paper cards Filtered List list, name, telephone number, email address

  41. CRC Cards Can you think of any other useful responsibilities?

  42. CRC Cards Can you think of any other useful responsibilities?

  43. CRC Cards How is this class different from Name and Person?

  44. Responsibility Algorithms Person Class Initialize name.initialize() Write "Enter phone number; press return." Get telephone number Write "Enter email address; press return." Get email address Print name.print() Write "Telephone number: " + telephoneNumber Write "Email address: " + emailAddress Tells name to initialize itself Tells name to print itself

  45. Responsibility Algorithms Name Class Initialize "Enter the first name; press return." Read firstName "Enter the last name; press return." Read lastName Print Print "First name: " + firstName Print "Last name: " + lastName

More Related