20232 IT3011 CTDL&TT Quiz 09 Cây nhị phân tổng quát

1
Cho hàm sau, khi áp dụng với đầu vào là 2 cây trên thì kết quả trả về sẽ là gì?

int compareTree(TN* r1, TN* r2)

{
if(r1==NULL && r2==NULL) return 1;
if((r1!=NULL && r2==NULL)||(r1==NULL&&r2!=NULL)) return 0;
return compareTree(r1->left, r2->right) && compareTree(r1->right, r2->left);
}

 0
 1
 Hàm lỗi

2
Cho cây nhị phân tìm tổng quát như hình.
Khi chạy thuật toán ở dưới thì thứ tự các nút được in ra sẽ là

void treeTravel(TN* root)

{
if(NULL==root) return;
treeTravel(root->left);
treeTravel(root->right);
printf("%c ",root->label);
}
  DEBFHGCA
 DBEACFGH
 ABDECGFH
 Không có thứ tự nào ở trên là đúng

3
Cây nhị phân tổng quát chỉ chứa nút trong có 2 con hoặc nút lá
Cho thứ tự duyệt trước A C D F E G J B I K H L M
thứ tự duyệt giữa D C E F G A B J H K L I M

Đâu là khẳng định đúng

 Con của J là B và F
 Chiều cao cây là 4 (chiều cao nút lá là 0)
 L là con của K
 G là con của C
 H là nút 1 lá sâu nhất trên cây

4
Cho cây nhị phân tìm tổng quát như hình.
Khi chạy thuật toán ở dưới thì
int calculate(TN* root, int level)
{
if(NULL==root) return -1;
if(level==0) {printf("%c ", root->label); return 1;}
calculate(root->left,level-1);
calculate(root->right,level-1);
}

Chú ý: Root là gốc cây, nút A

 calculate(root,1) in ra B C
 calculate(root,1) in ra A
 calculate(root,2) in ra D E G
 Không có kết quả nào ở trên là đúng
 calculate(root,2) in ra B C

5
Cho cây nhị phân tìm tổng quát như hình.
Khi chạy thuật toán ở dưới thì thứ tự các nút được in ra sẽ là

void treeTravel(TN* root)

{
if(NULL==root) return;
treeTravel(root->right);
 printf("%c ",root->label);
treeTravel(root->left);
}

 DEBFHGCA
 DBEACFGH
 ABDECGFH
 Không có thứ tự nào ở trên là đúng

6
Cho cây nhị phân tìm tổng quát như hình.
Khi chạy thuật toán ở dưới thì

void printLeaves(TN* root)

{
if(NULL==root) return;
queue<pair<TN*, int>> Q;
Q.push(make_pair(root, 0));
int currDepth=0, firstLeafDepth=-1;
while (Q.size() > 0)
{
// lay nut tiep trong hang doi
TN* p = Q.front().first; // la truong thu 1 cuar pair
 currDepth = Q.front().second; // la truong thu 2 cua pair
Q.pop();

// meu gap nut la dau tien trong queue --> Khong them tiep cac nut nua
if(p->left==NULL && p->right==NULL)
{
if(firstLeafDepth==-1) firstLeafDepth = currDepth;
if(currDepth==firstLeafDepth)
printf("%c ", p->label);
continue;
}
else if(firstLeafDepth==-1)
{
if (NULL != p->left) Q.push(make_pair(p->left, currDepth + 1));
if (NULL != p->right) Q.push(make_pair(p->right, currDepth + 1));
}
}
printf("\n");
}

Chú ý: Root là gốc cây, nút A

 printLeaves(root) in ra D E
 printLeaves(root) in ra D
  printLeaves(root) in ra D E G
 printLeaves(root) in ra D E F H
 printLeaves(root->right) in ra F H
 printLeaves(root->right) in ra C

7
Cho đoạn code sau

void printNodes(struct Node* root, int level) {

if (root == NULL) return;
if (level == 1 && root->left==NULL
&& root->right==NULL) {
printf("%c ", root->data);
} else if (level > 1) {
printDeepestLeafNodes(root->left, level - 1);
printDeepestLeafNodes(root->right, level - 1);
}
}

 Nếu root là A và level =1 hàm sẽ in ra A

 Nếu root là A và level =2 hàm sẽ in ra B,C
 Nếu root là A và level =0 hàm lỗi
 Nếu root là A và level =3 hàm sẽ in ra G H I
 Nếu root là A và level =3 hàm sẽ in ra E F J D
 Nếu root là A và level =3 hàm sẽ in ra F
 Nếu root là A và level = 5 hàm lỗi
 Nếu root là A và level =3 hàm sẽ in ra J F
 Nếu root là A và level =4 hàm sẽ in ra G H I

8
Cho hàm sau, đâu là khẳng định đúng
Nút gốc root luôn là A

int calDepth(struct BNODE *root, struct BNODE *curr)

{
 if (root==NULL) return 0;

if ((root->leftChild == curr) || (root->rightChild == curr))

{
return 1;
}

int leftDepth = calDepth(root->leftChild, curr);

if (leftDepth > 0 ) leftDepth = leftDepth + 1;
int rightDepth = calDepth(root->rightChild, curr);
if (rightDepth > 0) rightDepth = rightDepth + 1;

return (leftDepth > rightDepth) ? leftDepth : rightDepth;

}

 Nếu curr cũng là A thì hàm lỗi

 Nếu curr cũng là A thì hàm trả về 0
 Nếu curr là E thì hàm trả về 0
 Nếu curr là C thì hàm trả về 1
 Nếu curr là F thì hàm trả về 2
9
Cho hàm sau, khi áp dụng với đầu vào là 2 cây trên thì kết quả trả về sẽ là gì?

int compareTree(TN* r1, TN* r2)

{
if(r1==NULL && r2==NULL) return 1;
if((r1->left==NULL && r2->left==NULL)||(r1->right==NULL && r2->right==NULL)) return 1;
return compareTree(r1->left, r2->left) + compareTree(r1->right, r2->right);
}

 0
 1
 Hàm lỗi

10
Cho hàm sau, điền gì vào chỗ khuyết ?

struct BNODE *findNode(struct BNODE *root, char label)

{
if(root==NULL||A) return root;
struct BNODE *left = findNode(root->left, label);
if(B) return left;
return findNode(C, label);
}

 A: root->label=label
 A: root->label==label
 B: left!= NULL
 B: left== NULL
 C: root->right
 C: root->left

11
Cho cây nhị phân tìm tổng quát như hình.
Khi chạy thuật toán ở dưới thì giá trị trả về của hàm sẽ là

int calculate(TN* root)

{
if(NULL==root) return 0;
int l = calculate(root->left);
int r = calculate(root->right);
return 1+ l+r;
}

 7
 8
 9
 Không có kết quả nào ở trên là đúng
 10

12
Cho đoạn code sau

struct Node* find(struct Node* root, struct Node* rNode)

{
if(root==NULL||root->left==rNode
|| root->right==rNode) return root;
struct Node *left = find(root->left, rNode);
if(left!=NULL) return left;
 return find(root->right, rNode);
}

 Nếu root là A và rNode là F thì sẽ trả về nút A

 Nếu root là A và rNode là F thì sẽ trả về nút B
 Nếu root là A và rNode là A thì sẽ trả về NULL
 Nếu root là A và rNode là A thì hàm lỗi
 Nếu root là A và rNode là G thì sẽ trả về B
 Nếu root là A và rNode là I thì sẽ trả về J

13
Cho đoạn code sau

int isBalanced(struct BNODE* root) {

if (root == NULL)
return 0;
int leftHeight = isBalanced(root->left);
int rightHeight = isBalanced(root->right);
int diff = abs(leftHeight-rightHeight);
if(leftHeight <0||rightHeight <0 || diff>1) return -1;
return 1 + (leftHeight>rightHeight? leftHeight:rightHeight);
}
Đâu là khẳng định đúng
  Hàm trên bị lỗi
 Nếu root là A thì giá trị trả về của hàm là -1
 Nếu root là C thì giá trị trả về của hàm là -1
 Nếu root là E thì giá trị trả về của hàm là 0
 Nếu root là J thì gái trị trả về của hàm là 0

14
Cho cây nhị phân tìm tổng quát như hình.
Khi chạy thuật toán ở dưới thì giá trị trả về của hàm sẽ là

int calculate(TN* root)

{
if(NULL==root) return 0;
if(root->left==NULL && root->right==NULL) return 1;
int l = calculate(root->left);
int r = calculate(root->right);
return l+r;
}
  5
 4
 8
 Không có kết quả nào ở trên là đúng
 3

15
Hàm đếm tần số xuất hiện của khóa k trong cây nhị phân

int countOccurrences(struct Node* root, int k) {

if (root == NULL)
return 0;

int A;

queue<B> Q;
Q.push(root);
struct Node *cur;
while (!Q.empty()) {
C;
Q.pop();
if(cur->data == k) count++;
D Q.push(cur->left);
 E Q.push(cur->right);
}
return count;
}

 A: count = 0
 A: count
 B: struct Node
 B: struct Node*
 C: cur = Q.front()
 C: cur = Q.pop()
 D:
 D: if(cur->left!=NULL)
 E: if(cur->left!=NULL)
 E: if(cur->right!=NULL)
 E:

16
// Hàm kiểm tra xem hai cây nhị phân có đối xứng với nhau hay không (giá trị tại các nút đối xứng
cũng phải bằng nhau)
bool isMirror(struct Node* left, struct Node* right) {
if (A)
return true;
if (B)
return false;
return (C) && isMirror(left->left, right->right) && isMirror(left->right, right->left);
}

// Hàm kiểm tra xem cây nhị phân có đối xứng hay không
bool isSymmetric(struct Node* root) {
if (root == NULL)
return D;
return isMirror(root->left, root->right);
}
 A: left == NULL && right == NULL
 A: left == NULL || right == NULL
 B: left == NULL || right == NULL
 B: left == NULL && right == NULL
 C: left->data != right->data
 C: left->data == right->data
 D: true
 D: false

17
// Định nghĩa cấu trúc của một nút trong cây nhị phân
struct Node {
int data; // giá trị nút chỉ là 1 hoặc 0
struct Node* left;
struct Node* right;
};

// Hàm tìm độ dài đường đi chứa số 1 dài nhất từ gốc

int longestPath(struct Node* root)
{
if(root==NULL) return A;
if(root->data==0) return B;
int left = longestPath(root->left);
int right = longestPath(root->right);
return C;
}

 A: 0
 A: -1
 B: 0
 B: -1
 C: left>right?left:right
 C: 1+ (left>right?left:right)

18
Cho cây nhị phân tìm tổng quát như hình.
Khi chạy thuật toán ở dưới thì giá trị trả về của hàm sẽ là

int calculate(TN* root)

{
if(NULL==root) return 0;
int l = calculate(root->left);
int r = calculate(root->right);
return 1+ (l>r?l:r);
}
  3
 4
 2
 Không có kết quả nào ở trên là đúng
 5

19
Cho đoạn code sau

void findNode(struct BNODE *root, struct BNODE **aNode)

{
if(root==NULL) return;
if(root->label > (*maxNode)->label) *aNode= root;
findMaxNode(root->left, aNode);
findMaxNode(root->right,aNode);
}

Đâu là khẳng định đúng

  Hàm trên bị lỗi
 Nếu root là A và aNode là A thì sau khi gọi hàm aNode sẽ trả về nút I
 Nếu root là A và aNode là A thì sau khi gọi hàm aNode sẽ trả về nút J
 Nếu root là B và aNode là A thì sau khi gọi hàm aNode sẽ trả về nút G
 Nếu root là B và aNode là NULL thì sau khi gọi hàm aNode sẽ trả về nút H
 Nếu root là E và aNode là A thì sau khi gọi hàm sẽ bị lỗi

20
Cho hàm sau, khi áp dụng với đầu vào là processTree(root->left, root->right) thì kết quả trả về sẽ là
gì?
root là gốc của cây

int processTree(TN* r1, TN* r2)

{
if(r1==NULL && r2==NULL) return 1;
if((r1!=NULL && r2==NULL)||(r1==NULL&&r2!=NULL)) return 0;
return 1 + processTree(r1->left, r2->left) + processTree(r1->right, r2->right);
}

processTree(root->left, root->right);
 1
 2
 0
 3
 Hàm bị lỗi