![Page 1: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/1.jpg)
Basic algorithms with linked lists and binary trees
1
![Page 2: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/2.jpg)
Linked List Traversal
• A generic algorithm for visiting all list nodes
• Can be specialized for many goals
– Find minimum / maximum
– Search for given value
– Count number of occurrences of given value
• Building block for more complex algorithms
– Sorting
2
![Page 3: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/3.jpg)
Linked List Traversal
3
val: 13.40
next:
val: 12.50
next:
val:7.45
Next:
val:2.50
next: NULL
Input:
L // linked list; L is link to first node (red arrow)
// a node has two fields
// a value, called val, and
// a link to the next node, called next
Output:
// all node values, in the order in which they appear in the list
TraverseList(L)
curr = L // current node link is the link to the first node
while curr != NULL // while end of list has not been reached
print curr->val // print the val field of the node to which curr link points
curr = curr->next // move to next node
endwhile
endTraverseList
![Page 4: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/4.jpg)
Trace
4
val: 13.40
next:
val: 12.50
next:
val:7.45
Next:
val:2.50
next: NULL
Input:
L // linked list; L is link to first node (red arrow)
// a node has two fields
// a value, called val, and
// a link to the next node, called next
Output:
// all node values, in the order in which they appear in the list
TraverseList(L)
curr = L // current node link is the link to the first node
while curr != NULL // while end of list has not been reached
print curr->val // print the val field of the node
curr = curr->next // move to next node
endwhile
endTraverseList
A1 L A2 A3
curr curr->val curr->next Print Out
L 13.40 A1 13.40
A1 12.50 A2 12.50
A2 7.45 A3 7.45
A3 2.50 NULL 2.50
NULL
![Page 5: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/5.jpg)
Input:
L // linked list with (val, next) nodes
V // value to be inserted
Output:
// linked list with new node storing V, sorted
InsertSortedList(L, V)
N = link to new node // create new node
N->val = V // val of new node is input value V; don’t know next yet
curr = L // current node link is the link to the first node
prev = NULL // link to previous node, initially null
while curr != NULL // while end of list has not been reached
if curr->val < V then // if the current value is smaller than V
break // stop loop; insert btw prev and curr
endif
prev = curr // move to next node, update prev & curr
curr = curr->next
endwhile
N->next = curr
if prev != NULL then
prev->next = N
else
L = N
endif
endInsertSortedList
Insert node in sorted list
5
val: 13.40
next:
val: 12.50
next:
val:7.45
Next: NULL A1 L A2
![Page 6: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/6.jpg)
Input:
L // linked list with (val, next) nodes
V // value to be inserted
Output:
// linked list with new node storing V, sorted
InsertSortedList(L, V)
N = link to new node // create new node
N->val = V // val of new node is input value V; don’t know next yet
curr = L // current node link is the link to the first node
prev = NULL // link to previous node, initially null
while curr != NULL // while end of list has not been reached
if curr->val < V then // if the current value is smaller than V
break // stop loop; insert btw prev and curr
endif
prev = curr // move to next node, update prev & curr
curr = curr->next
endwhile
N->next = curr
if prev != NULL then
prev->next = N
else
L = N
endif
endInsertSortedList
Trace: V = 9.00
6
val: 13.40
next:
val: 12.50
next:
val:7.45
Next: NULL A1 L A2
N->next prev curr
NULL L
L A1
A1 A2
val: 9.00
next: N
![Page 7: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/7.jpg)
Input:
L // linked list with (val, next) nodes
V // value to be inserted
Output:
// linked list with new node storing V, sorted
InsertSortedList(L, V)
N = link to new node // create new node
N->val = V // val of new node is input value V; don’t know next yet
curr = L // current node link is the link to the first node
prev = NULL // link to previous node, initially null
while curr != NULL // while end of list has not been reached
if curr->val < V then // if the current value is smaller than V
break // stop loop; insert btw prev and curr
endif
prev = curr // move to next node, update prev & curr
curr = curr->next
endwhile
N->next = curr
if prev != NULL then
prev->next = N
else
L = N
endif
endInsertSortedList
Trace: V = 9.00
7
val: 13.40
next:
val: 12.50
next:
val:7.45
Next: NULL A1 L
A2
N->next prev prev->next curr
NULL L
L A1
A1 A2
A2 N
val: 9.00
next: N
![Page 8: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/8.jpg)
Input:
L // linked list with (val, next) nodes
V // value to be inserted
Output:
// linked list with new node storing V, sorted
InsertSortedList(L, V)
N = link to new node // create new node
N->val = V // val of new node is input value V; don’t know next yet
curr = L // current node link is the link to the first node
prev = NULL // link to previous node, initially null
while curr != NULL // while end of list has not been reached
if curr->val < V then // if the current value is smaller than V
break // stop loop; insert btw prev and curr
endif
prev = curr // move to next node, update prev & curr
curr = curr->next
endwhile
N->next = curr
if prev != NULL then
prev->next = N
else
L = N
endif
endInsertSortedList
Trace: V = 14.00
8
val: 13.40
next:
val: 12.50
next:
val:7.45
Next: NULL A1 L
N->next prev prev->next curr
NULL L
val: 14.00
next:
A2
N
![Page 9: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/9.jpg)
Input:
L // linked list with (val, next) nodes
V // value to be inserted
Output:
// linked list with new node storing V, sorted
InsertSortedList(L, V)
N = link to new node // create new node
N->val = V // val of new node is input value V; don’t know next yet
curr = L // current node link is the link to the first node
prev = NULL // link to previous node, initially null
while curr != NULL // while end of list has not been reached
if curr->val < V then // if the current value is smaller than V
break // stop loop; insert btw prev and curr
endif
prev = curr // move to next node, update prev & curr
curr = curr->next
endwhile
N->next = curr
if prev != NULL then
prev->next = N
else
L = N
endif
endInsertSortedList
Trace: V = 14.00
9
val: 13.40
next:
val: 12.50
next:
val:7.45
Next: NULL A1 L
N->next prev prev->next curr
NULL L
L
val: 14.00
next:
A2
N
![Page 10: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/10.jpg)
Input:
L // linked list with (val, next) nodes
V // value to be inserted
Output:
// linked list with new node storing V, sorted
InsertSortedList(L, V)
N = link to new node // create new node
N->val = V // val of new node is input value V; don’t know next yet
curr = L // current node link is the link to the first node
prev = NULL // link to previous node, initially null
while curr != NULL // while end of list has not been reached
if curr->val < V then // if the current value is smaller than V
break // stop loop; insert btw prev and curr
endif
prev = curr // move to next node, update prev & curr
curr = curr->next
endwhile
N->next = curr
if prev != NULL then
prev->next = N
else
L = N
endif
endInsertSortedList
Trace: V = 14.00
10
val: 13.40
next:
val: 12.50
next:
val:7.45
Next: NULL A1
N->next prev prev->next curr
NULL L
L
val: 14.00
next:
A2
L
![Page 11: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/11.jpg)
Input:
L // linked list with (val, next) nodes
V // value to be inserted
Output:
// linked list with new node storing V, sorted
InsertSortedList(L, V)
N = link to new node // create new node
N->val = V // val of new node is input value V; don’t know next yet
curr = L // current node link is the link to the first node
prev = NULL // link to previous node, initially null
while curr != NULL // while end of list has not been reached
if curr->val < V then // if the current value is smaller than V
break // stop loop; insert btw prev and curr
endif
prev = curr // move to next node, update prev & curr
curr = curr->next
endwhile
N->next = curr
if prev != NULL then
prev->next = N
else
L = N
endif
endInsertSortedList
iClicker Q What do the highlighted instructions achieve? A. If the new node is last they set its next link to NULL. B. If the new node is first they set the first node link to the new node. C. If the new node is not first they set the next link of the preceding node to the new node. D. A, B, and C E. A and C
![Page 12: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/12.jpg)
Binary tree traversal
• A generic algorithm for visiting all tree nodes
• Can be specialized for many goals
• Start at root
• Visit child nodes
• Visit children of children
• Some bookkeeping needed – Which nodes have been visited?
– Which are yet to be visited?
12
![Page 13: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/13.jpg)
Binary tree traversal
13
1
-1 2 5 10 24
6 19
3 32
13
T
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
Input: T // link to root of binary tree // a node stores (val, left, right) Output: // print all values stored in the tree TraverseBT(T) L = empty list of links to nodes L = InsertFirstList(L, T) while L is not empty curr = ExtractFirstNode(L) if curr != NULL then print curr->val L = InsertFirstList(L, curr->left) L = InsertFirstList(L, curr->right) endif endwhile endTraverseBT
![Page 14: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/14.jpg)
Trace
14
1
-1 2 5 10 24
6 19
3 32
13
Input: T // link to root of binary tree // a node stores (val, left, right) Output: // print all values stored in the tree TraverseBT(T) L = empty list of links to nodes L = InsertFirstList(L, T) while L is not empty curr = ExtractFirstNode(L) if curr != NULL then print curr->val L = InsertFirstList(L, curr->left) L = InsertFirstList(L, curr->right) endif endwhile endTraverseBT
T
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
L Curr Print Out
1 T
2 empty T
3 empty T 13
4 l1, l0 T
5 l0 l1
![Page 15: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/15.jpg)
Trace
15
1
-1 2 5 10 24
6 19
3 32
13
Input: T // link to root of binary tree // a node stores (val, left, right) Output: // print all values stored in the tree TraverseBT(T) L = empty list of links to nodes L = InsertFirstList(L, T) while L is not empty curr = ExtractFirstNode(L) if curr != NULL then print curr->val L = InsertFirstList(L, curr->left) L = InsertFirstList(L, curr->right) endif endwhile endTraverseBT
T
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
L Curr Print Out
5 l0 l1 32
6 NULL, l4, l0 l1
7 l4, l0 NULL
8 l9, l8, l0 l4 19
9 l8, l0 l9 24
![Page 16: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/16.jpg)
Trace
16
1
-1 2 5 10 24
6 19
3 32
13
Input: T // link to root of binary tree // a node stores (val, left, right) Output: // print all values stored in the tree TraverseBT(T) L = empty list of links to nodes L = InsertFirstList(L, T) while L is not empty curr = ExtractFirstNode(L) if curr != NULL then print curr->val L = InsertFirstList(L, curr->left) L = InsertFirstList(L, curr->right) endif endwhile endTraverseBT
T
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
L Curr Print Out
9 NULL, NULL, l8, l0 l9 24
10 NULL, l8, l0 NULL
11 l8, l0 NULL
12 NULL, NULL, l0 l8 10
13 NULL, l0 NULL
![Page 17: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/17.jpg)
Trace
17
1
-1 2 5 10 24
6 19
3 32
13
Input: T // link to root of binary tree // a node stores (val, left, right) Output: // print all values stored in the tree TraverseBT(T) L = empty list of links to nodes L = InsertFirstList(L, T) while L is not empty curr = ExtractFirstNode(L) if curr != NULL then print curr->val L = InsertFirstList(L, curr->left) L = InsertFirstList(L, curr->right) endif endwhile endTraverseBT
T
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
L Curr Print Out
13 NULL, l0 NULL
14 l0 NULL
15 l3, l2 l0 3
16 NULL, l7, l2 l3 6
17 NULL, NULL, l2 l7 5
![Page 18: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/18.jpg)
Trace
18
1
-1 2 5 10 24
6 19
3 32
13
Input: T // link to root of binary tree // a node stores (val, left, right) Output: // print all values stored in the tree TraverseBT(T) L = empty list of links to nodes L = InsertFirstList(L, T) while L is not empty curr = ExtractFirstNode(L) if curr != NULL then print curr->val L = InsertFirstList(L, curr->left) L = InsertFirstList(L, curr->right) endif endwhile endTraverseBT
T
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
L Curr Print Out
17 NULL, NULL, l2 l7 5
18 l6, l5 l2 1
19 NULL, NULL, l5 l6 2
19 NULL, NULL l5 -1
21 empty
![Page 19: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/19.jpg)
iClicker Q
19
Input: T // link to root of binary tree // a node stores (val, left, right) Output: // print all values stored in the tree TraverseBT(T) L = empty list of links to nodes L = InsertFirstList(L, T) while L is not empty curr = ExtractFirstNode(L) if curr != NULL then print curr->val L = InsertFirstList(L, curr->left) L = InsertFirstList(L, curr->right) endif endwhile endTraverseBT
Input: T // link to root of binary tree // a node stores (val, left, right) Output: // print all values stored in the tree TraverseBTM(T) L = empty list of links to nodes L = InsertFirstList(L, T) while L is not empty curr = ExtractFirstNode(L) print curr->val if curr->left != NULL L = InsertFirstList(L, curr->left) if curr->right != NULL L = InsertFirstList(L, curr->right) endwhile endTraverseBT
Is the modified algorithm TraverseBTM correct? A. Yes B. No
![Page 20: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/20.jpg)
Binary tree node count
20
1
-1 2 5 10 24
6 19
3 32
13
Input: T // link to root of binary tree // a node stores (val, left, right) Output: n // count of nodes CountNodesBT(T) L = empty list of links to nodes L = InsertList(L, T) n= 0 while L is not empty curr = ExtractFirstNode(L) if curr != NULL then n= n+ 1 // old “print curr->val” L = InsertList(L, curr->left) L = InsertList(L, curr->right) endif endwhile return n endCountNodesBT
T
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
![Page 21: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/21.jpg)
Recursive algorithm for binary tree node count
21
1
-1 2 5 10 24
6 19
3 32
13
T
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
• Insight
– T is a node with two binary trees connected to it
– Node count is • node count in left subtree (nl)
• + 1 for the root
• + node count in right subtree (nr)
n = nl + 1 +nr
![Page 22: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/22.jpg)
Recursive algorithm for binary tree node count
22
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR(T->left) + 1 + CountBTR (T->right)
endCountBTR
T0
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
![Page 23: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/23.jpg)
Recursive algorithm for binary tree node count
23
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR(T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7
Recursive because CountBTR calls CountBTR Recursion is a very powerful paradigm for designing algorithms
T0
![Page 24: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/24.jpg)
Trace
24
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) CountBTR(l2)+1+CountBTR(l3)
CountBTR(l2) CountBTR(l5)+1+CountBTR(l6)
CountBTR(l5) CountBTR(NULL)+1+CountBTR(NULL)
CountBTR(NULL) 0
T0
![Page 25: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/25.jpg)
Trace
25
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) CountBTR(l2)+1+CountBTR(l3)
CountBTR(l2) CountBTR(l5)+1+CountBTR(l6)
CountBTR(l5) 0+1+0
T0
![Page 26: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/26.jpg)
Trace
26
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) CountBTR(l2)+1+CountBTR(l3)
CountBTR(l2) CountBTR(l5)+1+CountBTR(l6)
CountBTR(l5) 1
T0
![Page 27: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/27.jpg)
Trace
27
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) CountBTR(l2)+1+CountBTR(l3)
CountBTR(l2) 1+1+CountBTR(l6)
CountBTR(l6) CountBTR(NULL)+1+CountBTR(NULL)
T0
![Page 28: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/28.jpg)
Trace
28
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) CountBTR(l2)+1+CountBTR(l3)
CountBTR(l2) 1+1+CountBTR(l6)
CountBTR(l6) 0+1+0
T0
![Page 29: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/29.jpg)
Trace
29
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) CountBTR(l2)+1+CountBTR(l3)
CountBTR(l2) 1+1+CountBTR(l6)
CountBTR(l6) 1
T0
![Page 30: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/30.jpg)
Trace
30
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) CountBTR(l2)+1+CountBTR(l3)
CountBTR(l2) 1+1+1
T0
![Page 31: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/31.jpg)
Trace
31
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) CountBTR(l2)+1+CountBTR(l3)
CountBTR(l2) 3
T0
![Page 32: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/32.jpg)
Trace
32
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) 3+1+CountBTR(l3)
T0
![Page 33: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/33.jpg)
Trace
33
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) 3+1+CountBTR(l3)
CountBTR(l3) CountBTR(l7)+1+CountBTR(NULL)
T0
![Page 34: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/34.jpg)
Trace
34
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) 3+1+CountBTR(l3)
CountBTR(l3) CountBTR(l7)+1+CountBTR(NULL)
CountBTR(l7) 0+1+0
T0
![Page 35: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/35.jpg)
Trace
35
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) 3+1+CountBTR(l3)
CountBTR(l3) 1+1+CountBTR(NULL)
T0
![Page 36: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/36.jpg)
Trace
36
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) 3+1+CountBTR(l3)
CountBTR(l3) 1+1+0
T0
![Page 37: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/37.jpg)
Trace
37
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) 3+1+2
T0
![Page 38: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/38.jpg)
Trace
38
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) CountBTR(l0)+1+CountBTR(l1)
CountBTR(l0) 6
T0
![Page 39: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/39.jpg)
Trace
39
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 6+1+CountBTR(l1)
T0
![Page 40: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/40.jpg)
Trace
40
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 6+1+CountBTR(l1)
CountBTR(l1) CountBTR(l4)+1+CountBTR(NULL)
T0
![Page 41: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/41.jpg)
Trace
41
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 6+1+CountBTR(l1)
CountBTR(l1) CountBTR(l4)+1+CountBTR(NULL)
CountBTR(l4) CountBTR(l8)+1+CountBTR(l9)
T0
![Page 42: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/42.jpg)
Trace
42
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 6+1+CountBTR(l1)
CountBTR(l1) CountBTR(l4)+1+CountBTR(NULL)
CountBTR(l4) CountBTR(l8)+1+CountBTR(l9)
CountBTR(l8) 0+1+0
T0
![Page 43: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/43.jpg)
Trace
43
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 6+1+CountBTR(l1)
CountBTR(l1) CountBTR(l4)+1+CountBTR(NULL)
CountBTR(l4) 1+1+CountBTR(l9)
CountBTR(l9) 0+1+0
T0
![Page 44: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/44.jpg)
Trace
44
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 6+1+CountBTR(l1)
CountBTR(l1) CountBTR(l4)+1+CountBTR(NULL)
CountBTR(l4) 1+1+1
T0
![Page 45: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/45.jpg)
Trace
45
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 6+1+CountBTR(l1)
CountBTR(l1) 3+1+0
T0
![Page 46: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/46.jpg)
Trace
46
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 6+1+4
T0
![Page 47: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/47.jpg)
Trace
47
1
-1 2 5 10 24
6 19
3 32
13
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
l0 l1
l2 l3 l4
l5 l6 l8 l9 l7 Call Return
CountBTR(T0) 11
T0
![Page 48: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/48.jpg)
iClicker Q
48
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTR(T)
if T == NULL
return 0
endif
return CountBTR (T->left) + 1 + CountBTR (T->right)
endCountBTR
Input:
T // link to root of binary tree
Output:
// count of nodes
CountBTRM(T)
if T->left != NULL then
leftCount = CountBTR (T->left)
else
leftCount = 0
if T->right != NULL then
rightCount = CountBTR (T->right)
else
rightCount = 0
return leftCount + 1 + rightCount
endCountBTR
Is the modified algorithm CountBTRM correct? A. Yes B. No
![Page 49: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/49.jpg)
Elements of recursive algorithm
• Recursive call – Algorithm calls itself on subsets of the input data – One ore more recursive calls
• For binary tree we had two recursive calls, one for each child
• Termination condition – At some point recursion has to stop – For example, don’t go beyond leafs
• Leafs don’t have children, referring to children leafs causes algorithm to crash
• Work to be done before, between, and after recursive calls – For example, print “(“, print string at current node, print “)”
![Page 50: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/50.jpg)
Recursion problem solving paradigm
• You don’t solve the problem directly
• Split the problem until it becomes trivial
• Compute solution to problem by combining solutions of sub-problems
• Examples – Counting nodes in binary trees
• No node means 0
• Number of nodes in tree is number of nodes in left subtree plus 1 plus number of nodes in right subtree
![Page 51: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/51.jpg)
Recursion problem solving paradigm
• You don’t solve the problem directly • Split the problem until it becomes trivial • Compute solution to problem by combining
solutions of sub-problems • Examples
– Counting nodes in binary trees – Evaluating arithmetic expression
• Value of leaf is number stored at leaf • Value for tree rooted at internal node is obtained by
applying operation stored at internal node to the values of the left and right subtrees
![Page 52: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/52.jpg)
Recursion problem solving paradigm
• You don’t solve the problem directly • Split the problem until it becomes trivial • Compute solution to problem by combining solutions of sub-
problems • Examples
– Counting nodes in binary trees – Evaluating arithmetic expression – Printing arithmetic expression
• Printout of leaf is string at leaf • Printout for internal node is
– Open parenthesis, – Followed by printout for left subtree, – Followed by string at current node, – Followed by printout for right subtree – Followed by closed parenthesis
![Page 53: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/53.jpg)
Evaluating arithmetic expression
53
Input: T // link to root of arithmetic expression binary tree Output: // expression printed out with parentheses EvalAEBTR(T) if T-> left == NULL return T->val endif switch T->symbol case ‘+’: return EvalAEBTR(T->left) + EvalAEBTR(T->right) case ‘-’: return EvalAEBTR(T->left) - EvalAEBTR(T->right) case ‘*’: return EvalAEBTR(T->left) * EvalAEBTR(T->right) case ‘/’: return EvalAEBTR(T->left) / EvalAEBTR(T->right) endswitch endEvalAEBTR -
3 1 5
*
+ 10
/
3
T
l0 l1
l2 l3
l4 l5 l6 l7
Switch statement is a condensed and readable substitute for multiple if statements
![Page 54: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/54.jpg)
Printing arithmetic expression bin. tree
54
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) (PrintAEBRT(l0) / PrintAEBRT(l1))
PrintAEBRT(l0) (PrintAEBRT(l2) + PrintAEBRT(l3))
PrintAEBRT(l2) (PrintAEBRT(l4) - PrintAEBRT(l5))
PrintAEBRT(l4) (PrintAEBRT(NULL) 3 PrintAEBRT(NULL))
T0
Printout
((((
![Page 55: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/55.jpg)
Printing arithmetic expression bin. tree
55
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) (PrintAEBRT(l0) / PrintAEBRT(l1))
PrintAEBRT(l0) (PrintAEBRT(l2) + PrintAEBRT(l3))
PrintAEBRT(l2) (PrintAEBRT(l4) - PrintAEBRT(l5))
PrintAEBRT(l4) (3)
T0
Printout
((((3)
![Page 56: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/56.jpg)
Printing arithmetic expression bin. tree
56
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) (PrintAEBRT(l0) / PrintAEBRT(l1))
PrintAEBRT(l0) (PrintAEBRT(l2) + PrintAEBRT(l3))
PrintAEBRT(l2) ((3) - PrintAEBRT(l5))
T0
Printout
((((3)-
![Page 57: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/57.jpg)
Printing arithmetic expression bin. tree
57
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) (PrintAEBRT(l0) / PrintAEBRT(l1))
PrintAEBRT(l0) (PrintAEBRT(l2) + PrintAEBRT(l3))
PrintAEBRT(l2) ((3) - PrintAEBRT(l5))
PrintAEBRT(l5) (PrintAEBRT(NULL) 1 PrintAEBRT(NULL))
T0
Printout
((((3)-
![Page 58: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/58.jpg)
Printing arithmetic expression bin. tree
58
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) (PrintAEBRT(l0) / PrintAEBRT(l1))
PrintAEBRT(l0) (PrintAEBRT(l2) + PrintAEBRT(l3))
PrintAEBRT(l2) ((3) - PrintAEBRT(l5))
PrintAEBRT(l5) (1)
T0
Printout
((((3)-(1)
![Page 59: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/59.jpg)
Printing arithmetic expression bin. tree
59
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) (PrintAEBRT(l0) / PrintAEBRT(l1))
PrintAEBRT(l0) (PrintAEBRT(l2) + PrintAEBRT(l3))
PrintAEBRT(l2) ((3) – (1))
T0
Printout
((((3)-(1))
![Page 60: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/60.jpg)
Printing arithmetic expression bin. tree
60
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) (PrintAEBRT(l0) / PrintAEBRT(l1))
PrintAEBRT(l0) (((3) – (1)) + PrintAEBRT(l3))
T0
Printout
((((3)-(1))+
![Page 61: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/61.jpg)
Printing arithmetic expression bin. tree
61
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) (PrintAEBRT(l0) / PrintAEBRT(l1))
PrintAEBRT(l0) (((3) – (1)) + ((5) * (3)))
T0
Printout
((((3)-(1))+((5)*(3)))
![Page 62: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/62.jpg)
Printing arithmetic expression bin. tree
62
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) ((((3) – (1)) +((5) * (3))) / PrintAEBRT(l1))
T0
Printout
((((3)-(1))+((5)*(3)))/
![Page 63: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/63.jpg)
Printing arithmetic expression bin. tree
63
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) ((((3) – (1)) +((5) * (3))) / PrintAEBRT(l1))
PrintAEBRT(l1) (10)
T0
Printout
((((3)-(1))+((5)*(3)))/(10)
![Page 64: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/64.jpg)
Printing arithmetic expression bin. tree
64
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
print “(“; PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right); print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Sub-calls
PrintAEBRT(T0) ((((3) – (1)) +((5) * (3))) / (10))
Correct, but parentheses around operands are annoying
T0
Printout
((((3)-(1))+((5)*(3)))/(10))
![Page 65: Basic algorithms with linked lists and binary trees · Linked List Traversal •A generic algorithm for visiting all list nodes •Can be specialized for many goals –Find minimum](https://reader035.vdocuments.mx/reader035/viewer/2022070719/5edf4364ad6a402d666a9c48/html5/thumbnails/65.jpg)
Printing arithmetic expression bin. tree
65
Input:
T // link to root of arithmetic expression binary tree
Output:
// expression printed out with parentheses
PrintAEBTR(T)
if T == NULL
return
endif
if T->left != NULL print “(“
PrintAEBTR(T->left)
print T->string
PrintAEBTR(T->right)
if T->left != NULL print “)“
endPrintAEBTR
-
3 1 5
*
+ 10
/
3
l0 l1
l2 l3
l4 l5 l6 l7
Call Printout
PrintAEBRT(T0) (((3 – 1) + (5 * 3)) / 10)
Don’t print parentheses for leaf nodes (i.e. operands) It is assumed that there are no nodes with one child
T0