1. Data Structures( 数据结构 ) Chapter3:Linked List

2. 2 西南财经大学天府学院 Vocabulary Linear List 线性表 Linked List 链表 Retrieval 检索 Traversal 遍历 Node 结点 Circularly Linked Lists 循环链表 Doubly Linked Lists 双向链表 Multilinked Lists 多重链表

3. 3 西南财经大学天府学院 3.1 Linear List Definition: A linear list is a list in which each element has a unique successor. Array is a typical linear list structure. Property: sequential Figure 3.1 A Linear List Element 1Element 2Element 3Element 4

4. 4 西南财经大学天府学院 3.1 Linear List Linear List Can be Divided in two categories  General(Unordered, Ordered)  restricted(FIFO,LIFO) Random List: No ordering of the data Ordered List: the data are arranged according to a Key Key: Use to identify the Data (Simple array, array of records structure)

5. 5 西南财经大学天府学院 3.1 Linear List Four Operation often associate with Linear Lists Insertion Deletion Retrieval( 检索） Traversal( 遍历）

6. 6 西南财经大学天府学院 3.1 Linear List Insertion Location Beginning of the list In the middle of the list At the end of the list Figure 3.3 Ordered List Insertion

7. 7 西南财经大学天府学院 3.1 Linear List Deletion(General List) Searching the location of the data to be deleted Remove the data from the list Figure 3.4 General List Deletion

8. 8 西南财经大学天府学院 3.1 Linear List Retrieval(General List) Locate the Data in the list No changing the contents of the lists Figure 3.5 Linear List Retrieval

9. 9 西南财经大学天府学院 3.1 Linear List Traversal A special case of retrieval All elements need to be retrieved in sequence Require loop algorithm Other processes(Sorting, Calculate the total values)

10. 10 西南财经大学天府学院 3.1 Linked list Definition: A linked list is an ordered collection of data in which each element contains the location of the next element; that is, each element contains two parts: data and link. a singly linked list: a linked list contains only one link to a single successor.

11. 11 西南财经大学天府学院 3.1 Linked list The major advantage of the linked list: the data of the linked list can be easily inserted and deleted. Nodes: The elements in a linked list are called nodes. The node in a linked list are called self-referential pHead datalink datalinkdatalink A linked list with a head pointer: pHead pHead An empty linked list

12. 12 西南财经大学天府学院 Linked List Data Structure Head Node Structure: It usually contains two parts: a pointer and metadata which are data about data in the list. Data Node Structure: The data type for the list depends entirely on the application. A typical data type is like: dataType key field1 field2 … fieldN End dataType dataType key field1 field2 … fieldN End dataType count head Head structure data link Data node structure metadata List count head End List Node data link End Node

13. 13 西南财经大学天府学院 3.2 Linked List Algorithms Create List: it receives the head structure and initializes the metadata for the list. The pseudocode algorithms: Algorithm createList(ref list ) Initializes metadata for a linked list. Pre list is metadata structure passed by reference Post metadata initialized 1 list.head = null 2 list.count = 0 3 return End createList Algorithm createList(ref list ) Initializes metadata for a linked list. Pre list is metadata structure passed by reference Post metadata initialized 1 list.head = null 2 list.count = 0 3 return End createList list.head = null list.count = 0 (a) before create ? ? list count head (b) after create 0 list count head

14. 14 西南财经大学天府学院 Insert Node 1.Allocate memory for the new node and insert data. 2.Point the new node to its successor. 3.Point the new node’s predecessor to the new node. We discuss four situation : insert into empty list insert at beginning insert in middle insert at end

15. 15 西南财经大学天府学院 Insert into empty list: pNew->link = list.head Set link to null pointer List.head = pNew Point list to first node pNew->link = list.head Set link to null pointer List.head = pNew Point list to first node 0 count head 75 pNew (a) before add 1 count head 75 pNew (b) after add

16. 16 西南财经大学天府学院 Insert at beginning pNew->link = list.head List.head = pNew pNew->link = list.head List.head = pNew 1 39 pNew 75 count head Before add After add 2 39 pNew counthead 75 Logically,inserting into an empty list is the same as inserting at the beginning of a list.

17. 17 西南财经大学天府学院 pNew->link = pPre->link pPre->link = pNew pNew->link = pPre->link pPre->link = pNew 2 pNew 39 count head Before add 75 52 pPre After add 3 52 pNew count head 3975 pPre Insert In Middle

18. 18 西南财经大学天府学院 Insert at end pNew->link = pPre->link pPre->link = pNew pNew->link = pPre->link pPre->link = pNew 3 count head 39 7552 pNew 134 pPre Before add After add 4 count head 39 7552 pPre pNew 134

19. 19 西南财经大学天府学院 Insert Node Algorithm Algorithm insertNode (ref list, val pPre, val dataIn ) 1allocate(pNew) 2if (memory overflow) 1 return false 3end if 4pNew->data=dataIn 5if (pPre null) 1 pNew->link =list.head 2 list.head = pNew 6else 1 pNew->link = pPre->link 2 pPre->link = pNew 7end if 8list.count = list.count+1 9Return ture end insertNode Algorithm insertNode (ref list, val pPre, val dataIn ) 1allocate(pNew) 2if (memory overflow) 1 return false 3end if 4pNew->data=dataIn 5if (pPre null) 1 pNew->link =list.head 2 list.head = pNew 6else 1 pNew->link = pPre->link 2 pPre->link = pNew 7end if 8list.count = list.count+1 9Return ture end insertNode Insert data into a new node in the linked list Pre List is metadata structure to a valid list pPre is pointer to data ’ s logical predecessor dataIn contains data to be inserted Post data have been inserted in sequence Return true if successful, false is memory overflow

20. 20 西南财经大学天府学院 Delete Node this algorithm logically removes a node from the linked list by: 1. changing various link pointers 2. physically deleting the node from dynamic memory. We discuss two situation : d elete first node (delete the only node in the list) g eneral delete case (delete the middle or last node)

21. 21 西南财经大学天府学院 Delete First Node list.head = pLoc->link recycle(pLoc) list.head = pLoc->link recycle(pLoc) 3 39 13475 Before delete pLoc pPre count head 2 13475 After delete pLoc pPre (Recyled) count head

22. 22 西南财经大学天府学院 General Delete Case pPre->link = pLoc->link recycle(pLoc) pPre->link = pLoc->link recycle(pLoc) 39 13475 pPre 3 Before delete pLoc counthead After delete 39 134 pPre 2 pLoc counthead (Recycled)

23. 23 西南财经大学天府学院 Delete Node Algorithm Algorithm DeleteNode (ref list, val pPre, val pLoc, ref dataOut ) 1Dataout = pLoc->data 2if (pPre null) 1 list.head = pLoc->link 3else 1 pPre->link = pLoc->link 4 end if 5 list.count = list.count - 1 6 recycle(pLoc) 7 Return end deleteNode Algorithm DeleteNode (ref list, val pPre, val pLoc, ref dataOut ) 1Dataout = pLoc->data 2if (pPre null) 1 list.head = pLoc->link 3else 1 pPre->link = pLoc->link 4 end if 5 list.count = list.count - 1 6 recycle(pLoc) 7 Return end deleteNode Deletes data from a linked list and returns it to calling module. Pre List is metadata structure to a valid list pPre is pointer to predecessor node pLoc is a pointer to node to be deleted dataout is variable to received deleted data Post data have been deleted and returned to caller

24. 24 西南财经大学天府学院 Search list Search list: it is used by several algorithms to locate data in a list. When we insert or delete or retrieve data from a list, we need to search the list and find the data.

25. 25 西南财经大学天府学院 Search list Algorithm searchList (val list ref pPre ref pLoc ref target 1pPre = null 2 pLoc = list.head 3Loop (pLoc not null AND target > pLoc->data.key) 1 pPre =pLoc 2 pLoc = pLoc->link 4end loop 5If (pLoc null) 1 found = false Algorithm searchList (val list ref pPre ref pLoc ref target 1pPre = null 2 pLoc = list.head 3Loop (pLoc not null AND target > pLoc->data.key) 1 pPre =pLoc 2 pLoc = pLoc->link 4end loop 5If (pLoc null) 1 found = false 6 else 1 if (target equal pLoc->data.key) 1 found = true 2 else 1 found = false 3 end if 7end if 8return found end searchList 6 else 1 if (target equal pLoc->data.key) 1 found = true 2 else 1 found = false 3 end if 7end if 8return found end searchList Searches list and passes back address of node containing target and its logical predecessor. Pre List is metadata structure to a valid list pPre is pointer to predecessor node pLoc is pointer variable for current node target is the being sought Post pLoc point to first node with equal /greater key -or- null if targer > key of last node pPre points to largest node smaller than key -or- null if targer < key of first node Return true if found, false if not found

26. 26 西南财经大学天府学院 Unordered List Search: The problem with unordered searches is that multiple elements often satisfy the search criteria. One simple solution is to return a list of all elements that satisfy the criteria. Retrieve Node: 1. Use search algorithm to locate the data in the list. 2. If the data are found, move the data to the output area in the calling module and returns true. 3. If the data are not found, return false.

27. 27 西南财经大学天府学院 algorithm retrieveNode (val list, val key, ref dataOut ) 1found = searchList(List, pPre, pLoc, key) 2If (found) 1 dataOut = pLoc->data 3End if 4Return found End retreiveNode algorithm retrieveNode (val list, val key, ref dataOut ) 1found = searchList(List, pPre, pLoc, key) 2If (found) 1 dataOut = pLoc->data 3End if 4Return found End retreiveNode Algorithm emtpyList (val list ) 1 return (list.count equal to zero) End emptyList Algorithm emtpyList (val list ) 1 return (list.count equal to zero) End emptyList

28. 28 西南财经大学天府学院 Full List&ListCount Algorithm fullList (val list ) 1Allocate (pNew) 2If (allocation successful) 1 recycle (pNew) 2 return false 3End if 4Return ture End fullList Algorithm fullList (val list ) 1Allocate (pNew) 2If (allocation successful) 1 recycle (pNew) 2 return false 3End if 4Return ture End fullList Algorithm listCount (val list ) 1Return (list.count) End listCount Algorithm listCount (val list ) 1Return (list.count) End listCount

29. 29 西南财经大学天府学院 Traverse List Algorithms of this kind start at the first node and examine each node in succession until the last node has been processed. Traverse list is used in changing a value in each node, printing the list, summing a field in the list and so on. step: 1. Set the walking pointer to the first node in the list. 2. Use a loop calling a process module and passes it the data and then advances the walking pointer to the next node. 3. When the last node is processed, the walking pointer becomes null and the loop terminates. pWalker = list.head Loop (pWalker not null) process(pWalker ->data) pWalker = pWalker ->link End loop pWalker = list.head Loop (pWalker not null) process(pWalker ->data) pWalker = pWalker ->link End loop

30. 30 西南财经大学天府学院 A approach in designing the traverse list in this approach, the user controls the loop, calling traverse to get next element in the list moredata = getNext (list, 0, dataout) Loop (moredata true) process(dataout) moredata = getNext (list, 1, dataout) End loop moredata = getNext (list, 0, dataout) Loop (moredata true) process(dataout) moredata = getNext (list, 1, dataout) End loop N Count pos head 5 101520 … 95100

31. 31 西南财经大学天府学院 Algorithm getNext ( ref list, val fromWhere, ref dataOut ) 1If (fromwhere is 0) 1 if (list.count is zero) 1 success = false 2 Else 1 list.pos = list.head 2 dataOut = list.pos->data 3 success = true 3 end if 2Else 1 if (list.pos->link null) 1 success = false 2 else 1 list.pos = list.pos->link 2 dataOut = list.pos->data 3 success = true 3 end if 3End if 4Return success End getNext Algorithm getNext ( ref list, val fromWhere, ref dataOut ) 1If (fromwhere is 0) 1 if (list.count is zero) 1 success = false 2 Else 1 list.pos = list.head 2 dataOut = list.pos->data 3 success = true 3 end if 2Else 1 if (list.pos->link null) 1 success = false 2 else 1 list.pos = list.pos->link 2 dataOut = list.pos->data 3 success = true 3 end if 3End if 4Return success End getNext Traverses a linked list, each call return the location of an element in the list Pre List is metadata structure to a valid list fromWhere is 0 start at the first element dataOut is variable to receive data Post dataOut contains data and true returned -or- if end of list returns false Return true if next element located, false if end of list

32. 32 西南财经大学天府学院 Destroy List It deletes any nodes still in the list and recycles their memory, then sets the metadata to a null list condition.. Algorithm destroyList (ref List ) 1Loop (list.count not zero) 1 dltPtr = list.head 2 list.head = dltPtr->link 3 list.count = list.count – 1 4 recycle (dltPtr) 2End loop 3list.pos = null 4Return End destroyList Algorithm destroyList (ref List ) 1Loop (list.count not zero) 1 dltPtr = list.head 2 list.head = dltPtr->link 3 list.count = list.count – 1 4 recycle (dltPtr) 2End loop 3list.pos = null 4Return End destroyList Delete all data in list Pre List is metadata structure to a valid list Post A ll data deleted Return

33. 33 西南财经大学天府学院 3.3 Processing A Linked list LinkedList createListdestroyList getDataaddNoderemoveNodeprintList menu searchList insertNode searchList deleteNode getNext (+)

34. 34 西南财经大学天府学院 Algorithm buildLinkedList 1Print (welcome to exploring linked lists.) 2CrateList (list) 3Loop (option not to quit) 1 option = menu () 2 if (option add) 1 dataIn = getData() 2 addNode (list, dataIn) 3 elseif (option delete) 1 print (Enter key of data to be deleted.) 2 read (deleteKey) 3 removeNode (list, deleteKey) 4 elseif (option print) 1 printList (list) 5 endif 4End loop 5DestroyList (list) 6Print (Exploration complete. Thank you.) End buildLinkedList Algorithm buildLinkedList 1Print (welcome to exploring linked lists.) 2CrateList (list) 3Loop (option not to quit) 1 option = menu () 2 if (option add) 1 dataIn = getData() 2 addNode (list, dataIn) 3 elseif (option delete) 1 print (Enter key of data to be deleted.) 2 read (deleteKey) 3 removeNode (list, deleteKey) 4 elseif (option print) 1 printList (list) 5 endif 4End loop 5DestroyList (list) 6Print (Exploration complete. Thank you.) End buildLinkedList This program builds a linked list that can be modified or printed by the user.

35. 35 西南财经大学天府学院 Algorithm menu 1Print ( …… MENU …… ) 2Print (A: Add new data.) 3Print (D: Delete data.) 4Print (P: Print list.) 5 Print (Q: Quit.) 6Valid = false 7Loop ( valid false) 1 print ( Enter your choice: ’’ ) 2 read (choice) 3 if (choice equal ‘ A ’ or ‘ D ’ or ‘ P ’ or ‘ Q ’ ) 1 valid = true 4 else 1 print ( Invalid choice. Choices are ) 5 endif 8End loop 9 Return choice End menu Algorithm menu 1Print ( …… MENU …… ) 2Print (A: Add new data.) 3Print (D: Delete data.) 4Print (P: Print list.) 5 Print (Q: Quit.) 6Valid = false 7Loop ( valid false) 1 print ( Enter your choice: ’’ ) 2 read (choice) 3 if (choice equal ‘ A ’ or ‘ D ’ or ‘ P ’ or ‘ Q ’ ) 1 valid = true 4 else 1 print ( Invalid choice. Choices are ) 5 endif 8End loop 9 Return choice End menu Display a menu and read user option. Pre Nothing Return Valid choice

36. 36 西南财经大学天府学院 Algorithm addNode ( ref list, val dataIn ) 1Found = searchList (list, pPre, pLoc, dataIn.key) 2If (found) 1 print (Error: Data already in the list. Not added.) 3Else 1 success = insertNode (list, pPre, dataIn) 2 if (success false) 1 print (Error: Out of memory. Program quitting.) 2 abort algorithm 3 end if 4 Return End addNode Algorithm addNode ( ref list, val dataIn ) 1Found = searchList (list, pPre, pLoc, dataIn.key) 2If (found) 1 print (Error: Data already in the list. Not added.) 3Else 1 success = insertNode (list, pPre, dataIn) 2 if (success false) 1 print (Error: Out of memory. Program quitting.) 2 abort algorithm 3 end if 4 Return End addNode Add data to a linked list Pre List is metadata structure to a valid list dataIn are data to be inserted into list Post D ata have been inserted into list in key sequence

37. 37 西南财经大学天府学院 Algorithm removeNode (ref list, val key ) 1Found = searchList (list, pPre, pLoc, key) 2If (found) 1 deleteNode (list, pPre, pLoc, deleteData) 3Else 1 print (Error: Key not in list.) 4End if 5Return End removeNode Algorithm removeNode (ref list, val key ) 1Found = searchList (list, pPre, pLoc, key) 2If (found) 1 deleteNode (list, pPre, pLoc, deleteData) 3Else 1 print (Error: Key not in list.) 4End if 5Return End removeNode This algorithm deletes a node from the linked list Pre List is metadata structure to a valid list key is the key to be located and deleted Post the node has been deleted -or- a warning message printed if not found

38. 38 西南财经大学天府学院 Algorithm printList ( val list ) 1If (emptyList (list)) 1 print (No data in list.) 2Else 1 print (**** Begin Data Print ****) 2 count = 0 3 moreData = getNext (list, 0, dataPtr) 4 loop (moreData true) 1 count = count + 1 2 print (count, dataPtr->key) 3 moreData = getNext (list, 1, dataPtr) 5 end loop 3 End if 4Return End printlist Algorithm printList ( val list ) 1If (emptyList (list)) 1 print (No data in list.) 2Else 1 print (**** Begin Data Print ****) 2 count = 0 3 moreData = getNext (list, 0, dataPtr) 4 loop (moreData true) 1 count = count + 1 2 print (count, dataPtr->key) 3 moreData = getNext (list, 1, dataPtr) 5 end loop 3 End if 4Return End printlist This algorithm traverses a linked list and prints the key in each node. Pre List is metadata structure to a valid list Post A ll key have been printed

39. 39 西南财经大学天府学院 3.4 List Applications Append Lists: 5 count pos head 510 15 2025 5 count pos head 712 17 2227 5 count pos head 510152025 5 count pos head 712 17 2227 list1 list2 list1 list2 Before Append After Append

40. 40 西南财经大学天府学院 Algorithm appendTwolists 1Pirint (This program creates two lists and then appends them) 2Print (Enter first file name) 3Read (fileName) 4Open (fileName) 5Build (list1, fileName) 6printList (list1) 7Print (Enter secondt file name) 8Read (fileName) 9Open (fileName) 10Build (list2, fileName) 11printList (list2) 12Append (list1, list2) 13printList (list1) 14Return End appendTwoLists Algorithm appendTwolists 1Pirint (This program creates two lists and then appends them) 2Print (Enter first file name) 3Read (fileName) 4Open (fileName) 5Build (list1, fileName) 6printList (list1) 7Print (Enter secondt file name) 8Read (fileName) 9Open (fileName) 10Build (list2, fileName) 11printList (list2) 12Append (list1, list2) 13printList (list1) 14Return End appendTwoLists

41. 41 西南财经大学天府学院 Algorithm build ( ref list, val file ) 1CreateList (list) 2Loop (not end of file) 1 read (file into dataIn) 2 searchList (list, pPre, pLoc, dataIn.key) 3 insertNode (list, pPre, dataIn) 3End loop 4Return End build Algorithm build ( ref list, val file ) 1CreateList (list) 2Loop (not end of file) 1 read (file into dataIn) 2 searchList (list, pPre, pLoc, dataIn.key) 3 insertNode (list, pPre, dataIn) 3End loop 4Return End build

42. 42 西南财经大学天府学院 Algorithm append ( ref list1, val list2 ) 1If (list1.count zero) 1 list1.head = list2.head 2Else 1 pLoc = list1.head 2 loop(pLoc->link not null) 1 pLoc = pLoc->link 3 end loop 4 pLoc->link = list2.head 3End if 4List1.count = list1.count + list2.count 5Return End append Algorithm append ( ref list1, val list2 ) 1If (list1.count zero) 1 list1.head = list2.head 2Else 1 pLoc = list1.head 2 loop(pLoc->link not null) 1 pLoc = pLoc->link 3 end loop 4 pLoc->link = list2.head 3End if 4List1.count = list1.count + list2.count 5Return End append

43. 43 西南财经大学天府学院 Array of lists (count, pos, and head)

44. 44 西南财经大学天府学院 Algorithm arrayOf Lists 1print (Begin array of linked lists) 2Print (How many list do you want?) 3Read (numLists) 4buildArys (listArray, numLists) 5printArys (listArray, numLists) 6Print (End of arry of linked lists) End arryOfLists Algorithm arrayOf Lists 1print (Begin array of linked lists) 2Print (How many list do you want?) 3Read (numLists) 4buildArys (listArray, numLists) 5printArys (listArray, numLists) 6Print (End of arry of linked lists) End arryOfLists

45. 45 西南财经大学天府学院 Algorithm buildArrays (ref listArray, val numLists ) 1row = 0 2Loop (row < numLists) 1 print (Enter file name) 2 read (fileName) 3 open (fileName) 4 build (listArray[row], fileName) 5 close (fileName) 6 row = row + 1 3End loop 4Return End buildArrays Algorithm buildArrays (ref listArray, val numLists ) 1row = 0 2Loop (row < numLists) 1 print (Enter file name) 2 read (fileName) 3 open (fileName) 4 build (listArray[row], fileName) 5 close (fileName) 6 row = row + 1 3End loop 4Return End buildArrays

46. 46 西南财经大学天府学院 Algorithm printArys (val listArray, val numLists ) 1Row = 0 2Loop (row < numLists) 1 printList (listArray[row]) 2 row = row + 1 3End loop 4Return End printAry Algorithm printArys (val listArray, val numLists ) 1Row = 0 2Loop (row < numLists) 1 printList (listArray[row]) 2 row = row + 1 3End loop 4Return End printAry

47. 47 西南财经大学天府学院 3.5 Complex Linked List Structures Circularly Linked Lists: In this structure, the last node’s link points to the first node of the list. N count pos rear 510 95 link

48. 48 西南财经大学天府学院 The problem on searching Circularly Linked list: What is the target does not exit? The solution: if we start at the fitst node, use the rear pointer; if we start at a middle node, we save the starting node’s address, use the address

49. 49 西南财经大学天府学院 Doubly Linked In this structure, each node has a pointer to both its successor and its predecessor. count head rear10595 BF BF BF List Doubly Linked List Insertion: – Follow the basic patter. – Need to connect both the forward and backward pointers. B: Backward pointer F: Forward pointer

50. 50 西南财经大学天府学院 0 1 20 pPre 20 pNew Before After Insert into null list or before first node 2 2040 30 pNew 3 2040 30 Before After Insert between two nodes

51. 51 西南财经大学天府学院 Algorithm insertDbl (ref list, val dataIn ) 1If (fulllist(list)) 1 return 0 2End if 3Found = searchList (list, pPre, pSucc, dataIn.key) 4If (not found) 1 allocate (pNew) 2 pNew->data = dataIn 3 if (pPre is null) 1 pNew->back = null 2 pNew->fore = list.head 3 list.head = pNew 4 else 1 pNew->fore = pPre->fore 2 pNew->back = pPre 3 pPre->fore = pNew 5 end if Algorithm insertDbl (ref list, val dataIn ) 1If (fulllist(list)) 1 return 0 2End if 3Found = searchList (list, pPre, pSucc, dataIn.key) 4If (not found) 1 allocate (pNew) 2 pNew->data = dataIn 3 if (pPre is null) 1 pNew->back = null 2 pNew->fore = list.head 3 list.head = pNew 4 else 1 pNew->fore = pPre->fore 2 pNew->back = pPre 3 pPre->fore = pNew 5 end if 6 if (pPre->fore null) 1 list.rear = pNew 7 else 1 pSucc->back = pNew 8 end if 11 list.count = list.count + 1 12 return (1) 5End if 6Return (2) End insertDbl 6 if (pPre->fore null) 1 list.rear = pNew 7 else 1 pSucc->back = pNew 8 end if 11 list.count = list.count + 1 12 return (1) 5End if 6Return (2) End insertDbl

52. 52 西南财经大学天府学院 3 2575 50 pPred pDltpSucc 3 2575 Before delete After deleting 50 50 (Recycled) Doubly Linked List Deletion

53. 53 西南财经大学天府学院 Algorithm deleteDbl ( ref list, val pDlt ) 1If (pDlt null) 1 abort (Impossible condition in delete double) 2End if 3List.count = list.count - 1 4If (pDlt->back not null) 1 pPred = pDlt->back 2 pPred->fore = pDlt->fore 5Else 1 list.head = pDlt->fore 6End if 7If (pDlt->fore not null ) 1 pSucc = pDlt->fore 2 pSucc->back = pDlt->back 8Else 1 list.rear = pDlt->back 9End if 10Recycle (pDlt) 11Return End deleteDbl Algorithm deleteDbl ( ref list, val pDlt ) 1If (pDlt null) 1 abort (Impossible condition in delete double) 2End if 3List.count = list.count - 1 4If (pDlt->back not null) 1 pPred = pDlt->back 2 pPred->fore = pDlt->fore 5Else 1 list.head = pDlt->fore 6End if 7If (pDlt->fore not null ) 1 pSucc = pDlt->fore 2 pSucc->back = pDlt->back 8Else 1 list.rear = pDlt->back 9End if 10Recycle (pDlt) 11Return End deleteDbl

54. 54 西南财经大学天府学院 Multilinked Lists: It is a list with two or more logical key sequences. 3 Pres rear Sp rear Spouse link President link Washington1789Cutis Admas,J1779Smith Jefferson1801Skelton

55. 55 西南财经大学天府学院 Multilinked list Build Multilinked getData insert Build Node Insert Pres Insert Spouse Search Pres Search Spouse

56. 56 西南财经大学天府学院 Multilinked List Delete: The major variation for multilinked list delete: need to reconnect the pointers for each logical list. One solution: use the spouse’s name from the president search and then search the spouse list to find the pointers that need to be updated, but doing so can be very inefficient. The standard solution: use a doubly linked list for the spouse links.

57. 57 西南财经大学天府学院 3.6 Summary A linear list is a list in which each element has a unique successor. Linear list can be divided into tow categories: general and restricted. In a general list, data can be inserted and deleted anywhere and there are no restrictions on the operations that can be used to process the list. General lists can be further divided into random lists and ordered list. In a random list, there is no ordering of the data.

58. 58 西南财经大学天府学院 In an ordered list, the data dare arranged according to a key,which is one or more fields used to identify the data or control their use. In a restricted list, data,can be added or deleted at the end of the structure and processing is restricted to the operations on the data at the ends of the list. Two common restricted list structures are stacks, (last in- fist out [LIFO] lists) and queues (fist in-first out [FIFO] lists). Four common operations are associated with linear lists: insertion, deletion, retrieval, and traversal. A linked list is an ordered collection of data in which each element contains the location (address) of the next element; that is, each element contains two parts: data and link.

59. 59 西南财经大学天府学院 A head node is a data structure that contains metadata about the list, such as a count, a head pointer to the first node, and a rear pointer to the last node. It may contain any other general list data required by the use of the structure. The node in s singly linked list contains only one link to a single successor unless it is the last, in which case it is not linked to any other node. When we want to insert into a linked list, we must consider four cases: adding to the empty list, adding at the beginning, adding to the middle, and adding at the end.

60. 60 西南财经大学天府学院 When we want to delete a node from a list, we must consider two case: delete the first node or delete any other node. To search a linked list for an item, we use the ordered list search. Traversing a linked list means going through the list, node by node, and processing each node. Three examples of list traversals are counting the number of the nodes, printing the contents of nodes, and summing the values of one or more fields.

61. 61 西南财经大学天府学院 A header node contains the same metadata found in the head structure and shares the pointer structure with the data node. It is physically positioned so that it is always the first node in the linked list. A circularly linked list is a list in which the last node’s link points to the first node of the list. A doubly linked list is a linked list in which each node has pointer to both its successor and its predecessor. A multilinked list is a linked list with two or more logical list.

62. 62 西南财经大学天府学院 Exercises

63. 63 西南财经大学天府学院 Exercises

64. 64 西南财经大学天府学院 Exercises

65. 65 西南财经大学天府学院 Exercises