Why do we prefer Red Black tree over AVL tree?

Concept: AVL trees and Red Black trees are both self-balancing binary search trees guaranteeing O(log n) height, but they differ in how strictly balance is enforced and how that balance is tracked.

AVL trees enforce a strict height-balance condition — the heights of the two child subtrees of any node can differ by at most 1 — checked using an explicit balance factor stored at every node. Red Black trees use a looser invariant instead: no root-to-leaf path is more than twice as long as any other path, guaranteed by simple coloring rules (root is black, no two adjacent red nodes, every path has the same number of black nodes), tracked with just one color bit per node.

Application: AVL's stricter invariant costs relatively little on insertion — a single insertion needs at most one rebalancing step (one or two rotations) — but on deletion, imbalance can propagate all the way up the tree, so an AVL deletion can need up to O(log n) rotations in the worst case. Red Black trees' looser invariant keeps this bounded on both operations: at most 2 rotations for insertion and at most 3 rotations for deletion, regardless of tree height. So it is specifically the delete path where Red Black trees clearly win on rotation count, and every node also stores only a single color bit instead of a multi-bit balance factor — together these are why Red Black trees cost less to maintain, which is exactly why they are the standard choice for frequently-updated structures (e.g., the Linux kernel's scheduler, C++ std::map, Java's TreeMap).

• Red Black trees are not as strictly balanced as AVL trees — true, and that relaxed rule is what enables the performance benefits below, but stated alone it's a structural description, not itself one of the two counted reasons.

• Fewer rotations during insertion/deletion — true, and one real reason, but only half the picture.

• Less memory needed for the balance information — also true, and the other real reason.

Since both of these performance reasons hold at once, the complete justification combines them — matching the option that states both together (Answer: option stating both fewer rotations and less memory).