In object-oriented programming, each function is part of an object. The function can refer to the object in which it resides implicitly, so that object is not an explicit parameter. It is an implicit parameter.
A destructor recovers resources owned by an object. Typically,
it deletes memory that the object owns, but that is physically
outside the object.
The destructor for class River is called ~River.
The destructor is called any time an object is destroyed,
for any reason.
No. Using object-oriented programming typically makes programs larger and less efficient than if they had been designed by other means. But that is compensated for because the programs are better organized, easier to understand and easier to modify.
- What feature of C++ makes this possible?
The class, and private members of classes.
- Programmers rarely deliberately sabotage their own work.
Since programmers are not supposed to violate
abstractions, why is it so important that a compiler
prevent them from doing so? Can't programmers police themselves?
Even good programmers make mistakes, and the compiler should catch those mistakes wherever possible.
Programming teams often have some less experienced programmers who are likely to violate abstractions if permitted to do so. A compiler that disallows such violations gives the better programmers confidence that the less experienced programmers are not violating abstractions.
struct Polynomial {
int degree;
double* coef;
Polynomial(int n)
{
degree = n;
coef = new double[d+1];
}
};
Which of the following will create a polynomial with
degree 5?
- Polynomial P(5);
- Polynomial(5) P;
- Polynomial P; Polynomial(5);
- Polynomial P; P(5);
- P[1].coef = 3.5;
- P.coef[1] = 3.5;
- P.(*coef)[1] = 3.5;
- (*P).coef[1] = 3.5;
81
/ \
20 100
/ \
16 65
81 65
/ \ / \
20 100 20 81
/ \ / \ \
16 65 16 25 100
/
25
before rotations after rotations
The answer is the tree on the right. It is obtained from the
tree on the left by doing a double rotation at the root.
25
/ \
10 30
/ \
26 50
- Is this tree a binary search tree? That is, does it obey
the ordering requirements?
Yes.
- Ignoring the keys, is this tree height-balanced?
Yes.
- If you were to use the standard (unbalanced) binary search tree
insertion algorithm, show what this tree would look like after
inserting 40.
25 / \ 10 30 / \ 26 50 / 40 - Is the tree height-balanced after inserting 40, without
rebalancing?
No.
I presume that connect(A,B) tries to make A' point to B', rather than making B' point to A', where A' is the representative of A and B' is the representative of B.
|
 |
|
 |
|
 |
|
struct TreeNode {
int key;
TreeNode* left;
TreeNode* right;
TreeNode(TreeNode* l, int k, TreeNode* r)
{
left = l;
key = k;
right = r;
}
};
void PrintEvens(TreeNode* T)
{
if(T != NULL) {
PrintEvens(T->right);
if(T->key % 2 == 0) cout << T->key << endl;
PrintEvens(T->left);
}
}
Using the type TreeNode of the previous problem, write a function removeMin(t) that returns the tree that would result from removing the smallest value from tree t, but that does not alter tree t. If t is empty, then removeMin(t) should return an empty tree. For example, if t is the tree
81
/ \
20 100
\
65
/ \
50 70
then removeMin(t) should
return the following tree, without altering tree t.
81
/ \
65 100
/ \
50 70
Do not rebalance the tree.
The new tree that you construct can share
subtrees with t, as long as it does not change the subtrees.
TreeNode* removeMin(TreeNode* t)
{
if(t == NULL) return NULL;
else if(t->left == NULL) return t->right;
else return new TreeNode(removeMin(t->left), t->key, t->right);
}