CSCI 251 Ch. 4 Lists
numsList: 2, 8, 1 ListRemove(numsList, list tail) numsList = ________
2, 8
numsList: 23, 17, 8 ListInsertAfter(numsList, node 23, node 5) numsList = _____
23, 5, 17, 8
Prepending 29 to trainsList updates the list's head pointer to point to node _____. 4 29 31
29
Given a doubly-linked list with nodes 8, 12, 7, 3, node 7's next pointer points to node _____. 12 3
3
How many nodes will ListSearch visit when searching for 54?
3
ListAppend(charList, node F) inserts node F _____. after node Q before node N after node N
after node N
Given a new node, the ________ operation for a singly-linked list inserts the new node after a provided existing list node.
InsertAfter
Inserts x after w
InsertAfter(list, w, x)
Returns true if list has no items
IsEmpty(list)
Given taskList, node D is followed by node _____.
K
ListAppend() Algorithm (Doubly-linked List)
ListAppend(list, newNode) { if (list⇢head == null) { // List empty list⇢head = newNode list⇢tail = newNode } else { list⇢tail⇢next = newNode newNode⇢prev = list⇢tail list⇢tail = newNode } }
Removes x
Remove(list, x)
Given a specified existing node in a singly-linked list, the _______ operation removes the node after the specified list node.
RemoveAfter
A list where elements contain pointers to the next and/or previous elements in the list
positional list
a common ADT for holding ordered data, having operations like append a data item, remove a data item, search whether a data item exists, and print the list
list
A ______ ______ algorithm visits all nodes in the list once and performs an operation on each node.
list traversal
Given a doubly-linked list with nodes 4, 7, 5, 1, node 7's previous pointer points to node _____. 4 5
4
numsList: 91, 80, 77, 60, 75 ListRemoveAfter(numsList, node 60) ListRemoveAfter(numsList, node 77) ListRemoveAfter(numsList, null) numsList = ______
80, 77
numsList: 9, 4, 11, 7 ListRemoveAfter(numsList, node 11) numsList = ______
9, 4, 11
Inserts x at end of list
Append(list, x)
Appending node D to charList updates which node's next pointer? M T E
E
Returns the number of items in the list
GetLength(list)
ListSearch() Algorithm
ListSearch(list, key) { curNode = list⇢head while (curNode is not null) { if (curNode⇢data == key) { return curNode } curNode = curNode⇢next } return null }
Prepending Evelyn to deliveryList executes which statement? a. list⇢head = null b. newNode⇢next = list⇢head c. list⇢tail = newNode
b
Suppose ListTraverseReverse is called on the following list. If ListTraverseReverseRecursive were called directly on node 91, the nodes visited would be: _____. a. node 91 and node 67 b. node 18, node 46, and node 91 c. node 18, node 46, node 91, and node 67
b
A node with an unused data member that always resides at the head of the list and cannot be removed
dummy/header node
Doubly-linked list with dummy node. ListInsertAfter(list, null, newNode) will insert newNode before the list's dummy node. True False
false
Suppose dataList is a singly-linked list with a dummy node. Which statement removes the first item from the list? a. ListRemoveAfter(dataList, null) b. ListRemoveAfter(dataList, dataList⇢head) c. ListRemoveAfter(dataList, dataList⇢tail)
b
Prepending node 789 to studentIdList updates the list's tail pointer. True False
false
The head and tail pointers always point to the dummy node. True False
false
ListPrepend(shoppingList, node Milk) updates the list's tail pointer. True False
true
Given ListInsertionSortSinglyLinked is called to sort the list below. How many times is ListInsertAfter called? 0 1 2
0
A special value indicating a pointer points to nothing
null
How many nodes will ListSearch visit when searching for 48?
6
Suppose a linked list has 10 nodes. Calling ListSearch results in a minimum of _____ calls to ListSearchRecursive. 1 2 10 11
1
numsList: 1 ListInsertAfter(numsList, node 1, node 6) ListInsertAfter(numsList, node 1, node 4) numsList = _____
1, 4, 6
Prepending a node to a doubly-linked list
1. Prepend to empty list: If the list's head pointer is null (empty), the algorithm points the list's head and tail pointers to the new node. 2. Prepend to non-empty list: If the list's head pointer is not null (not empty), the algorithm points the new node's next pointer to the list's head node, points the list head node's previous pointer to the new node, and then points the list's head pointer to the new node.
Removing a node from a singly-linked list
1. Remove list's head node (special case): If curNode is null, the algorithm points sucNode to the head node's next node, and points the list's head pointer to sucNode. If sucNode is null, the only list node was removed, so the list's tail pointer is pointed to null (indicating the list is now empty). OR 2. Remove node after curNode: If curNode's next pointer is not null (a node after curNode exists), the algorithm points sucNode to the node after curNode's next node. Then curNode's next pointer is pointed to sucNode. If sucNode is null, the list's tail node was removed, so the algorithm points the list's tail pointer to curNode (the new tail node).
numsList: 10, 20, 30, 40, 50, 60 ListRemoveAfter(numsList, node 40) ListRemoveAfter(numsList, node 20) numsList = ______
10, 20, 40, 60
If ListTraverse is called to traverse a list with 10 nodes, how many calls to ListTraverseRecursive are made? 9 10 11
11
Given ListInsertionSortSinglyLinked is called to sort the list below. How many times is ListPrepend called? 0 1 2
2
Type the list after the given operations. Each question starts with an empty list. Append(list, 3) Append(list, 2) Append(list, 1) Remove(list, 3)
2, 1
numsList: 2, 5, 9 ListRemoveAfter(numsList, node 5) numsList = ______
2, 5
numsList: 3, 57, 28, 40 ListRemoveAfter(numsList, null) numsList = ______
57, 28, 40
Type the list after the given operations. Each question starts with an empty list. Append(list, 3) Append(list, 2)
3, 2
Given a list with items 40, 888, -3, 2, what does GetLength(list) return? 4 Fails
4
numsList: 5, 9 ListInsertAfter(numsList, node 9, node 4) numsList = _____
5, 9, 4
numsList: 70, 82, 41, 120, 357, 66 ListRemove(numsList, node 82) ListRemove(numsList, node 357) ListRemove(numsList, node 66) numsList = ________
70, 41, 120
numsList: 71, 29, 54 ListRemove(numsList, node 29) numsList = ________
71, 54
numsList: 77 ListInsertAfter(numsList, node 77, node 32) ListInsertAfter(numsList, node 32, node 50) ListInsertAfter(numsList, node 32, node 46) numsList = _____
77, 32, 46, 50
ListTraverseReverse can be used to traverse a singly-linked list. True False
False
Singly-linked list with a dummy node
List operations such as append, prepend, insert after, and remove after are simpler to implement compared to a linked list without a dummy node, since a special case is removed from each implementation. ListAppend, ListPrepend, and ListInsertAfter do not need to check if the list's head is null, since the list's head will always point to the dummy node. ListRemoveAfter does not need a special case to allow removal of the first list item, since the first list item is after the dummy node.
ListAppend() Algorithm
ListAppend(list, newNode) { if (list⇢head == null) { // List empty list⇢head = newNode list⇢tail = newNode } else { list⇢tail⇢next = newNode list⇢tail = newNode } }
ListFindInsertionPosition() Algorithm
ListFindInsertionPosition(list, dataValue) { curNodeA = null curNodeB = list⇢head while (curNodeB != null and dataValue > curNodeB⇢data) { curNodeA = curNodeB curNodeB = curNodeB⇢next } return curNodeA }
ListInsertAfter() Algorithm
ListInsertAfter(list, curNode, newNode) { if (list⇢head == null) { // List empty list⇢head = newNode list⇢tail = newNode } else if (curNode == list⇢tail) { // Insert after tail list⇢tail⇢next = newNode newNode⇢prev = list⇢tail list⇢tail = newNode } else { sucNode = curNode⇢next newNode⇢next = sucNode newNode⇢prev = curNode curNode⇢next = newNode sucNode⇢prev = newNode } }
InsertAfter() Algorithm
ListInsertAfter(list, curNode, newNode) { if (list⇢head == null) { // List empty list⇢head = newNode list⇢tail = newNode } else if (curNode == list⇢tail) { // Insert after tail list⇢tail⇢next = newNode list⇢tail = newNode } else { newNode⇢next = curNode⇢next curNode⇢next = newNode } }
ListInsertionSortDoublyLinked() Algorithm
ListInsertionSortDoublyLinked(list) { curNode = list⇢head⇢next while (curNode != null) { nextNode = curNode⇢next searchNode = curNode⇢prev while (searchNode != null and searchNode⇢data > curNode⇢data) { searchNode = searchNode⇢prev } // Remove and re-insert curNode ListRemove(list, curNode) if (searchNode == null) { curNode⇢prev = null ListPrepend(list, curNode) } else { ListInsertAfter(list, searchNode, curNode) } // Advance to next node curNode = nextNode } }
ListInsertionSortSinglyLinked() Algorithm
ListInsertionSortSinglyLinked(list) { beforeCurrent = list⇢head curNode = list⇢head⇢next while (curNode != null) { next = curNode⇢next position = ListFindInsertionPosition(list, curNode⇢data) if (position == beforeCurrent) beforeCurrent = curNode else { ListRemoveAfter(list, beforeCurrent) if (position == null) ListPrepend(list, curNode) else ListInsertAfter(list, position, curNode) } curNode = next } }
ListPrepend() Algorithm (Doubly-linked List)
ListPrepend(list, newNode) { if (list⇢head == null) { // List empty list⇢head = newNode list⇢tail = newNode } else { newNode⇢next = list⇢head list⇢head⇢prev = newNode list⇢head = newNode } }
ListPrepend() Algorithm
ListPrepend(list, newNode) { if (list⇢head == null) { // list empty list⇢head = newNode list⇢tail = newNode } else { newNode⇢next = list⇢head list⇢head = newNode } }
ListRemove() Algorithm (Doubly-linked List)
ListRemove(list, curNode) { sucNode = curNode⇢next predNode = curNode⇢prev if (sucNode is not null) { sucNode⇢prev = predNode } if (predNode is not null) { predNode⇢next = sucNode } if (curNode == list⇢head) { // Removed head list⇢head = sucNode } if (curNode == list⇢tail) { // Removed tail list⇢tail = predNode } }
ListRemoveAfter() Algorithm
ListRemoveAfter(list, curNode) { // Special case, remove head if (curNode is null && list⇢head is not null) { sucNode = list⇢head⇢next list⇢head = sucNode if (sucNode is null) { // Removed last item list⇢tail = null } } else if (curNode⇢next is not null) { sucNode = curNode⇢next⇢next curNode⇢next = sucNode if (sucNode is null) { // Removed tail list⇢tail = curNode } } }
ListSearch() Algorithm (Recursive Version)
ListSearch(list, key) { return ListSearchRecursive(key, list⇢head) }
ListSearchRecursive() Algorithm
ListSearchRecursive(key, node) { if (node is not null) { if (node⇢data == key) { return node } return ListSearchRecursive(key, node⇢next) } return null }
ListTraverse() Algorithm
ListTraverse(list) { curNode = list⇢head // Start at head while (curNode is not null) { Print curNode's data curNode = curNode⇢next } }
ListTraverse() Algorithm (Recursive Version)
ListTraverse(list) { ListTraverseRecursive(list⇢head) }
ListTraverseRecursive() Algorithm
ListTraverseRecursive(node) { if (node is not null) { Visit node ListTraverseRecursive(node⇢next) } }
ListTraverseReverse() Algorithm
ListTraverseReverse(list) { curNode = list⇢tail // Start at tail while (curNode is not null) { Print curNode's data curNode = curNode⇢prev } }
Given waitList, the tail node's data value is _____.(Answer "None" if no tail exists)
Mary
After the following operations, will Search(list, 2) find an item? Type yes or no. Append(list, 3) Append(list, 2) Append(list, 1) Remove(list, 2)
No
ListPrepend is called on which node(s)? Node 11 only Node 22 only Nodes 11 and 22
Node 11 only
ListTraverseReverse visits which node second? Node 2 Node 13
Node 13
What is the first node that curNode will point to? Node 39 Node 45 Node 11
Node 45
Given ListInsertionSortSinglyLinked is called to sort the list below. What is returned by the first call to ListFindInsertionPosition? null Node 63 Node 71 Node 84
Node 63
ListSearch(charList, E) first assigns curNode to _____. Node M Node T Node E
Node M
The best case runtime of ListInsertionSortSinglyLinked is ______, which occurs when the list is sorted in descending order.
O(N)
Insertion sort's typical runtime is ______
O(N^2)
The average and worst case runtime of ListInsertionSortSinglyLinked is ________
O(N^2)
Inserts x at start of list
Prepend(list, x)
Prints list's items in order
Print(list)
Prints list's items in reverse order
PrintReverse(list)
Returns item if found, else returns null
Search(list, x)
Which sorting algorithm uses a gap value to jump between elements, and is difficult to adapt to linked lists for this reason? Insertion sort Merge sort Shell sort
Shell sort
Sorts the lists items in ascending order
Sort(list)
Inserting a new node in a doubly-linked lists
The InsertAfter algorithm considers three insertion scenarios: 1. Insert as first node: If the list's head pointer is null (list is empty), the algorithm points the list's head and tail pointers to the new node. 2. Insert after list's tail node: If the list's head pointer is not null (list is not empty) and curNode points to the list's tail node, the new node is inserted after the tail node. The algorithm points the tail node's next pointer to the new node, points the new node's previous pointer to the list's tail node, and then points the list's tail pointer to the new node. 3. Insert in middle of list: If the list's head pointer is not null (list is not empty) and curNode does not point to the list's tail node, the algorithm updates the current, new, and successor nodes' next and previous pointers to achieve the ordering {curNode newNode sucNode}, which requires four pointer updates: point the new node's next pointer to sucNode, point the new node's previous pointer to curNode, point curNode's next pointer to the new node, and point sucNode's previous pointer to the new node.
Inserting a node in a singly-linked list
The InsertAfter algorithm considers three insertion scenarios: 1. Insert as list's first node: If the list's head pointer is null, the algorithm points the list's head and tail pointers to the new node. 2. Insert after list's tail node: If the list's head pointer is not null (list not empty) and curNode points to the list's tail node, the algorithm points the tail node's next pointer and the list's tail pointer to the new node. 2. Insert in middle of list: If the list's head pointer is not null (list not empty) and curNode does not point to the list's tail node, the algorithm points the new node's next pointer to curNode's next node, and then points curNode's next pointer to the new node.
Removing a node from a doubly-linked list
The algorithm uses four separate checks to update each pointer: 1. Successor exists: If the successor node pointer is not null (successor exists), the algorithm points the successor's previous pointer to the predecessor node. 2. Predecessor exists: If the predecessor node pointer is not null (predecessor exists), the algorithm points the predecessor's next pointer to the successor node. 3. Removing list's head node: If curNode points to the list's head node, the algorithm points the list's head pointer to the successor node. 4. Removing list's tail node: If curNode points to the list's tail node, the algorithm points the list's tail pointer to the predecessor node.
Appending a node to a singly-linked list
The append algorithm behavior differs if the list is empty versus not empty: 1. Append to empty list: If the list's head pointer is null (empty), the algorithm points the list's head and tail pointers to the new node. 2. Append to non-empty list: If the list's head pointer is not null (not empty), the algorithm points the tail node's next pointer and the list's tail pointer to the new node.
Appending a node to a doubly-linked list
The append algorithm behavior differs if the list is empty versus not empty: 1. Append to empty list: If the list's head pointer is null (empty), the algorithm points the list's head and tail pointers to the new node. 2. Append to non-empty list: If the list's head pointer is not null (not empty), the algorithm points the tail node's next pointer to the new node, points the new node's previous pointer to the list's tail node, and points the list's tail pointer to the new node.
Prepending C to gradesList updates which pointer? The list's head pointer A's next pointer D's next pointer
The list's head pointer
Prepending a node to a singly-linked list
The prepend algorithm behavior differs if the list is empty versus not empty: 1. Prepend to empty list: If the list's head pointer is null (empty), the algorithm points the list's head and tail pointers to the new node. 2. Prepend to non-empty list: If the list's head pointer is not null (not empty), the algorithm points the new node's next pointer to the head node, and then points the list's head pointer to the new node.
Appending node K to rentalList executes which of the following statements? a. list⇢head = newNode b. list⇢tail⇢next = newNode c. newNode⇢prev = list⇢tail
a
For each question, assume 2 list types are available: a doubly-linked list with 1 dummy node at the list's head, and a doubly-linked list with 2 dummy nodes, one at the head and the other at the tail. When list⇢head == list⇢tail is true in _____, the list is empty. a. a list with 1 dummy node b. a list with 2 dummy nodes c. either a list with 1 dummy node or a list with 2 dummy nodes
a
ListInsertAfter(charList, node T, node Q) assigns newNode's next pointer with _____. a. curNode⇢next b. charList's head node c. null
a
ListInsertAfter(wagesList, list head, node 246) executes which statement? a. list⇢head = newNode b. list⇢tail⇢next = newNode c. curNode⇢next = newNode
a
Which statement is NOT executed when node 70 is appended to ticketList? a. list⇢head = newNode b. list⇢tail⇢next = newNode c. list⇢tail = newNode
a
Why are sorting algorithms for arrays generally more difficult to adapt to singly-linked lists than to doubly-linked lists? a. Singly-linked lists do not support backward traversal. b. Singly-linked do not support inserting nodes at arbitrary locations.
a
For each question, assume 2 list types are available: a doubly-linked list with 1 dummy node at the list's head, and a doubly-linked list with 2 dummy nodes, one at the head and the other at the tail. list⇢head⇢next is always non-null in _____. a. a list with 1 dummy node b. a list with 2 dummy nodes c. neither list type
b
ListAppend(callList, node 5) executes which statement? a. list⇢head = newNode b. list⇢tail⇢next = newNode c. newNode⇢next = list⇢tail
b
ListPrepend(earningsList, node 977) executes which statement? a. list⇢tail = newNode b. newNode⇢next = list⇢head c. newNode⇢next = list⇢tail
b
Suppose numbersList is a singly-linked list with items 73, 19, and 86. Item 86 is at the list's tail. What is the list's contents after the following operations? lastItem = numbersList⇢tail ListAppend(numbersList, node 25) ListInsertAfter(lastItem, node 49) a. 73, 19, 86, 25, 49 b. 73, 19, 86, 49, 25 c. 73, 19, 25, 49, 86
b
For each question, assume 2 list types are available: a doubly-linked list with 1 dummy node at the list's head, and a doubly-linked list with 2 dummy nodes, one at the head and the other at the tail. list⇢tail may be null in _____. a. a list with 1 dummy node b. a list with 2 dummy nodes c. neither list type
c
If myList is a singly-linked list with a dummy node, which statement is true when the list is empty? a. myList⇢head == null b. myList⇢tail == null c. myList⇢head == myList⇢tail
c
ListInsertAfter(numList, node 1, node 6) executes which statement? a. list⇢head = newNode b. newNode⇢next = curNode⇢next c. list⇢tail⇢next = newNode
c
Suppose numbersList is a singly-linked list with items 73, 19, and 86. Item 86 is at the list's tail. Suppose the following statement is executed: node19 = numbersList⇢head⇢next⇢next Which subsequent operations swap nodes 73 and 19? a. ListPrepend(numbersList, node19) b. ListInsertAfter(numbersList, numbersList⇢head, node19) c. ListRemoveAfter(numbersList, numbersList⇢head⇢next)ListPrepend(numbersList, node19)
c
What aspect of linked lists makes adapting array-based sorting algorithms to linked lists difficult? a. Two elements in a linked list cannot be swapped in constant time. b. Nodes in a linked list cannot be moved. c. Elements in a linked list cannot be accessed by index.
c Lack of indexed access is what prevents many sorting algorithms from being easily adapted to work with linked lists.
A data structure for implementing a list ADT, where each node has data, a pointer to the next node, and a pointer to the previous node.
doubly-linked list
If a list ADT has operations like Sort or PrintReverse, the list is clearly implemented using an array. True False
false *No such conclusion can be drawn. The point of an ADT is that the implementation is not known.
Given numsList is: 5, 8, 2, 1. ListTraverse(numsList) visits _____ node(s). one two four
four
A singly-linked list's first node
head
Given a doubly-linked list with nodes 20, 67, 11, node 20 is the _____. head tail
head
The ListTraverse function takes a list as an argument, and searches the entire list by calling ListTraverseRecursive on the list's _______.
head
Appending node W to sampleList updates which of sampleList's pointers? head and tail head only tail only
head and tail
Sorting algorithms easily adapted to efficiently sort linked lists
insertion sort, merge sort
Suppose dataList is a singly-linked list with a dummy node. Which is a requirement of the ListPrepend function? The list is empty The list is not empty newNode is not null
newNode is not null
Given carList, ListRemove(carList, node Bugatti) executes which of the following statements? list⇢tail = predNode Yes No
no
Given numList, ListRemove(numList, node 12) executes which of the following statements? list⇢head = sucNode Yes No
no
Given numList, ListRemove(numList, node 12) executes which of the following statements? list⇢tail = predNode Yes No
no
Given carList, ListRemove(carList, node Bugatti) executes which of the following statements? predNode⇢next = sucNode Yes No
no A predecessor node does not exist.
Given numList, ListRemoveAfter(numList, node 55) executes which of the following statements? list⇢head = sucNode Yes No
no Node 12 (node after node 55) is removed. Node 12 is not the list's head node, so the list's head pointer is unchanged.
Given numList, ListRemoveAfter(numList, node 55) executes which of the following statements? list⇢tail = curNode Yes No
no Node 12 (node after node 55) is removed. Node 12 is not the list's tail node, so the list's tail pointer is unchanged.
Given charList, ListRemoveAfter(charList, null) executes which of the following statements? list⇢tail = curNode Yes No
no The node being removed, node H, was not the list's tail node, so the list's tail pointer will not be changed.
Given numList, ListRemoveAfter(numList, node 55) executes which of the following statements? sucNode = list⇢head⇢next Yes No
no curNode is not null, so the list's head node is not removed.
Given charList, ListRemoveAfter(charList, null) executes which of the following statements? curNode⇢next = sucNode Yes No
no curNode is null, which does not point to a valid node. Assigning the next pointer of a non-existent node is an error.
Suppose ListTraverseReverse is called on the following list. ListTraverseReverse passes _____ as the argument to ListTraverseReverseRecursive. node 67 node 18 null
node 67
For ListSearch(captainList, Sisko), after checking node Riker, to which node is curNode pointed? node Riker node Kirk
node Kirk
A dummy node can also be used in a doubly-linked list implementation. The dummy node in a doubly-linked list always has the prev pointer set to ______.
null
Given charList, C's next pointer value is _____.
null
Suppose a linked list has 10 nodes. When the key is not found, ListSearch returns _____. the list's head the list's tail null
null
What value does ListSearch return if the search key is not found?
null
A ______ ______ algorithm visits all nodes starting with the list's tail node and ending after visiting the list's head node.
reverse traversal
Given a key, a ________ algorithm returns the first node whose data matches that key, or returns null if a matching node was not found.
search
Sorting algorithms that cannot as efficiently sort linked lists
shell sort, quick sort, heap sort
A data structure for implementing a list ADT, where each node has data and a pointer to the next node.
singly-linked list
A singly-linked list's last node
tail
Suppose a linked list has 10 nodes. When more than 1 of the list's nodes contains the search key, ListSearch returns _____ node containing the key. the first the last a random
the first
ListTraverse begins with _____. a specified list node the list's head node the list's tail node
the list's head node
A doubly-linked list supports a reverse traversal. True False
true
Doubly-linked list with dummy node. ListPrepend(list, newNode) is equivalent to ListInsertAfter(list, list⇢head, newNode). True False
true
Doubly-linked list with dummy node. ListRemove's implementation must not allow removal of the dummy node. True False
true
Given a list with items 'Z', 'A', 'B', Sort(list) yields 'A', 'B', 'Z'. True False
true
ListTraverse can be used to traverse a doubly-linked list. True False
true
ListTraverseRecursive works for an empty list. True False
true
ListTraverseRecursive works for both singly-linked and doubly-linked lists. True False
true
Prepending node 6 to parkingList updates the list's tail pointer. True False
true
Suppose ListTraverseReverse is called on the following list. ListTraverseReverseRecursive has been called for each of the list's nodes by the time the tail node is visited. True False
true
The dummy node's next pointer points to the first list item. True False
true
The ordering of list nodes is not altered when node 45 is removed and then inserted after node 39. True False
true
The traversal algorithm supports both singly-linked and doubly-linked lists. True False
true
Using a dummy node simplifies the algorithms for a linked list because the head and tail pointers are never null. True False
true
Each node in a doubly-linked list contains data and _____ pointer(s). one two
two
Given carList, ListRemove(carList, node Bugatti) executes which of the following statements? list⇢head = sucNode Yes No
yes
Given carList, ListRemove(carList, node Bugatti) executes which of the following statements? sucNode⇢prev = predNode Yes No
yes
Given numList, ListRemove(numList, node 12) executes which of the following statements? predNode⇢next = sucNode Yes No
yes
Given numList, ListRemove(numList, node 12) executes which of the following statements? sucNode⇢prev = predNode Yes No
yes
Given numList, ListRemoveAfter(numList, node 55) executes which of the following statements? curNode⇢next = sucNode Yes No
yes A successor node exists, so node 55's next pointer is pointed to node 74.
Given charList, ListRemoveAfter(charList, null) executes which of the following statements? list⇢head = sucNode Yes No
yes The node being removed, node H, is the list head, so the list's head pointer will be pointed to node A.
Given charList, ListRemoveAfter(charList, null) executes which of the following statements? sucNode = list⇢head⇢next Yes No
yes curNode is null, so the head node is removed. Node A is the list head's successor.
