Download Chap 3_bak

Chap 3
Linked Lists
Vocabulary

Linear List
 Linked List
 Retrieval
 Traversal
 Node
 Circularly Linked Lists
 Doubly Linked Lists
 Multilinked Lists
线性表
链表
检索
遍历
结点
循环链表
双向链表
多重链表
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
Element 1
Element 2
Element 3
Element 4

Classification
Linear Lists
General
Unordered
Ordered
Restricted
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.
list
10
data
25
10
20
30
Inserted
Data
Insertion
20
25
30
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.
list
blue
Delete element
identified search
green
Deletion
red
blue
green
red
yellow
yellow
Retrieval: List retrieval requires that data be located in a
list and presented to the calling module without changing
the contents of the list.
Retrieved element
identified by search
list
cat
dog
Retrieval
cat
dog
zebra
goldfish
goldfish
dog
zebra
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
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.
pHead
data
link
data
link
data
link
A linked list with a head pointer: pHead
pHead
An empty linked list

Nodes: The elements in a linked list are
called nodes.

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:
metadata
dataType
key
field1 <…>
field2 <…>
…
fieldN <…>
End dataType
List
count
head
Head structure
link
Data node structure
Node
count <integer>
data <datatype>
head <pointer>
link <pointer>
End List
data
<keyType>
End Node
3.3
Linked List Algorithms

Create List: it receives the head structure and
initializes the metadata for the list.

The pseudocode algorithms:
Algorithm createList(ref list <metadata>)
Initializes metadata for a linked list.
list
?
?
count
head
(a) before create
list.head = null
list.count = 0
list
0
count
head
(b) after create
Pre list is metadata structure passed
by reference
Post metadata initialized
1 list.head = null
2 list.count = 0
3 return
End createList

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
Insert into empty list:
0
head
count
(a) before add
pNew->link = list.head
List.head = pNew
75
pNew
Set link to null pointer
Point list to first node
75
1
head
count
(b) after add
pNew
Insert at beginning:
Before add
1
count
75
head
pNew
39
pNew->link = list.head
List.head = pNew
After add
1
count
75
head
pNew
39
Logically,inserting
into an empty
list is the same
as inserting at
the beginning
of a list.
Insert in middle:
Before add
2
count
39
75
head
pPre
pNew
52
pNew->link = pPre->link
pPre->link = pNew
After add
3
count
39
75
head
pPre
pNew
52
Insert at end:
Before add
39
3
count
52
75
head
pPre
134
pNew
pNew->link = pPre->link
pPre->link = pNew
After add
3
count
39
52
pPre
pNew
75
head
134
Insert node algorithm:
Algorithm insertNode (ref list
val pPre
val dataIn
1
allocate(pNew)
2
if (memory overflow)
1 return false
3
end if
4
pNew->data=dataIn
5
if (pPre null)
< metadata >,
<node pointer>,
<dataType>)
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
1 pNew-.link =list.head
2 list.head = new
Post
1 pNew->link = pPre->link
data have been inserted in
sequence
2 pPre->link = pNew
Return
7
end if
8
list.count = list.count+1
true if successful , false is
memory overflow
9
Return ture
6
else
end insertNode

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:
Before delete
3
count
39
75
134
head
pLoc
pPre
list.head = pLoc->link
recycle(pLoc)
After delete
2
count
(Recyled)
head
pLoc
pPre
75
134
General delete case:
Before delete
3
count
39
75
pPre
pLoc
134
head
pPre->link = pLoc->link
recycle(pLoc)
After delete
3
count
39
(Recycled)
head
pPre
pLoc
134
Delete node algorithm:
Algorithm insertNode (ref list
val pPre
<node pointer>,
val pLoc
<node pointer>,
ref dataOut
1
Dataout = pLoc->data
2
if (pPre null)
1 list.head = pLoc->link
3
< metadata >,
else
1 pPre->link = pLoc->link
<dataType>)
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
4
end if
5
list.count = list.count - 1
6
recycle(pLoc)
dataIn is variable to received
deleted data
7
Return
Post
end deleteNode
data have been deleted and
returned to caller

Search list: it is used by several
algorithms to
Searches list and passes back address
of node
containing
target andor
its logical
locate data in a list. When we
insert
or delete
predecessor.
retrieve data from a list, wePre
need to search the list
and find the data.
List is metadata structure to a valid
Algorithm searchList (val list
<metadata>
ref pPre <node pointer>
ref pLoc <node pointer>
ref target <key type>
list 6 else
pPre is pointer to predecessor node
1 pointer
if (target variable
equal pLoc->data.key)
pLoc is
for current
node
1 found = true
target2iselse
the being sought
3
Post
1 found = false
pLoc point to first node with equal
pLoc = list.head
end if
/greater 3key
Loop (pLoc not null AND target > pLoc->data.key) -or7 null
end
if
if targer
> key of last node
pPre
to largest node smaller
1 pPre =pLoc
8 points
return found
than key
2 pLoc = pLoc->link
-or-end
nullsearchList
if targer < key of first node
4
end loop
5
If (pLoc null)
1
2
pPre = null
1 found = false
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.
algorithm retrieveNode (val list
val key
< metadata >,
<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

Empty list:
Algorithm emtpyList (val list <metadata>)
1 return (list.count equal to zero)
End emptyList

Full list:
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

List count:
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
Count
N
5
10
pos
•
15
head
20
moredata = getNext (list, o, dataout)
Loop (moredata true)
process(dataout)
moredata = getNext (list, o, dataout)
End loop
… 95
100
Algorithm getNext ( ref list
<metatype>,
val fromWhere <Boolean>,
ref dataOut
1
<datatype> )
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 deleted
Return
3.4 Processing A Linked list
LinkedList
createList
destroyList
(+)
getData
addNode
(+)
removeNode
printList
searchList
getNext
menu
searchList
insertNode
deleteNode
Algorithm buildLinkedList
1
Print (welcome to exploring linked lists.)
2
CrateList (list)
3
Loop (option not to quit)
1 option = menu ()
This program builds a linked list
that can be modified or printed by the
user.
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
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)
Display a menu and read user option.
Pre
Nothing
Return
Valid choice
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
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. NotAdd
added.)
data to a linked list
3
Else
Pre
1 success = insertNode (list, pPre, dataIn)List is metadata structure to a valid
list
2 if (success false)
dataIn are data to be inserted into list
1 print (Error: Out of memory. Program quitting.)
2 abort algorithm
3 end if
4
Return
End addNode
Post
Data have been inserted into list in key
sequence
Algorithm removeNode (ref list
val key
<metadata>,
<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
1
<metadata> )
If (emptyList (list))
1 print (No data in list.)
2
Else
1 print (**** Begin Data Print ****)
2 count = 0
This algorithm traverses a linked list and
prints the key in each node.
Pre
List is metadata structure to a valid list
3 moreData = getNext (list, 0, dataPtr)Post
4 loop (moreData true)
All key have been printed
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
3.5 List Applications

Append Lists:
list1
5
count pos head
5
10
15
20
25
7
12
17
22
27
list2
5
count pos head
Before Append
list1
5
count pos head
5
10
15
20
25
7
12
17
22
27
list2
5
count pos head
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
val file
<metadata>,
<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
val numLists
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
<metadata>,
<integer>)
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.6 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 link
5
10
95


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.
List
B
count head
rear
5
B
F
10
B: Backward pointer
Doubly
F
B
95
F: Forward pointer
Linked List Insertion:
–Follow the basic patter.
–Need to connect both the forward and backward
pointers.
F
0
pNew
1
20
20
After
Insert into null list or before first node
Before
3
2
pPre
40
20
pNew
20
30
40
30
After
Before
Insert between two nodes
Algorithm insertDbl (ref list
1
<metadata>,
6 if (pPre->fore null)
val dataIn <dataType>)
1 list.rear = pNew
If (full list)
7 else
1 return 0
1 pSucc->back = pNew
2
End if
8 end if
3
Found = searchList (list, Pre, pSucc, dataIn.key)
9 pFore->fore = pNew
4
If (not found)
10 list.count = list.count + 1
1 allocate (pNew)
11 return (1)
2 pNew->data = dataIn
5
End if
3 if (pPre is null)
6
Return (2)
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
End insertDbl
Doubly
Linked List deletion:
pPred
pDlt
pSucc
3
25
75
50
Before delete
3
25
75
50
(Recycled)
After deleting 50
Algorithm deleteDbl ( ref list
val pDlt
1
<metadata>,
<node pointer>)
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.
President
link
3
Pres
rear
Spouse
link
Sp
rear
Washington
1789
Cutis
Admas,J
1779
Smith
Jefferson
1801 Skelton

Multilinked List Insert:
Build
Multilinked
insert
getData
Build
Node
Insert
Pres
Insert
Spouse
Search
Pres
Search
Spouse

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.
3.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
deleted 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.