data structures intro/linked list review cis 237 – data structures
TRANSCRIPT
Data StructuresIntro/Linked List Review
CIS 237 – Data Structures
PseudocodeAlgorithm sample (ref pageNumber <integer>)This algorithm reads a file and prints a report.
Pre pageNumber must be initializedPost Report printed. pageNumber contains number of
pages in the report.Return number of lines printed.
1 Open file2 lines = 03 loop (not end of file) 1 read file 2 if (full page) 1 form feed
2 pageNumber = pageNumber + 13 write page heading
3 end if 4 write report line 5 lines = lines + 14 end loop5 close file6 return lines
Kinds of Data• Atomic Data
– integer
– floating point
– character
• Data Structure
– arrays
– classes
• Abstract Data Type
Abstract Data Type
• Characteristics– Declaration of data– Declaration of operations– Encapsulation of data and operations
• Abstraction
• Encapsulation
Designing Abstract Data Types
• classes/templates
• data
• member functions
• the “Big-3”
• overloading operators
ListsLinear Lists
General Restricted
Unordered
Ordered FIFO (queue)
LIFO (stack)
Linked Lists
• Component Type– Must work with operators used on
them
• Nodes
• The list
Linked Lists - Nodes
data
link
apple grape peach pear
Linked List - ADT
apple grape peach pear
head
count 4
head
count 0
Keyed List Data Structure
apple grape peach pear
head
count 4
• Simple List Operations– Empty– Create– Full*
Other List Operations• Size
• Ordered Insert (Ascending)
• Remove a Value
• Find a Value in the List
• Print List (overload of the operator << )
• The Destructor and Destroy
• = and the Copy Constructor and Copy
orderedInsert AlgorithmAlgorithm orderedInsert (val dataIn <dataType)
Inserts data into a new node in the linked list so the list is in ascending orderPre dataIn contains the data to be insertedPost data is inserted in sequenceReturn true if successful, false otherwise1. if list empty or dataIn < data at the head //inserting at head of list
• Create a new head with dataIn• If create fails return false
2. else
1. trailp = Null2. p = head3. while (p is not Null and dataIn is greater than p->data)
1. trailp = p2. p = p->next
4. end while5. trailp->next = a new node with data in as data and p as its next ptr6. if create fails return false
3. end if
4. count = count + 15. return true
Remove AlgorithmAlgorithm remove( dataout<dataType>)Deletes data from a linked list and returns success or failurePre dataOut is the dataPost node with data removed from listReturn true if found and removed, false if not there1. p = head2. trailp = Null3. while p is not Null and p->data not dataout
1. trailp = p2. p = p->next
4. end while5. if p is Null return false //not in list6. if p is head
1. head = head->next7. else
1. trailp->next = p->next8. end if9. delete p10. count = count -111. return true
Find Algorithm
Algorithm findList(target<dataType>)
Searches for the target and return success or failure
Pre target is the item with the value being sought
Return true if found, false otherwise
1. p = head
2. while p is not Null and p->data is not target
1. p = p->next
3. end while
4. if p is not Null and p->data equals target
1. return true
5. else
1. return false
6. end if
Destroy the list starting at LAlgorithm destroy(ref node L)
Deletes all the nodes in the list starting at L
Pre L contains the node at which to start destroying
Post nodes from L to end gone
1. while L is not null
1. doomed = L
2. L = L ->next
3. delete doomed
2. end while
AssignmentAlgorithm operator=(const ref rightList)
Makes a deep copy of the list from rightList to the current instance
Pre rightList is an initialized list
Return returns the current instance1. If (the current instance and the rightList are not the same)
1. destroy the current instance2. head is assigned the copy of the rightList3. count = rightList->count
2. end if3. return *this
Copy A ListAlgorithm copy (pointer Node L)
Makes a copy from the list that begins with L, does a deep copy
Pre L is a node at which to start copying
Post current instance contains a copy of the list
1. first = null
2. last = null
3. if L is not null
1. first = last = a new node with L->data as its data
2. for p = L->next; p not null; p = p->next, last=last->next
1. last->next = new node with p->data as data
3. end for
4. return first
4. end if
Operator <<
Algorithm operator<<(ostream &out, list l)
Prints each data item to out using an iterator. Data type must have << operator overloaded
Pre out must contain an output stream and a list
Post all values in list will be printed out
1. for itr.start(); itr.move(); itr.next()
1. out << itr.value() << “ “
2. end for
Dummy Header
grape peach pear
head
count 3
head
count 0
Dummy Header Changes• Constructor must create dummy
node
• Traversals begin at head->next
(head for trailer)
• Empty must check head->next
• No special cases– orderedInsert– remove
Sample - orderInsert
Algorithm orderedInsert (val dataIn <dataType)
Inserts data into a new node in the linked list so the list is in ascending orderPre dataIn contains the data to be insertedPost data is inserted in sequenceReturn true if successful, false otherwise1. trailp = head2. p = head->next3. while (p is not Null and dataIn is greater than p->data)
1. trailp = p2. p = p->next
4. end while5. trailp->next = a new node with data in as data and p as its next ptr6. if create fails return false
7. count = count + 18. return true
Doubly Linked List
grape peach pear
head
count 3
rear
count
head
0
rear
Changes for Doubly Linked List
• Node– Must now have a previous pointer
• List – Has rear– Constructor must now initialize rear
• Copy– Must create node with prev pointer– Must return the last node copied– Calls to copy must then include rear
Ascending Insert - doubly linked/dummy headerAlgorithm orderedInsert (val dataIn <dataType)
Inserts data into a new node in the linked list so the list is in ascending orderPre dataIn contains the data to be insertedPost data is inserted in sequenceReturn true if successful, false otherwise1. trailp = head2. p = head->next3. while (p is not Null and dataIn is greater than p->data)
1. trailp = p2. p = p->next
4. end while5. trailp->next = a new node with data in as data and p as its next ptr and trailp as prev ptr6. if create fails return false7. if trailp is the rear //either new rear or must set prev pointer of after node
1. rear is now trailp->next8. else
1. p->prev = trailp->next9. end if
10. count = count + 111. return true
Remove - doubly linked/dummy headerAlgorithm remove( dataout<dataType>)
Deletes data from a linked list and returns success or failurePre dataOut is the dataPost node with data removed from listReturn true if found and removed, false if not there1. p = head->next2. trailp = head3. while p is not Null and p->data not dataout
1. trailp = p2. p = p->next
4. end while5. if p is Null return false //not in list6. trailp->next = p->next7. if p is rear //if deleting last node reset rear else set next node’s prev
ptr1. rear = trailp
8. else1. trailp->next->prev = trailp
9. end if10. delete p11. return true
Reverse Iterator• Parts
– Curr– Itr the list being iterated
• Last
• More
– Stops at itr.head not NULL
• Back
• Value
Complex Component Types
• Use any type
• Should have relational operators overloaded
• << overloaded if using overloaded << in
application
• Constructor in node/list
• Find
Circular List with a Dummy Header
grape peach pear
head
count 3
head
count 0
Changes For Circular List
• No need for rear– Reverse iterator start at itr.head->prev
• Loop control – List operations head not Null– Iterator operations itr.head
• Constructor set up next and prev• Insert/Remove eliminate rear check• Copy mark first element