oracle pac
TRANSCRIPT
-
8/3/2019 Oracle PAC
1/30
Question Number 1
Given the following code snippet:
void InsertNode(tNode** node, int i){
if(*node == NULL){
*node = new tNode;(*node)->pLeft = NULL;
(*node)->data = i;
(*node)->pRight = NULL;
SetRootNode(node);
return;
}
else{
if(i < (*node)->data)
InsertNode(&((*node)->pLeft), i);
if(i > (*node)->data)
InsertNode(&((*node)->pRight), i);
return;
}}
void Func(tNode **node){
if(*node!=NULL){
Func(&(*node)->pLeft);
tNode *temp;
temp = (*node)->pLeft;
(*node)->pLeft= (*node)->pRight;
(*node)->pRight = temp;
Func(&(*node)->pRight);
}
}
void traverse(tNode** nd){
if(*nd!=NULL){
traverse(&((*nd)->pLeft));
traverse(&((*nd)->pRight));
std::cout
-
8/3/2019 Oracle PAC
2/30
}
bT->InsertNode(bT->GetRootNode(), 97);
bT->Func(bT->GetRootNode());
bT->InsertNode(bT->GetRootNode(), 99);
bT->traverse(bT->GetRootNode());
}
98,15,78,96,97,99,10,12,5,100,120,110
110,120,100,5,12,10,99,97,96,78,15,98
100,110,120,98,5,10,12,15,78,96,97,99
None of these
-------------------------------------------------------------
Question Number 2
Given the following code snippet:
void InsertNode(tNode** node, int i){
if(*node == NULL){
*node = new tNode;
(*node)->pLeft = NULL;
(*node)->data = i;(*node)->pRight = NULL;
SetRootNode(node);
return;
}
else{
if(i < (*node)->data)
InsertNode(&((*node)->pLeft), i);
if(i > (*node)->data)
InsertNode(&((*node)->pRight), i);
return;
}
}
void Func(tNode **node){
if(*node!=NULL){
Func(&(*node)->pLeft);
tNode *temp;
temp = (*node)->pLeft;
(*node)->pLeft= (*node)->pRight;
(*node)->pRight = temp;
Func(&(*node)->pRight);
-
8/3/2019 Oracle PAC
3/30
}
}
void traverse(tNode** nd){
if(*nd!=NULL){
traverse(&((*nd)->pLeft));
traverse(&((*nd)->pRight));
std::couttraverse(bT->GetRootNode());
}
120,110,100,99,98,96,78,15,12,10,5
98,100,120,110,99,15,78,96,12,5,110
110,5,12,96,78,15,99,110,120,100,98
5,10,12,15,78,96,98,99,100,110,120
------------------------------------------------
Question Number 3
Given the following code snippet:
void InsertNode(tNode** node, int i){
if(*node == NULL){
*node = new tNode;
(*node)->pLeft = NULL;
(*node)->data = i;
(*node)->pRight = NULL;
-
8/3/2019 Oracle PAC
4/30
SetRootNode(node);
return;
}
else{
if(i < (*node)->data)
InsertNode(&((*node)->pLeft), i);
if(i > (*node)->data)InsertNode(&((*node)->pRight), i);
return;
}
}
void Func(tNode **node){
if(*node!=NULL){
Func(&(*node)->pLeft);
tNode *temp;
temp = (*node)->pLeft;
(*node)->pLeft= (*node)->pRight;
(*node)->pRight = temp;
Func(&(*node)->pRight);}
}
void traverse(tNode** nd){
if(*nd!=NULL){
traverse(&((*nd)->pLeft));
traverse(&((*nd)->pRight));
std::coutInsertNode(bT->GetRootNode(), 99);
bT->Func(bT->GetRootNode());
bT->traverse(bT->GetRootNode());
}
-
8/3/2019 Oracle PAC
5/30
5,12,10,99,96,78,15,110,120,100,98
98,100,120,110,15,78,96,99,10,12,5
5,10,12,15,78,96,98,99,100,110,120
5,10,12,15,78,96,99,98,100,110,120
------------------------------------------
Question Number 4
Given the following code snippet:
void InsertNode(tNode** node, int i){
if(*node == NULL){
*node = new tNode;
(*node)->pLeft = NULL;
(*node)->data = i;
(*node)->pRight = NULL;
SetRootNode(node);
return;
}
else{
if(i < (*node)->data)
InsertNode(&((*node)->pLeft), i);
if(i > (*node)->data)
InsertNode(&((*node)->pRight), i);
return;}
}
void Func(tNode **node){
if(*node!=NULL){
Func(&(*node)->pLeft);
tNode *temp;
temp = (*node)->pLeft;
(*node)->pLeft= (*node)->pRight;
(*node)->pRight = temp;
Func(&(*node)->pRight);
}
}void traverse(tNode** nd){
if(*nd!=NULL){
traverse(&((*nd)->pLeft));
traverse(&((*nd)->pRight));
std::cout
-
8/3/2019 Oracle PAC
6/30
Let the input given be
98,15,100,10,78,120,5,12,96,110
What would be the output of the following code snippet?
int main(void)
{tree *bT = new tree;
int i = 10;
int data;
while(i--){
std::coutGetRootNode(), data);
}
bT->Func(bT->GetRootNode());
bT->InsertNode(bT->GetRootNode(), 99);
bT->traverse(bT->GetRootNode());
}
98,15,78,96,99,10,12,5,100,120,110
100,110,120,98,5,10,12,15,78,96,99
110,120,100,5,12,10,99,96,78,15,98
99,96,78,15,12,10,5,98,120,110,100
----------------------------------------------------------
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \
-
8/3/2019 Oracle PAC
7/30
/ / \
"A" + "D"
/ \
/ \
/ \
"B" "C"
Suppose InternalNode implements getLeft and getRight as part of its public interface to allow external code to navigate the
tree. Their return type must be Node, because they may return either an internal or a terminal node. Which of the following
is true:
Node and TerminalNode must both provide concrete implementations of getLeft and getRight.
It is sufficient to implement getLeft and getRight in TerminalNode.
It is sufficient to implement getLeft and getRight in Node.
None of these options
--------------------------------------------------------------------------
Question Number 6
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \
/ / \"A" + "D"
/ \
/ \
/ \
"B" "C"
Consider this implementation of toString():
-
8/3/2019 Oracle PAC
8/30
abstract class Node {
abstract String toString();
}
class TerminalNode extends Node {
String toString() {
return value;}
}
class InternalNode extends Node {
String toString() {
if (null == left)
return "[" + right + "]";
else if (null == right)
return "[" + left + "]";
else
return "[" + left + " | " + right + "]";
}
}
Under what conditions will this implementation distinguish (i.e. produce different strings for) two trees that have the same
strings in the same sequence in their terminal nodes but different internal structures?
Never
Only for full trees (ones in which every internal node has two children, except possibly the parent of the rightmost
terminal node)
Always-------------------------------------------------------
Question Number 7
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
-
8/3/2019 Oracle PAC
9/30
/ / \
/ / \
/ / \
"A" + "D"
/ \
/ \
/ \"B" "C"
Should InternalNode have simple setters, as follows?
void setLeft(Node nd) {
left = nd;
}
void setRight(Node nd) {
right = nd;
}
Node removeRight() {
Node node = right;
right = null;
return node;
}
InternalNode removeRight() {
InternalNode node = right;
right = null;
return node;}
Node removeRight() {
right = null;
return right;
}
None of these options, since under some circumstances removing the right subtree of an InternalNode would violate the
specifications.-------------------------------------------------------------------
Question Number 8
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
-
8/3/2019 Oracle PAC
10/30
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \
/ / \
"A" + "D"
/ \
/ \
/ \"B" "C"
Suppose we want to be able to grow a tree by replacing the empty left or right subtree of an InternalNode (failing if that
subtree is not empty). Since this operation will fail under certain common conditions well have the method return a boolean
to indicate whether or not it succeeded, rather than throwing an exception. Which of the following best implement that idea
in keeping with the specifications in the instructions?
boolean addLeft(Node nd) {
if (left == null) {
left = nd;
return true;
}
else
return false;
}
and addRight similarly
boolean addLeft(Node nd) {
if (nd == null)
return false;
else {
left = nd;
return true;
}
}
and addRight similarly
boolean add(Node nd) {
if (nd == null && right == null)
-
8/3/2019 Oracle PAC
11/30
return false;
else {
left = nd;
return true;
}
}
and addRight similarly
boolean add(Node nd) {
if (nd == null)
return false;
else if (left == null) {
left = nd;
return true;
}
else if (right == null)
right = nd;
return true;}
else
return false;
}
----------------------------------------------------------
Question Number 9
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \
/ / \
"A" + "D"
/ \
/ \
/ \
"B" "C"
-
8/3/2019 Oracle PAC
12/30
Consider the following implementation of count as the number of nodes in a tree?
abstract class Node {
abstract int count();
}
class TerminalNode extends Node {int count() {
return 1;
}
}
class InternalNode extends Node {
int count() {
return 1 + left.count() + right.count();
}
}
Which of the following statements is true?
A run-time error could happen if left or right of an InternalNode were null.
TerminalNode.count should return 0, not 1.
InternalNode.count should not add 1 to the counts of its children.
The code is correct as shown.----------------------------------------------
Coding Skills (Advanced)
Support ID: 110E229
Question Number 10
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
-
8/3/2019 Oracle PAC
13/30
/ \
+ +
/ / \
/ / \
/ / \
"A" + "D"
/ \/ \
/ \
"B" "C"
Which of the following correctly defines count as the number of nodes in a tree if none of the other classes implement
count?
abstract class Node {
int count() {
return 1 + left.count() + right.count();
}
}
abstract class Node {
int count() {
return 1 +
((left == null) ? 0 : left.count()) +
((right == null) ? 0 : right.count());
}
}
A is correct, but B is not.
B is correct, but not A.
Neither is correct.
Both are correct.
-----------------------------------------
Support ID: 110E236
Skipped: Question Number 9
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
-
8/3/2019 Oracle PAC
14/30
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \/ \
/ \
+ +
/ / \
/ / \
/ / \
"A" + "D"
/ \
/ \
/ \
"B" "C"
Consider the following implementation of count as the number of nodes in a tree?
abstract class Node {
abstract int count();
}
class TerminalNode extends Node {
int count() {
return 1;
}
}
class InternalNode extends Node {
int count() {
return 1 + left.count() + right.count();
}
}
Which of the following statements is true?
A run-time error could happen if left or right of an InternalNode were null.
TerminalNode.count should return 0, not 1.
InternalNode.count should not add 1 to the counts of its children.
The code is correct as shown.
=====================================
Question Number 1
-
8/3/2019 Oracle PAC
15/30
Given the following code snippet answer the following question.
struct AVLTree
{
AVLTree * left;
AVLTree * right;int element;
int height;
};
int MAX(int a, int b){
if(a>=b)
return a;
if(aheight;
}
}
AVLTree * single_rotation_with_left(AVLTree *k2)
{
AVLTree *k1;
k1 = k2->left;
k2->left = k1->right;
k1->right = k2;
k2->height = MAX(height(k2->left), height(k2->right)) + 1;
k1->height = MAX(height(k1->left), height(k2->right)) + 1;
return k1;
}
AVLTree * single_rotation_with_right(AVLTree *k2)
{
AVLTree *k1;
k1 = k2->right;
k2->right = k1->left;
k1->left = k2;
k2->height = MAX(height(k2->left), height(k2->right)) + 1;k1->height = MAX(height(k1->right), height(k2->left)) + 1;
return k1;
}
AVLTree *double_rotation_with_left(AVLTree *k3)
{
k3->left = single_rotation_with_right(k3->left);
return single_rotation_with_left(k3);
}
AVLTree *double_rotation_with_right(AVLTree *k3)
-
8/3/2019 Oracle PAC
16/30
{
k3->right = single_rotation_with_left(k3->right);
return single_rotation_with_right(k3);
}
void insert(int value, AVLTree **node)
{
if (*node == NULL){
*node = new AVLTree;
if (*node == NULL)
{
return;
}
(*node)->element = value;
(*node)->height = 0;
(*node)->left = (*node)->right = NULL;
return;
}
else if (value < (*node)->element)
{insert(value, &((*node)->left));
if (height((*node)->left) - height((*node)->right) == 2)
{
if (value < (*node)->left->element)
{
*node = single_rotation_with_left(*node);
}
else
{
*node = double_rotation_with_left(*node);
}
}
}
else if (value > (*node)->element)
{
insert(value, &((*node)->right));
if (height((*node)->right) - height((*node)->left) == 2)
{
if (value > (*node)->right->element)
{
*node = single_rotation_with_right(*node);
}
else
{
*node = double_rotation_with_right(*node);}
}
}
(*node)->height = MAX(height((*node)->left), height((*node)->right)) + 1;
}
Consider an input sequence that is provided as an input to the insert method
20,5,15,9,13,2,6,12,14,15,16,17,18,19
-
8/3/2019 Oracle PAC
17/30
Let's give the root node of the resulting tree as input to the following code snippet
int func(AVLTree **p)
{
if (*p!=0)
return func (&(*p)->right) + 1;
elsereturn 0;
}
What would be the return value after execution of the above code snippet?
3
4
7
6
---------------------------------------------------------
Question Number 2
Given the following code snippet answer the following question.
struct AVLTree
{
AVLTree * left;
AVLTree * right;
int element;int height;
};
int MAX(int a, int b){
if(a>=b)
return a;
if(aheight;
}
}
AVLTree * single_rotation_with_left(AVLTree *k2)
{
-
8/3/2019 Oracle PAC
18/30
AVLTree *k1;
k1 = k2->left;
k2->left = k1->right;
k1->right = k2;
k2->height = MAX(height(k2->left), height(k2->right)) + 1;
k1->height = MAX(height(k1->left), height(k2->right)) + 1;
return k1;}
AVLTree * single_rotation_with_right(AVLTree *k2)
{
AVLTree *k1;
k1 = k2->right;
k2->right = k1->left;
k1->left = k2;
k2->height = MAX(height(k2->left), height(k2->right)) + 1;
k1->height = MAX(height(k1->right), height(k2->left)) + 1;
return k1;
}
AVLTree *double_rotation_with_left(AVLTree *k3){
k3->left = single_rotation_with_right(k3->left);
return single_rotation_with_left(k3);
}
AVLTree *double_rotation_with_right(AVLTree *k3)
{
k3->right = single_rotation_with_left(k3->right);
return single_rotation_with_right(k3);
}
void insert(int value, AVLTree **node)
{
if (*node == NULL)
{
*node = new AVLTree;
if (*node == NULL)
{
return;
}
(*node)->element = value;
(*node)->height = 0;
(*node)->left = (*node)->right = NULL;
return;
}
else if (value < (*node)->element)
{insert(value, &((*node)->left));
if (height((*node)->left) - height((*node)->right) == 2)
{
if (value < (*node)->left->element)
{
*node = single_rotation_with_left(*node);
}
else
{
-
8/3/2019 Oracle PAC
19/30
*node = double_rotation_with_left(*node);
}
}
}
else if (value > (*node)->element)
{
insert(value, &((*node)->right));if (height((*node)->right) - height((*node)->left) == 2)
{
if (value > (*node)->right->element)
{
*node = single_rotation_with_right(*node);
}
else
{
*node = double_rotation_with_right(*node);
}
}
}
(*node)->height = MAX(height((*node)->left), height((*node)->right)) + 1;
}
Consider an input sequence that is provided as an input to the insert method
20,5,15,9,13,2,6,12,14,15,16,17,18,19
Let's give the root node of the resulting tree as input to the following code snippet
int func(AVLTree **p)
{
if (*p!=0)
return func (&(*p)->right) + func (&(*p)->left) + 1;
else
return 0;
}
What would be the return value after execution of the above code snippet?
13
14
15
None of these
-----------------------------------------
Question Number 3
Given the following code snippet answer the following question.
-
8/3/2019 Oracle PAC
20/30
struct AVLTree
{
AVLTree * left;
AVLTree * right;
int element;
int height;};
int MAX(int a, int b){
if(a>=b)
return a;
if(aheight;
}
}
AVLTree * single_rotation_with_left(AVLTree *k2)
{
AVLTree *k1;
k1 = k2->left;
k2->left = k1->right;
k1->right = k2;
k2->height = MAX(height(k2->left), height(k2->right)) + 1;
k1->height = MAX(height(k1->left), height(k2->right)) + 1;
return k1;
}
AVLTree * single_rotation_with_right(AVLTree *k2)
{
AVLTree *k1;
k1 = k2->right;
k2->right = k1->left;
k1->left = k2;
k2->height = MAX(height(k2->left), height(k2->right)) + 1;
k1->height = MAX(height(k1->right), height(k2->left)) + 1;
return k1;}
AVLTree *double_rotation_with_left(AVLTree *k3)
{
k3->left = single_rotation_with_right(k3->left);
return single_rotation_with_left(k3);
}
AVLTree *double_rotation_with_right(AVLTree *k3)
{
k3->right = single_rotation_with_left(k3->right);
-
8/3/2019 Oracle PAC
21/30
return single_rotation_with_right(k3);
}
void insert(int value, AVLTree **node)
{
if (*node == NULL)
{
*node = new AVLTree;if (*node == NULL)
{
return;
}
(*node)->element = value;
(*node)->height = 0;
(*node)->left = (*node)->right = NULL;
return;
}
else if (value < (*node)->element)
{
insert(value, &((*node)->left));
if (height((*node)->left) - height((*node)->right) == 2){
if (value < (*node)->left->element)
{
*node = single_rotation_with_left(*node);
}
else
{
*node = double_rotation_with_left(*node);
}
}
}
else if (value > (*node)->element)
{
insert(value, &((*node)->right));
if (height((*node)->right) - height((*node)->left) == 2)
{
if (value > (*node)->right->element)
{
*node = single_rotation_with_right(*node);
}
else
{
*node = double_rotation_with_right(*node);
}
}}
(*node)->height = MAX(height((*node)->left), height((*node)->right)) + 1;
}
Consider an input sequence that is provided as an input to the insert method
20,5,15,9,13,2,6,12,14,15,16,17,18,19
In the process of inserting the above nodes how many times double_rotation_with_right is being called
-
8/3/2019 Oracle PAC
22/30
3
5
2
-----------------------------------
Question Number 4
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \ / / \
"A" + "D"
/ \
/ \
/ \
"B" "C"
The problem with the previous definition of InternalNode.sameShape is that it calls nd.getLeft() and nd.getRight(), but only
InternalNode defines those methods and nd could be a TerminalNode. The following code fixes that and will compile, but it
omits the tests for null
abstract class Node {
abstract boolean isTerminal();
abstract boolean sameShape(Node);
}
class TerminalNode extends Node {
boolean isTerminal() {
return true;
}
boolean sameShape(Node nd) {
-
8/3/2019 Oracle PAC
23/30
return nd.isTerminal();
}
}
class InternalNode extends Node {
boolean isTerminal() {
return false;}
boolean sameShape(Node nd) {
return
!nd.isTerminal() &&
left.sameShape(((InternalNode)nd).getLeft()) &&
right.sameShape(((InternalNode)nd).getRight());
}
}
If sameShape is called on an InternalNode with a non-null argument, which of the two methods could end up getting called
with a null argument for certain trees?
Neither would ever get called with a null argument.
TerminalNode.sameShape might be called with a null argument but not InternalNode.sameShape.
InternalNode.sameShape might be called with a null argument but not TerminalNode.sameShape.
Both methods could get called with a null argument.
---------------------------------------------------------Question Number 5
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \
-
8/3/2019 Oracle PAC
24/30
/ / \
"A" + "D"
/ \
/ \
/ \
"B" "C"
It is proposed to add a check for null at the beginning of each method, returning False if the argument is null, since a Node
object would never have the same shape as null. This change is shown in the code below. Which methods will compile and
work correctly now?
abstract class Node {
abstract boolean equals(Node);
}
class TerminalNode extends Node {
boolean sameShape(Node nd) {
return nd != null;
}
}
class InternalNode extends Node {
boolean sameShape(Node nd) {
return
nd != null &&
left.sameShape(nd.getLeft()) &&
right.sameShape(nd.getRight());
}
}
Both TerminalNode.sameShape and InternalNode.sameShape are correct.
TerminalNode.sameShape is fine the way it is but InternalNode.sameShape will not compile.
TerminalNode.sameShape is fine the way it is but although TerminalNode.sameShape will compile, it is incorrect.
Neither TerminalNode.sameShape nor InternalNode.equals provides a correct solution: each either does not compile or is
not correct.
-----------------------------------------------
Question Number 6
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
-
8/3/2019 Oracle PAC
25/30
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \/ \
/ \
+ +
/ / \
/ / \
/ / \
"A" + "D"
/ \
/ \
/ \
"B" "C"
Here is a proposed implementation of sameShape for the tree structure:
abstract class Node {
abstract boolean sameShape(Node nd);
}
class TerminalNode extends Node {
boolean sameShape(Node nd) {
return true;
}
}
class InternalNode extends Node {
boolean sameShape(Node nd) {
return left.sameShape(nd.getLeft()) &&
right.sameShape(nd.getRight());
}
}
Which classes contain correctly implemented methods?
TerminalNode
InternalNode
A, but not B
B, but not A
Neither
-
8/3/2019 Oracle PAC
26/30
Both
---------------------------
Support ID: 110E22E
Question Number 7
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+/ \
/ \
/ \
+ +
/ / \
/ / \
/ / \
"A" + "D"
/ \
/ \
/ \
"B" "C"
One problem with the proposed implementation of sameShape is that two nodes of different types cannot have the same
shape. In the following code which of TerminalNode.sameShape and InternalNode.sameShape correct this problem (though
possibly leaving others uncorrected)?
abstract class Node {
abstract boolean isTerminal();
abstract boolean sameShape(Node);
}
class TerminalNode extends Node {
boolean isTerminal() {
return true;}
boolean sameShape(Node nd) {
return nd != null && nd.isTerminal();
}
}
class InternalNode extends Node {
boolean isTerminal() {
return false;
-
8/3/2019 Oracle PAC
27/30
}
boolean sameShape(Node nd) {
return
nd != null &&
!nd.isTerminal() &&
getLeft().sameShape(((InternalNode)nd).getLeft()) &&
getRight().sameShape(((InternalNode)nd).getRight());}
}
Neither
TerminalNode but not InternalNode
InternalNode but not TerminalNode
Both
---------------------------------------------
Question Number 8
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left childB and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \
/ / \
"A" + "D"/ \
/ \
/ \
"B" "C"
We want to define an operation to get the list element at position N (with the first element is at position 0). Which
statements are correct in the following implementation? In answering, take into account all details of the statements
labelled (A) and (B).
-
8/3/2019 Oracle PAC
28/30
class SinglyLinkedList {
InternalNode first;
String nth(int n) {
InternalNode nd = first;
while (n-- > 0) nd = nd.getRight(); // (A)return ((TerminalNode)(nd.getLeft())).getValue(); // (B)
}
}
A is completely correct, but B is not
B is completely correct, but A is not
Neither is completely correct.
Both are completely correct.
==============================
Question Number 9
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \
/ / \"A" + "D"
/ \
/ \
/ \
"B" "C"
-
8/3/2019 Oracle PAC
29/30
In the implementation of many linear linked structures it is often useful to keep a pointer to the last node in addition to the
first, so that a new node can be added at the end without having to loop through the entire structure looking for the last
node. In what ways would adding a pointer to the last node improve the efficiency of this dictionary implementation?
It would speed up put operations when the dictionary contains an item with the designated key.
It would speed up put operations when the dictionary does not contain an item with the designated key.
A but not B
B but not A
Both
Neither
----------------------------------
Question Number 10
The subject of these questions is an unusually simple kind of binary tree, defined by these properties:
Terminal nodes contain a string.
Internal nodes have one or two children, called "left" and "right".
Either child of an internal node may be null, but not both.
Internal nodes contain no other information.
By "tree" we simply mean a node and all of its descendants.
A tree rooted at a node having left child A and right child B is a different tree than one rooted at a node having left child
B and right child A.
Here's an example, with plus signs (+) used to indicate internal nodes:
+
/ \
/ \
/ \
+ +
/ / \
/ / \
/ / \
"A" + "D"
/ \/ \
/ \
"B" "C"
Under what conditions would the following either produce an error or return an incorrect result? (Assume that given a top-
level InternalNode (one whose left child is also an InternalNode) next and getValue are correctly defined.)
public String get(String y) throws Exception {
-
8/3/2019 Oracle PAC
30/30
InternalNode cur = first;
while ((null != cur) && (!k.equals(getKey(cur))))
cur = next(cur);
return getValue(cur);
when the dictionary is empty
when the dictionary contains an entry whose key is equal to k
when the dictionary does not contain an entry whose key is equal to k
A and B but not C
A only
B and C but not A
It is correct for all three conditions.
-----------------------------------