Arrays store items side by side in memory, which is why reading any index is instant. 2-D arrays are stored row by row.

• ✗Using 1-based indexes. C++ arrays start at 0, so the last valid index is n − 1.
• ✗Writing a[n] (out of bounds). C++ does not check, so it silently corrupts memory.
• ✗Using sizeof(a)/sizeof(a[0]) inside a function. There, a is a pointer, so the trick gives the wrong size. Pass n instead.

Nodes on the heap, each pointing to the next. Insert at front, end or a position, delete by value, search and traverse, plus the dummy-node trick and the classic pitfalls.

• ✗Losing the list by updating head before linking the new node (head = n; first).
• ✗Dereferencing temp->next without checking temp != nullptr.
• ✗Forgetting the empty-list and delete-the-head special cases.

Each node points both forward and backward. You can walk in both directions and delete a node knowing only its address, at the cost of one extra pointer per node.

• ✗Updating next but forgetting prev (or the reverse). Each insert or delete touches both directions.
• ✗Forgetting cur->next->prev when cur->next is nullptr (deleting the tail) → crash.
• ✗Not updating tail when deleting the last node.

Last in, first out. The stack ADT (push, pop, peek, isEmpty, isFull) built on a fixed array with a top index, plus overflow and underflow.

• ✗Writing st[top++] = x with top = -1 (writes to index −1). Use st[++top] = x.
• ✗Popping without checking isEmpty() (underflow).
• ✗Pushing without checking isFull() (writes past the array).

The same stack ADT, but the top is the head of a linked list. No fixed capacity, push and pop stay O(1), and the bracket-matching application.

• ✗Using the tail as the top, making pop O(n).
• ✗Forgetting delete in pop (memory leak).
• ✗Reading top->data after deleting the node. Save the value first.

First in, first out. Why a naive array queue makes dequeue O(n), how a front index makes it O(1), and the wasted-slot problem that leads to the circular queue.

• ✗Confusing front and rear (items enter at the rear, leave at the front).
• ✗Dequeuing without checking for empty.
• ✗With a front index, testing rear == -1 for empty. The correct test is front > rear.

Keep two pointers, front and rear. Enqueue at the rear and dequeue at the front, both O(1), with no capacity limit.

• ✗Dequeuing from the tail (needs the previous node, so O(n)).
• ✗Forgetting rear = nullptr when the queue becomes empty. The next enqueue then writes through a dangling pointer.
• ✗Enqueue into an empty queue without setting both front and rear.

Let front and rear wrap around with the modulo operator, so freed slots are reused. All operations O(1) on a fixed array.

• ✗Writing rear++ instead of rear = (rear + 1) % N.
• ✗Testing front == rear for both empty and full. Without a count (or one spare slot) they look the same.
• ✗Printing from 0 to rear instead of starting at front and wrapping.

The standard library versions you will use in real code and on LeetCode, their method names, and the classic traps (pop returns void, empty checks).

• ✗Writing int x = s.pop();. It does not compile; pop() returns void. Read top() first.
• ✗Calling top() / front() / pop() on an empty container (undefined behaviour). Check empty().
• ✗Using q.top() on a queue (it is front()), or s.front() on a stack (it is top()).