A Data Structures Test Without Revision

Day 51 was another busy day in my GATE CSE 2027 preparation, and it turned into something I didn't initially expect: a fairly detailed reality check about my Data Structures recall.

I studied Discrete Mathematics, started Group Theory, completed pending Compiler Design notes, and gave my first Data Structures topic-wise test of November.

The interesting part was that I gave the DS test without revising Data Structures beforehand.

That decision made the result much more useful than the score alone.

Revising POSET and Starting Group Theory

I revised Partial Order Sets, which follow the three properties I remember as RAT:

• Reflexive
• Antisymmetric
• Transitive

I had planned to study Lattice as well, but the lecture wasn't downloaded, so I skipped it for the time being instead of sitting around waiting for technology to discover its purpose in life.

I then started Group Theory Lecture 1.

There are three Group Theory lectures, each approximately four hours long, so this is not exactly a tiny little chapter to casually finish between snacks.

I completed around two hours of the first lecture and studied:

• Binary operations
• Closure property
• Commutativity
• Associativity
• Identity element
• Inverse element

One important point I understood was that an inverse is connected to the existence of an identity element. Also, if an identity element exists in a set, it is unique.

I still have a lot of Group Theory remaining, but at least the chapter has officially begun.

Data Structures Topic Test 1

The biggest part of the day was the GO Classes Data Structures Topic Wise Test 1, focused on linked lists.

My result was:

At first glance, 60% is only a small improvement over yesterday's C Programming test.

But the two tests exposed different things.

The most important context for this test is that I had not revised Data Structures before attempting it.

And that showed up everywhere.

The Problem Wasn't Always Understanding

Several questions were labelled easy, but they didn't feel easy when I was sitting in a timed test without recent revision.

For example, there were questions I knew how to solve, but I kept checking my reasoning because I wasn't confident enough.

In one question, I knew the pointer traversal logic but still spent extra time verifying it.

In another, I tried to mentally trace pointer modifications before finally using pen and paper. That wasted around a minute before I switched to the better method.

The lesson was pretty obvious:

For complicated pointer manipulation, using rough paper immediately is often faster than trying to prove that my brain has unlimited RAM.

It does not.

A Genuine Conceptual Mistake

One of my genuine mistakes involved insertion in a circular doubly linked list.

I forgot an important structural advantage:

head->prev

directly gives access to the last node.

I initially thought I would need to traverse through the list to reach the last node, making the operation O(N).

But because the list is circular and doubly linked, the last node is already directly accessible through head->prev.

So the insertion can be performed in O(1) time.

This was a genuine revision gap rather than a difficult new concept.

When I Assumed a Pointer Was Moving

Another silly mistake came from a linked-list printing program.

I mentally treated the code as if the pointer was traversing the list.

But the pointer was never actually updated.

A condition involving:

ptr->next

doesn't automatically mean:

ptr = ptr->next;

The current pointer remained at the same node, resulting in an infinite loop.

This was a good reminder to read the actual code rather than mentally adding operations that aren't there.

The Questions I Skipped

One question involved mutual recursion.

I skipped it after looking at it for only around 24 seconds because I saw recursive functions and immediately assumed it would take too much time.

Later, while analysing the test, I realised it was actually fairly straightforward once I understood what the functions were checking.

That was a useful lesson about question perception.

Sometimes I am rejecting a question before actually giving it a chance.

Another skipped question was labelled hard, but when I looked at it later, the main idea involving Node *head versus Node **head_ref was quite straightforward.

I simply didn't have enough time left in the test to properly analyse it.

Correct Doesn't Always Mean Independently Solved

This was another important theme from today's analysis.

One question was correct because I remembered seeing the same MCQ and its solution during the lecture.

Another question was eventually marked correctly after I got stuck for around five minutes and used ChatGPT to understand the final Boolean evaluation.

So while the final score says 10 correct, not every correct answer represents the same level of independent understanding.

That matters.

A correct answer obtained through:

• independent reasoning,
• remembering a previously seen question,
• guessing,
• or external confirmation

should not all be treated as identical evidence of preparation.

The score is useful, but the story behind the score is more useful.

The Longest Questions

Some correct answers also consumed a huge amount of time.

One question took me over six minutes because I didn't immediately recognise that the given code was simply reversing a doubly linked list.

I knew the standard reversal algorithm for a singly linked list, but not this version.

So I traced the entire code until I understood what it was doing, and then verified it again.

Another recursive linked-list question took over seven minutes because I got myself stuck while tracing the recursive calls.

The recurring pattern was clear:

When I cannot immediately recognise a pattern, I start tracing everything.

Tracing is not wrong. In fact, it is often necessary.

But I need to become better at recognising standard patterns through revision so that every familiar algorithm doesn't turn into a five-minute forensic investigation.

Completing My Pending Compiler Design Work

Instead of doing the planned TOC warm-up, I used part of the day to complete something that had been postponed.

I finished my Syntax-Directed Translation notes and solved a few related questions.

The main difficulty I faced was evaluating SDT for an ambiguous CFG.

This is an area where I need more practice because constructing and evaluating the appropriate parse tree becomes less straightforward when multiple derivations are possible.

Still, completing the pending notes was important.

Finishing lectures is not enough if the notes remain unfinished forever. Eventually, the backlog starts looking like a museum collection.

What Day 51 Actually Taught Me

The 60% score was useful, but today's analysis showed something deeper.

I don't appear to have forgotten everything in Data Structures.

Instead, many concepts are still present but suffer from:

• slow retrieval,
• lack of confidence,
• poor pattern recognition,
• and inefficient tracing under time pressure.

At the same time, there were genuine conceptual gaps that revision needs to fix.

So the next phase of my GATE preparation is becoming clearer.

It isn't just:

Study more topics.

It is increasingly becoming:

Retrieve faster, recognise patterns faster, and solve independently under exam conditions.

And that is exactly what these topic tests are supposed to expose.