WZPGCL Assistant Engineer (CSE) — Exam: 27.05.2023প্রশ্ন ও সমাধান

Direct answer: pre-order traversal visits Root → Left → Right; post-order traversal visits Left → Right → Root — they differ only in when the root is visited relative to its subtrees.

graph TD
  A((A))-->B((B))
  A-->C((C))
  B-->D((D))
  B-->E((E))
  C-->F((F))
  C-->G((G))

Pre-order (Root, Left, Right): visit the root first, then recursively traverse the left subtree, then the right subtree.

• Traversal order on the tree above: A → B → D → E → C → F → G

preorder(node):
  if node is null: return
  visit(node)
  preorder(node.left)
  preorder(node.right)

Post-order (Left, Right, Root): recursively traverse the left subtree, then the right subtree, and visit the root last.

• Traversal order on the tree above: D → E → B → F → G → C → A

postorder(node):
  if node is null: return
  postorder(node.left)
  postorder(node.right)
  visit(node)

Why the difference matters: pre-order is used to create a copy of a tree (root must be processed before its children can be attached), while post-order is used to safely delete a tree or evaluate an expression tree (children — operands — must be resolved before the parent — operator — is applied).

Exam takeaway: remember the mnemonic position of "Root" in the name — Pre-order puts Root first (before L, R); Post-order puts Root last (after L, R); both are O(n) time since every node is visited exactly once.

Definition. A constructor is a special member function that initializes an object at the moment it is created; it shares the class's name, has no return type (not even void), and runs automatically when the object is instantiated.

Key properties:

• Same name as the class — the compiler recognizes it as the initializer.
• No return type — distinguishes it from a regular method that happens to share the class name.
• Automatic invocation — called implicitly on object creation; never called like an ordinary method.
• Can be overloaded — multiple constructors with different parameter lists may coexist.
• Default constructor — if none is written, the compiler supplies a no-argument one that default-initializes members.
• Not inherited, though a subclass constructor can invoke a parent's via super(...)/an initializer list.

Example (Java):

class Rectangle {
    int width, height;
    Rectangle() { width = 1; height = 1; }               // default constructor
    Rectangle(int w, int h) { width = w; height = h; }    // parameterized (overloaded)
    int area() { return width * height; }
}
Rectangle r1 = new Rectangle();      // width=1, height=1
Rectangle r2 = new Rectangle(4, 5);  // width=4, height=5

Exam takeaway: a constructor's job is guaranteed initialization — same name, no return type, auto-invoked, overloadable — exactly what distinguishes it from every other member function.