820 likes | 951 Vues
0. C++ Programming: From Problem Analysis to Program Design, Second Edition. Chapter 17: Linked Lists. 0. Objectives. In this chapter you will: Learn about linked lists Become aware of the basic properties of linked lists Explore the insertion and deletion operations on linked lists
E N D
0 C++ Programming: From Problem Analysis to Program Design, Second Edition Chapter 17: Linked Lists
0 Objectives In this chapter you will: • Learn about linked lists • Become aware of the basic properties of linked lists • Explore the insertion and deletion operations on linked lists • Discover how to build and manipulate a linked list • Learn how to construct a doubly linked list C++ Programming: From Problem Analysis to Program Design, Second Edition
0 Introduction • Data can be organized and processed sequentially using an array, called a sequential list • Problems with an array • Array size is fixed • Unsorted array: searching for an item is slow • Sorted array: insertion and deletion is slow C++ Programming: From Problem Analysis to Program Design, Second Edition
0 Linked Lists • Linked list: collection of components (nodes) • Every node (except last) has address of next node • Every node has two components • Address of the first node of the list is stored in a separate location, called head or first C++ Programming: From Problem Analysis to Program Design, Second Edition
‘X’ ‘C’ ‘L’ head 0 A Linked List • a linked list is a list in which the order of the components is determined by an explicit link member in each node • the nodes are structs--each node contains a component member and also a link member that gives the location of the next node in the list C++ Programming: From Problem Analysis to Program Design, Second Edition
head “Ted” “Irv” “Lee” 0 Dynamic Linked List • in a dynamic linked list, nodes are linked together by pointers, and an external pointer (or head pointer) points to the first node in the list C++ Programming: From Problem Analysis to Program Design, Second Edition
3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL 0 Nodes can be located anywhere in memory • the link member holds the memory address of the next node in the list head C++ Programming: From Problem Analysis to Program Design, Second Edition
‘A’6000 .info .link 0 Declarations for a Dynamic Linked List // Type DECLARATIONS struct NodeType { char info; NodeType* link; } // Variable DECLARATIONS NodeType* head; NodeType* ptr; 8
ptr .info .link ptr ‘A’ 6000 .info .link *ptr ptr ‘A’ 6000 .info .link (*ptr).info ptr->info 0 Pointer Dereferencing and Member Selection ‘A’ 6000 ptr 9
ptr .info .link 0 ptr is a pointer to a node ‘A’ 6000 ptr 10
ptr 0 *ptr is the entire node pointed to by ptr ‘A’ 6000 .info .link *ptr 11
ptr .info .link 0 ptr->infois a node member ‘A’ 6000 ptr->info (*ptr).info // equivalent 12
ptr .info .link 0 ptr->linkis a node member ‘A’ 6000 ptr->link (*ptr).link // equivalent 13
ptr 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 3000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 3000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 3000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 5000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 5000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 5000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 2000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 2000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr 2000 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr NULL 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
ptr NULL 3000 5000 2000 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL head 0 Traversing a Dynamic Linked List //PRE: head points to a dynamic linked list ptr = head ; while (ptr != NULL) { cout << ptr->info ; // Or, do something else with node *ptr ptr = ptr->link ; } C++ Programming: From Problem Analysis to Program Design, Second Edition
0 Using Operator new If memory is available in an area called the free store (or heap), operator new allocates the requested object, and returns a pointer to the memory allocated. The dynamically allocated object exists until the delete operator destroys it. 26
‘X’ ‘C’ ‘L’ head 0 Inserting a Node at the Front of a List ‘B’ item char item = ‘B’; NodeType* location; location = new NodeType; location->info = item; location->link = head; head = location;
‘X’ ‘C’ ‘L’ head 0 Inserting a Node at the Front of a List ‘B’ item char item = ‘B’; NodeType* location; location = new NodeType; location->info = item; location->link = head; head = location; location
‘X’ ‘C’ ‘L’ head 0 Inserting a Node at the Front of a List ‘B’ item char item = ‘B’; NodeType* location; location = new NodeType; location->info = item; location->link = head; head = location; location
‘X’ ‘C’ ‘L’ head 0 Inserting a Node at the Front of a List ‘B’ item char item = ‘B’; NodeType* location; location = new NodeType; location->info = item; location->link = head; head = location; ‘B’ location
‘X’ ‘C’ ‘L’ head 0 Inserting a Node at the Front of a List ‘B’ item char item = ‘B’; NodeType* location; location = new NodeType; location->info = item; location->link = head; head = location; ‘B’ location
head 0 Inserting a Node at the Front of a List ‘B’ item char item = ‘B’; NodeType* location; location = new NodeType; location->info = item; location->link = head; head = location; ‘X’ ‘C’ ‘L’ ‘B’ location
0 Using Operator delete The object currently pointed to by the pointer is deallocated, and the pointer is considered undefined. The object’s memory is returned to the free store. 33
head 0 Deleting the First Node from the List item NodeType* tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; ‘B’ ‘X’ ‘C’ ‘L’ tempPtr
head 0 Deleting the First Node from the List ‘B’ item NodeType * tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; ‘B’ ‘X’ ‘C’ ‘L’ tempPtr
head 0 Deleting the First Node from the List ‘B’ item NodeType * tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; ‘B’ ‘X’ ‘C’ ‘L’ tempPtr
head 0 Deleting the First Node from the List ‘B’ item NodeType * tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; ‘B’ ‘X’ ‘C’ ‘L’ tempPtr
head 0 Deleting the First Node from the List ‘B’ item NodeType * tempPtr; item = head->info; tempPtr = head; head = head->link; delete tempPtr; ‘X’ ‘C’ ‘L’ tempPtr
0 What is a List? • a list is a varying-length, linear collection of homogeneous elements • linear means each list element (except the first) has a unique predecessor, and each element (except the last) has a unique successor
0 struct NodeType // SPECIFICATION FILE DYNAMIC-LINKED SORTED LIST( slist2.h ) struct NodeType { char item ; // Data (char to keep example simple) NodeType* link ; // link to next node in list } ; 40
0 // SPECIFICATION FILE DYNAMIC-LINKED SORTED LIST( slist2.h ) class SortedList2 { public : bool IsEmpty () const ; void Print ( ) const ; void InsertTop ( /* in */ char item ) ; void Insert ( /* in */ char item ) ; void DeleteTop ( /* out */ char& item ) ; void Delete ( /* in */ char item ); SortedList2 ( ) ; // Constructor ~SortedList2 ( ) ; // Destructor SortedList2 ( const SortedList2& otherList ) ; // Copy-constructor private : NodeType* head; } ; 41
‘C’ ‘L’ ‘X’ 0 class SortedList2 SortedList2 Private data: head ~SortedList2 IsEmpty Print InsertTop Insert DeleteTop Delete
0 Insert Algorithm • what will be the algorithm to Insert an item into its proper place in a sorted linked list? • that is, for a linked list whose elements are maintained in ascending order?
0 Insert algorithm for SortedList2 • find proper position for the new element in the sorted list using two pointers prevPtr and currPtr, where prevPtr trails behind currPtr • obtain a node for insertion and place item in it • insert the node by adjusting pointers
0 Implementing SortedList2Member Function Insert // DYNAMIC LINKED LIST IMPLEMENTATION (slist2.cpp) void SortedList2 :: Insert ( /* in */ char item ) // PRE: item is assigned && List components in ascending order // POST: item is in List && List components in ascending order { . . . }
‘C’ ‘L’ ‘X’ 0 Inserting ‘S’ into a Sorted List prevPtr currPtr Private data: head
‘C’ ‘L’ ‘X’ 0 Finding Proper Position for ‘S’ prevPtr currPtr NULL Private data: head
‘C’ ‘L’ ‘X’ 0 Finding Proper Position for ‘S’ prevPtr currPtr Private data: head
‘C’ ‘L’ ‘X’ 0 Finding Proper Position for ‘S’ prevPtr currPtr Private data: head
‘S’ 0 Inserting ‘S’ into Proper Position prevPtr currPtr Private data: head ‘C’ ‘L’ ‘X’