ADT Sorted List

1

• Chapter 4
• ADT Sorted List

2
Sorted Type Class Interface Diagram
SortedType class
MakeEmpty
Private data length info 0
1 2
MAX_ITEMS-1 currentPos
IsFull
GetLength
GetItem
PutItem
DeleteItem
ResetList
GetNextItem
2
3
Member functions

• Which member function specifications and
  implementations must change to ensure that any
  instance of the Sorted List ADT remains sorted at
  all times?
• PutItem
• DeleteItem

3
4
InsertItem algorithm for SortedList ADT

• 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.

4
5
Implementing SortedType member function PutItem

// IMPLEMENTATION FILE
(sorted.cpp) include itemtype.h //
also must appear in client code void SortedType
PutItem ( ItemType item ) // Pre List has
been initialized. List is not full. // item is
not in list. // List is sorted by key member
using function ComparedTo. // Post item is in
the list. List is still sorted. . . .
5
6

• void SortedType PutItem ( ItemType item )
• bool moreToSearch
• int location 0
• // find proper location for new element
• moreToSearch ( location lt length )
• while ( moreToSearch )
• switch ( item.ComparedTo( infolocation ) )
• case LESS moreToSearch false
• break
• case GREATER location
• moreToSearch ( location lt length
  )
• break
• // make room for new element in sorted
  list
• for ( int index length index gt location
  index-- )
• info index info index - 1
• info location item
• length

6
7
DeleteItem algorithm for SortedList ADT

• Find the location of the element to be deleted
  from the sorted list.
• Eliminate space occupied by the item by moving up
  all the list elements that follow it.
• Decrement length.

7
8
Implementing SortedType member function
DeleteItem

// IMPLEMENTATION FILE continued
(sorted.cpp) void SortedType DeleteItem (
ItemType item ) // Pre List has been
initialized. // Key member of item is
initialized. // Exactly one element in list has
a key matching items key. // List is sorted by
key member using function ComparedTo. // Post
No item in list has key matching items key. //
List is still sorted. . . .
8
9

• void SortedType DeleteItem ( ItemType item )
• int location 0
• // find location of element to be deleted
• while ( item.ComparedTo ( infolocation ) !
  EQUAL )
• location
• // move up elements that follow deleted item in
  sorted list
• for ( int index location 1 index lt
  length index )
• info index - 1 info index
• length--

9
10
Improving member function GetItem

• Recall that with the Unsorted List ADT
• we examined each list element beginning
• with info 0 , until we either found a
• matching key, or we had examined all
• the elements in the Unsorted List.
• How can the searching algorithm be improved for
  Sorted List ADT?

10
11
Retrieving Eliot from aSorted List
length 4 info 0
Asad 1 Bradley
2 Henry 3 Maxwell
. .
. MAX_ITEMS-1
The sequential search for Eliot can stop when
Henry has been examined.
Why?
11
12
Binary Seach in a Sorted List

• Examines the element in the middle of the array.
  
• Is it the sought item?
• If so, stop searching.
• Is the middle element too small?
• Then start looking in second half of array.
• Is the middle element too large?
• Then begin looking in first half of the array.
• Repeat the process in the half of the list that
  should be examined next.
• Stop when item is found, or when there is nowhere
  else to look and item has not been found.

12
13

• ItemType SortedTypeGetItem ( ItemType item,
  bool found )
• // Pre Key member of item is initialized.
• // Post If found, items key matches an
  elements key in the list
• // and a copy of that element is returned
  otherwise,
• // original item is returned.
• int midPoint
• int first 0
• int last length - 1
• bool moreToSearch ( first lt last )
• found false
• while ( moreToSearch !found )
• midPoint ( first last ) / 2 // INDEX
  OF MIDDLE ELEMENT
• 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

13
14
Trace of Binary Search
item 45

first
midPoint
last
15 26 38 57 62 78
84 91 108 119
info0 1 2 3
4 5 6 7
8 9
first midPoint last
14
15
Trace continued
item 45

first, last
midPoint
first,
midPoint,
last
15
16
Trace concludes
item 45

last first


16
17

• ItemType SortedTypeGetItem ( ItemType item,
  bool found )
• // ASSUMES info ARRAY SORTED IN ASCENDING ORDER
• int midPoint
• int first 0
• int last length - 1
• bool moreToSearch ( first lt last )
• found false
• while ( moreToSearch !found )
• midPoint ( first last ) / 2
• switch ( item.ComparedTo( info midPoint ) )
• case LESS last midPoint -
  1
• moreToSearch ( first lt last )
• break
• case GREATER first midPoint 1
• moreToSearch ( first lt last )
• break
• case EQUAL found true
• item info midPoint

17
18
Allocation of memory
STATIC ALLOCATION Static
allocation is the allocation of memory space at
compile time.
DYNAMIC ALLOCATION Dynamic
allocation is the allocation of memory space at
run time by using operator new.
18
19
3 Kinds of Program Data

• STATIC DATA memory allocation exists throughout
  execution of program.
• static long SeedValue
• AUTOMATIC DATA automatically created at function
  entry, resides in activation frame of the
  function, and is destroyed when returning from
  function.
• DYNAMIC DATA explicitly allocated and
  deallocated during program execution by C
  instructions written by programmer using unary
  operators new and delete

19
20
Arrays created at run time

• If memory is available in an area called the free
  store (or heap), operator new allocates memory
  for the object or array and returns the address
  of (pointer to) the memory allocated.
• Otherwise, the NULL pointer 0 is returned.
• The dynamically allocated object exists until the
  delete operator destroys it.

20
21
Dynamic Array Allocation
char ptr // ptr is a pointer variable
that // can hold the
address of a char ptr new char 5
// dynamically, during run time, allocates
// memory for 5 characters and places into
// the contents of ptr their beginning
address
6000
6000
ptr
21
22
Dynamic Array Allocation
char ptr ptr new char 5
strcpy( ptr, Bye ) ptr 1 u // a
pointer can be subscripted stdcout ltlt ptr 2

6000
u
6000
B y e \0
ptr
22
23

class SortedTypeltchargt
SortedType
Private data length
3 listData currentPos ?
MakeEmpty
SortedType
RetrieveItem
InsertItem
DeleteItem . . .
GetNextItem
23
24
InsertItem algorithm for Sorted Linked List

• Find proper position for the new element in the
  sorted list using two pointers predLoc and
  location, where predLoc trails behind location.
• Obtain a node for insertion and place item in it.
• Insert the node by adjusting pointers.
• Increment length.

24
25
The Inchworm Effect
25
26
Inserting S into a Sorted List
predLoc location
Private data length
3 listData currentPos ?
26
27
Finding proper position for S
predLoc location
NULL
Private data length
3 listData currentPos ?
27
28
Finding proper position for S
predLoc location
Private data length
3 listData currentPos ?
28
29
Finding Proper Position for S
predLoc location
Private data length
3 listData currentPos ?
29
30
Inserting S into Proper Position
predLoc location
Private data length
4 listData currentPos
C L X
30
31
Why is a destructor needed?

• When a local list variable goes out of scope, the
  memory space for data member listPtr is
  deallocated.
• But the nodes to which listPtr points are not
  deallocated.
• A class destructor is used to deallocate the
  dynamic memory pointed to by the data member.

31
32
Implementing the Destructor

• SortedTypeSortedType()
• // Post List is empty all items have
• // been deallocated.
• NodeType tempPtr
• while (listData ! NULL)
• tempPtr listData
• listData listData-gtnext
• delete tempPtr

32
33
How do the SortedList implementations compare?
33
34
SortedList implementations comparison
34
35
List implementations comparison
36

• Chapter 6
• Lists Plus

37
What is a Circular Linked List?

• A circular linked list is a list in which every
  node has a successor the last element is
  succeeded by the first element.

38
External Pointer to the Last Node
39
What is a Doubly Linked List?

• A doubly linked list is a list in which each node
  is linked to both its successor and
  its predecessor.

40
Linking the New Node into the List
41
Deleting from a Doubly Linked List
What are the advantages of a circular doubly
linked list?
42
What are Header and Trailer Nodes?

• A Header Node is a node at the beginning of a
  list that contains a key value smaller than any
  possible key.
• A Trailer Node is a node at the end of a list
  that contains a key larger than any possible key.
• Both header and trailer are placeholding nodes
  used to simplify list processing.

43
A linked list in static storage ?

• A Linked List as an Array of Records

44
A Sorted list Stored in an Array of Nodes
45
An Array with Linked List of Values and Free Space
46
An Array with Three Lists (Including the Free
List)
47
Overview
48
Overview

• Inserting into an unsorted list and inserting
  into a sorted list are the same time complexity.
• In a sorted list, there is a semantic
  relationship between successive items in the
  list.
• Deleting from a sorted array based list requires
  that the elements below the one being deleted be
  moved up one slot.
• Searching an unsorted list and a sorted list are
  always the same time complexity.
• You can perform a binary search on both a linked
  and an array-based implementation of a sorted
  list.
• To dynamically allocate an array-based list there
  should be a parameterized constructor.

49
Overview

• the order of the operation that determines if an
  item is in
• a list in a sorted, array-based implementation
• a list in an unsorted, array-based implementation
• a list in a sorted, linked implementation
• a list in an unsorted, linked implementation

O(log N)
O(N)
O(N)
O(N)
50
Overview

• // Pre List contains valid data and List is
  sorted by key using function
• // ComparedTo.
• // There is at most one list item with the same
  key as item there may be none.
• // Post No list element has the same key as
  item. List is still sorted.
• void SortedTypeDeleteItem(ItemType item)
• int location 0
• int index
• bool moreToSearch
• moreToSearch ____________________
• bool found false
• while ( !found _______________)
• switch (item.ComparedTo(infolocation))
• case LESS location
• moreToSearch ____________________
• break
• case GREATER moreToSearch ___________________
  __
• break
• case EQUAL ________ true
• break

location lt length
moreToSearch
location lt length
false
found
infoindex
51
Overview

• // Pre List contains valid data, sorted by key
  values.
• // One and only one list item with the same
  key as item's is in the list.
• // Post No list element has the same key as
  item the list is still sorted.
• void SortedTypeDeleteItem(ItemType item)
• int location 0
• while (item.ComparedTo(infolocation) !
  ___________)
• location
• for (int index location 1
  ________________ index)
• infoindex - 1 infoindex
• ___________

EQUAL
index lt length
length--
52
Overview

• ItemType SortedTypeGetItem(ItemType item,
  bool found)
• // Uses binary search algorithm
• int midPoint
• int first ______________
• int last ______________
• bool moreToSearch _______________
• found false
• while (moreToSearch !found)
• midPoint (first last) / 2
• switch (item.ComparedTo(infomidPoint))
• case LESS last _______________
• moreToSearch first lt last
• break
• case GREATER first _______________
  moreToSearch first lt last
• break
• case EQUAL found true
• item _________________
• break

0
length - 1
first lt last
midPoint - 1
midPoint 1
infomidPoint