Unsorted Lists

Data Structures – Section 2-1

1
 What is a list?
• A list is a homogeneous collection of
elements.
• Linear relationship between elements:
(1) Each element except the first one has
a unique predecessor.
(2) Each element except the last one has
a unique successor.
• Length: the number of items in the list.

2
 What is an unsorted list?
• A list in which data items are placed in
no particular order.

What is a sorted list?

• A list in which data items are placed in a
particular order.
• Key: a member of the class whose value is
used to determine the order of the items in
the list.
3
4
 Operations
• MakeEmpty
• Boolean IsFull
• int LengthIs
• RetrieveItem (ItemType& item, Boolean& found)
• InsertItem (ItemType item)
• DeleteItem (ItemType item)
• ResetList
• void GetNextItem (ItemType& item)

5
RetrieveItem (ItemType& item,
Boolean& found)
• Function: Retrieves list element whose key
matches item's key (if present).

• Preconditions: (1) List has been initialized,

(2) Key member of item has been initialized.

• Postconditions: (1) If there is an element

someItem whose key matches item's key, then
found=true and item is a copy of someItem;
otherwise, found=false and item is unchanged,
(2) List is unchanged. 6
InsertItem (ItemType item)
• Function: Adds item to list

• Preconditions:
(1) List has been initialized,
(2) List is not full,
(3) item is not in list.

• Postconditions: item is in list.

7
 DeleteItem (ItemType item)
• Function: Deletes the element whose key
matches item's key

• Preconditions: (1) List has been

initialized, (2) Key member of item has
been initialized, (3) There is only one
element in list which has a key matching
item's key.

• Postconditions: No element in list has a

key matching item's key. 8
 ResetList
• Function: Initializes current position for
an iteration through the list.

• Preconditions: List has been initialized

• Postconditions: Current position is prior

to first element in list.

9
 void GetNextItem (ItemType&
item)
• Function: Gets the next element in list.

• Preconditions: (1) List has been

initialized,
(2) Current position is defined

• Postconditions: (1) Current position is

updated to next position, (2) item is a
copy of element at current position.
10
Unsorted List Implementation
template<class ItemType>
class UnsortedType {
public:
void MakeEmpty();
bool IsFull() const;
int LengthIs() const;
void RetrieveItem(ItemType&, bool&);
void InsertItem(ItemType);
void DeleteItem(ItemType);
void ResetList();
bool IsLastItem()
void GetNextItem(ItemType&);
private:
int length;
ItemType info[MAX_ITEMS];
int currentPos; 11
};
12
 Unsorted List Implementation
template<class ItemType>
(cont.)
void UnsortedType<ItemType>::MakeEmpty()
{
length = 0;
}

template<class ItemType>
bool UnsortedType<ItemType>::IsFull() const
{
return (length == MAX_ITEMS);
}

template<class ItemType>
int UnsortedType<ItemType>::LengthIs() const
{
return length;
} 13
14
 Unsorted List Implementation
(cont.)
template<class ItemType>
void UnsortedType<ItemType>::RetrieveItem (ItemType& item,
bool& found)
{
int location = 0;
found = false;
while( (location < length) && !found)
if (item == info[location]) {
found = true;
item = info[location];
}
else
location++;
}
15
 Unsorted List Implementation
(cont.)

template<class ItemType>
void UnsortedType<ItemType>::InsertItem (ItemType
item)
{
info[length] = item;
length++;
}

16
 Unsorted List Implementation
(cont.)
template<class ItemType>
void UnsortedType<ItemType>::DeleteItem(ItemType item)
{
int location = 0;

while(item != info[location])
location++;

info[location] = info[length - 1];

length--;
}

17
18
 Unsorted List Implementation
template<class ItemType>
(cont.)
void UnsortedType<ItemType>::ResetList()
{
currentPos = -1;
}

template<class ItemType>
bool UnsortedType<ItemType>::IsLastItem()
{
return(currentPos == length - 1);
}

template<class ItemType>
void UnsortedType<ItemType>::GetNextItem (ItemType& item)
{
currentPos++;
item = info[currentPos];
} 19
20
Write a client function that splits an
unsAorted list into two unsorted lists
using the following specification.

SplitLists (UnsortedType list, ItemType item,

UnsortedType& list1, UnsortedType&
list 2)

Function: Divides list into two lists according to the key

of item.
Preconditions: list has been initialized and is not
empty.
Postconditions: list1 contains all the items of list
whose keys are less than or equal to item’s key. list2
contains all the items of list whose keys are greater 21
than item’s key.
ItemType listItem;

list.ResetList();
while ( !list.IsLastItem()) {
list.GetNextItem(listItem);
if(listItem > item) {
if (!list2.IsFull())
list2.InsertItem(listItem);
}
else {
if ( !list1.IsFull())
list1.InsertItem(listItem);
}
} 22