Chap 3 Linked Lists. Vocabulary Linear List 线性表 Linked List 链表 Retrieval 检索 Traversal...
-
Upload
gertrude-nicholson -
Category
Documents
-
view
381 -
download
0
description
Transcript of Chap 3 Linked Lists. Vocabulary Linear List 线性表 Linked List 链表 Retrieval 检索 Traversal...
Chap 3Chap 3Linked ListsLinked Lists
VocabularyVocabulary
Linear List 线性表Linked List 链表Retrieval 检索Traversal 遍历Node 结点Circularly Linked Lists 循环链表Doubly Linked Lists 双向链表Multilinked Lists 多重链表
3.1 Linear List3.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
Element 1 Element 2 Element 3 Element 4
Classification
Linear Lists
General Restricted
Unordered Ordered FIFO(queue)
LIFO(stack)
Operation Insertion: Depending on the type of general list, an insertion can be
made at the beginning of the list, in the middle of the list, or at the end of the list. If data is inserted into ordered lists, the ordering of the list must be maintained. Maintaining the order may require a search algorithm to determine where the data are to be placed.
10 20 30
data25 Insertion
10 20 25 30
Inserted Data
list
Deletion: Deletion from a general list requires that the list be searched to locate the data being deleted. Any sequential search algorithm can be used to locate the data. When data are deleted from a random array, the data following the deleted item must be shifted to replace the empty element.
blue green yellow
redDeletion
blue green red yellow
Delete element identified searchlist
Retrieval: List retrieval requires that data be located in a list and presented to the calling module without changing the contents of the list.
dogRetrieval
cat goldfishdog zebralist
cat goldfishdog zebra
Retrieved element identified by search
Traversal: List traversal is a special case of retrieval in which all elements are retrieval in sequence. List traversal requires a looping algorithm rather than a search. Each execution of the loop processes one element in the list. The loop terminates when all elements have been processed.
3.2 Linked list 3.2 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. The data part holds the useful information, the data to be processed. The link is used to chain the data together. It contains a pointer that identified the next element in the list.
a singly linked list: a linked list contains only one link to a single successor.
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.
pHead data link data link data link
A linked list with a head pointer: pHead
pHead
An empty linked list
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 <keyType>
field1 <…>
field2 <…>
…
fieldN <…>
End dataType
count head
Head structure
data link
Data node structure
metadataList
count <integer>
head <pointer>
End List
Node
data <datatype>
link <pointer>
End Node
3.3 Linked List Algorithms3.3 Linked List Algorithms Create List: it receives the head structure and initia
lizes the metadata for the list. The pseudocode algorithms: Algorithm createList(ref list <metadata
>)
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
? ?listcount head
(b) after create
0listcount head
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 listinsert at beginninginsert in middleinsert at end
pNew->link = list.head Set link to null pointer
List.head = pNew Point list to first node
0count head
75
pNew (a) before add
1count head
75
pNew (b) after add
Insert into empty list:
Insert at beginning:
pNew->link = list.head
List.head = pNew
1
39pNew
75
count head
Before add
After add
1
39pNew
count head75
Logically,inserting into an empty list is the same as inserting at the beginning of a list.
Insert in middle:
pNew->link = pPre->link
pPre->link = pNew
2
pNew
39
count head
Before add75
52pPre
After add
3
52pNew
count head
39 75
pPre
Insert at end:
pNew->link = pPre->link
pPre->link = pNew
3count head
39 7552
pNew 134pPre
Before add
After add
3count head
39 7552
pPre pNew 134
Insert node algorithm:Algorithm insertNode (ref list < metadata >,
val pPre <node pointer>,
val dataIn <dataType>)
1 allocate(pNew)
2 if (memory overflow)
1 return false
3 end if
4 pNew->data=dataIn
5 if (pPre null)
1 pNew-.link =list.head
2 list.head = new
6 else
1 pNew->link = pPre->link
2 pPre->link = pNew
7 end if
8 list.count = list.count+1
9 Return 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
Delete Node: this algorithm logically removes a node from the linked list by:1. changing various link pointers and then 2. physically deleting the node from dynamic memory.
We discuss two situation :
delete first node (delete the only node in the list)
general delete case (delete the middle or last node)
Delete first node:
list.head = pLoc->link
recycle(pLoc)
3 39 13475
Before delete
pLocpPre
count head
2 13475After delete
pLocpPre
(Recyled)count head
General delete case:
pPre->link = pLoc->link
recycle(pLoc)
39 13475
pPre
3
Before delete
pLoccount head
After delete
39 134
pPre
3
pLoccount head
(Recycled)
Delete node algorithm:Algorithm insertNode (ref list < metadata >,
val pPre <node pointer>,
val pLoc <node pointer>,
ref dataOut <dataType>)
1 Dataout = pLoc->data
2 if (pPre null)
1 list.head = pLoc->link
3 else
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
dataIn is variable to received deleted data
Post
data have been deleted and returned to caller
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.
Algorithm searchList (val list <metadata>
ref pPre <node pointer>
ref pLoc <node pointer>
ref target <key type>
1 pPre = null
2 pLoc = list.head
3 Loop (pLoc not null AND target > pLoc->data.key)
1 pPre =pLoc
2 pLoc = pLoc->link
4 end loop
5 If (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
7 end if
8 return 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
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.
Empty list:
algorithm retrieveNode (val list < metadata >,
val key <key type>,
ref dataOut <dataType>)
1 found = searchList(List, pPre, pLoc, key)
2 If (found)
1 dataOut = pLoc->data
3 End if
4 Return found
End retreiveNode
Algorithm emtpyList (val list <metadata>)
1 return (list.count equal to zero)
End emptyList
Full list:
List count:
Algorithm fullList (val list <metatype>)
1 Allocate (pNew)
2 If (allocation successful)
1 recycle (pNew)
2 return false
3 End if
4 Return ture
End fullList
Algorithm listCount (val list <metatype>)
1 Return (list.count)
End listCount
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
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, o, dataout)Loop (moredata true)process(dataout)moredata = getNext (list, o, dataout)End loop
N • Count pos head
5 10 15 20 … 95 100
Algorithm getNext ( ref list <metatype>,
val fromWhere <Boolean>,
ref dataOut <datatype> )
1 If (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
2 Else
1 if (list.pos->link null)
1 success = false
2 else
1 list.pos = list.pos->link
2 dataOut = true
3 end if
3 End if
4 Return 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
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 pList <metadata>)
1 Loop (list.count not zero)
1 dltPtr = list.head
2 list.head = dltPtr->link
3 list.count = list.count – 1
4 recycle (dltPtr)
2 End loop
3 list.pos = null
4 Return
End destroyList
Delete all data in list
Pre List is metadata structure to a valid list
Post All data deletedReturn
3.4 Processing A Linked list3.4 Processing A Linked listLinkedList
createList destroyList
getData addNode removeNode printList
menusearchList
insertNode
searchList
deleteNode
getNext
(+) (+)
Algorithm buildLinkedList
1 Print (welcome to exploring linked lists.)
2 CrateList (list)
3 Loop (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
4 End loop
5 DestroyList (list)
6 Print (Exploration complete. Thank you.)
End buildLinkedList
This program builds a linked list that can be modified or printed by the user.
Algorithm menu
1 Print (……MENU……)
2 Print (A: Add new data.)
3 Print (D: Delete data.)
4 Print (P: Print list.)
5 Print (Q: Quit.)
6 Valid = false
7 Loop ( 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 <A,D,P,Q> )
5 endif
8 End loop
9 Return choice
End menu
Display a menu and read user option.
Pre NothingReturn Valid choice
Algorithm addNode ( ref list <metadata>,
val dataIn <dataType>)
1 Found = searchList (list, pPre, pLoc, dataIn.key)
2 If (found)
1 print (Error: Data already in the list. Not added.)
3 Else
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 Data have been inserted into list in key sequence
Algorithm removeNode (ref list <metadata>,
val key <keyType>)
1 Found = searchList (list, pPre, pLoc, key)
2 If (found)
1 deleteNode (list, pPre, pLoc, deleteData)
3 Else
1 print (Error: Key not in list.)
4 End if
5 Return
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
Algorithm printList ( val list <metadata> )
1 If (emptyList (list))
1 print (No data in list.)
2 Else
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
4 Return
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 All key have been printed
3.5 List Applications3.5 List ApplicationsAppend Lists:
5count pos head
5 10 15 20 25
5count pos head
7 12 17 22 27
5count pos head
5 10 15 20 25
5count pos head
7 12 17 22 27
list1
list2
list1
list2
Before Append
After Append
Algorithm appendTwolists
1 Pirint (This program creates two lists and then appends them)
2 Print (Enter first file name)
3 Read (fileName)
4 Open (fileName)
5 Build (list1, fileName)
6 printList (list1)
7 Print (Enter secondt file name)
8 Read (fileName)
9 Open (fileName)
10 Build (list2, fileName)
11 printList (list2)
12 Append (list1, list2)
13 printList (list1)
14 Return
End appendTwoLists
Algorithm build ( ref list <metadata>,
val file <data file>)
1 CreateList (list)
2 Loop (not end of file)
1 read (file into dataIn)
2 searchList (list, pPre, pLoc, dataIn.key)
3 insertNode (list, pPre, dataIn)
3 End loop
4 Return
End build
Algorithm append ( ref list1 <metadata>,
val list2 <metadata>)
1 If (list1.count zero)
1 list1.head = list2.head
2 Else
1 pLoc = list1.head
2 loop(pLoc->link not null)
1 pLoc = pLoc->link
3 end loop
4 pLoc->link = list2.head
3 End if
4 List1.count = list1.count + list2.count
5 Return
End append
Array of lists(count,
pos, and head)
Algorithm arrayOf Lists
1 print (Begin array of linked lists)
2 Print (How many list do you want?)
3 Read (numLists)
4 buildArys (listArray, numLists)
5 printArys (listArray, numLists)
6 Print (End of arry of linked lists)
End arryOfLists
Algorithm buildArrays (ref listArray <metadata>,
val numLists <integer>)
1 row = 0
2 Loop (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
3 End loop
4 Return
End buildArrays
Algorithm printArys (val listArray <metadata>,
val numLists <integer> )
1 Row = 0
2 Loop (row < numLists)
1 printList (listArray[row])
2 row = row + 1
3 End loop
4 Return
End printAry
3.63.6 Complex Linked List StructurComplex Linked List Structureses
Circularly Linked Lists:In this structure, the last node’s link points to the first node of the list.
Ncount pos rear
5 10 95link
The problem on searching doubly 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
Doubly Linked: In this structure, each node has a pointer to both its successor and its predecessor.
count head rear 105 95B F B F B FList
Doubly Linked List Insertion:–Follow the basic patter.
–Need to connect both the forward and backward pointers.
B: Backward pointer F: Forward pointer
0 1
20
pPre
20pNew
Before AfterInsert into null list or before first node
2
20 40
30pNew
3
20 40
30
Before AfterInsert between two nodes
Algorithm insertDbl (ref list <metadata>,
val dataIn <dataType>)
1 If (full list)
1 return 0
2 End if
3 Found = searchList (list, Pre, pSucc, dataIn.key)
4 If (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
5 end if
6 if (pPre->fore null)
1 list.rear = pNew
7 else
1 pSucc->back = pNew
8 end if
9 pFore->fore = pNew
10 list.count = list.count + 1
11 return (1)
5 End if
6 Return (2)
End insertDbl
3
25 7550
pPred pDlt pSucc
3
25 75
Before delete
After deleting 50
50(Recycled)
Doubly Linked List deletion:
Algorithm deleteDbl ( ref list <metadata>,
val pDlt <node pointer>)
1 If (pDlt null)
1 abort (Impossible condition in delete double)
2 End if
3 List.count = list.count + 1
4 If (pDlt->backk not null)
1 pPred = pDlt->back
2 pPred->fore = pDlt->fore
5 Else
1 list.head = pDlt->fore
6 End if
7 If (pDlt->fore not null )
1 pSucc = pDlt->fore
2 pSucc->back = pDlt->back
8 Else
1 list.rear = pDlt->back
9 End if
10 Recycle (pDlt)
11 Return
End deleteDbl
Multilinked Lists: It is a list with two or more logical key sequences.
3 Pres rear
Sp rear
Spouselink
President link
Washington 1789 Cutis
Admas,J 1779 Smith
Jefferson 1801 Skelton
Multilinked List Insert:
Build Multilinked
getData insert
Build Node
InsertPres
InsertSpouse
SearchPres
SearchSpouse
Multilinked List Delete:– The major variation for multilinked list delete: need to r
econnect 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.
3.9 Summary3.9 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 delete
d anywhere and there are no restrictions on the operations that can be used to process the list.
– General lists can be further diveded into random lists and ordered list.
– In a random list, there is no ordering of the data.
– 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 then ends of the list.
– Tow 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.
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 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.
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.
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.