Data Structures: Organizing Information Like a Pro

The Thali Pile and the Ticket Line

Picture your school canteen at lunch break. Behind the counter, the cook keeps a tall pile of steel thalis, one stacked directly on top of the other. When a new thali is washed, it goes on top of the pile. When a student needs one, they take it from the top too — nobody digs out a thali from the bottom, because the whole pile would topple. Now walk twenty metres to the ticket counter of a busy railway station, say Chennai Central or Howrah Junction. Here, the first person who joined the line is the first person served. Someone who arrives late has to stand at the back and wait their turn, no matter how much they protest.

Both scenes involve a collection of things — thalis, people — that need to be organized so that adding and removing items happens in a sensible, predictable order. But the rule for adding and removing is completely different in the two cases. The thali pile always gives you the most recently added item first. The ticket line always gives you the earliest-added item first. In computer science, these two rules are so common and so useful that they have names, precise definitions, and ready-made code you can use in almost any program: the stack and the queue. Alongside them sits an even more fundamental idea — the array, a simple row of labelled boxes that lets you jump straight to any item if you know its position, the way you'd jump straight to seat 14 in a train coach without checking seats 1 to 13 first.

This chapter is about all three: what they are, how to use them correctly in code, why a program that picks the wrong one runs painfully slowly or breaks, and how to tell them apart without hesitation — a skill examiners test constantly and that real software depends on every single day.

What Exactly Is a "Data Structure"?

Before going further, let's pin down the term precisely, because students often use it loosely. A data structure is a specific way of organizing and storing data in a computer's memory so that certain operations on that data — adding an item, removing an item, finding an item, going through every item in order — can be done efficiently and predictably. The word "efficiently" matters: the exact same set of numbers can be stored in memory in ten different arrangements, and depending on the arrangement, finding a particular number might take one step or might take a thousand steps. Choosing the right data structure is choosing the right arrangement for the job you actually need to do.

There isn't just one "correct" data structure for every situation — that is the whole point of studying more than one. In this chapter we build up three of the most fundamental ones from scratch, always starting with a real situation before writing a single line of code.

The Array — A Row of Labelled Boxes

Suppose your class teacher records the marks of five students in a unit test, in roll-number order: 78, 65, 91, 54, and 88. The most natural way to store these five numbers together is as an array: a fixed sequence of boxes sitting right next to each other in memory, each box holding one value, and each box labelled with a number called its index.

Here is the detail that trips up almost every beginner, so let's state it as clearly as possible.

Common Misconception: Many students assume the first item in an array is at "index 1," because that is how we count in ordinary life — first, second, third. In Python, C, C++, Java, and almost every mainstream programming language, indexing starts at 0. The first box is index 0, the second is index 1, and so on, so an array with 5 elements has valid indices 0, 1, 2, 3, and 4 — never 5. Forgetting this causes one of the most common bugs in all of programming, called an "off-by-one error."

Here is the marks array in Python, with each step of what happens traced out:

marks = [78, 65, 91, 54, 88]

print(marks[0])   # first element  -> 78
print(marks[2])   # third element  -> 91

marks[3] = 70      # overwrite the value at index 3 (was 54)
print(marks)       # [78, 65, 91, 70, 88]

Trace it with me. marks[0] reaches into the box labelled 0 and pulls out 78 — the mark of the first student, not the second. marks[2] reaches into the box labelled 2, which is the third box counting from zero, and pulls out 91. The line marks[3] = 70 does not add a new box; it replaces whatever was sitting in the box labelled 3 (which was 54, the fourth student's original mark) with 70. Printing the array afterward confirms only that one position changed.

Why is reaching into marks[2] so fast, regardless of whether the array has 5 elements or 5 million? Because the boxes are stored right next to each other in memory, back to back, with no gaps. If you know the memory address where the array begins (the "base address") and you know how many bytes each element takes up, you can calculate the exact address of any index with a single multiplication and addition — no searching required. In a language like C, where an integer typically takes 4 bytes, if the array's base address is 2000, the address of index i is:

address(i) = base_address + i × size_of_one_element
address(3) = 2000 + 3 × 4 = 2012

The diagram below shows this laid out: five boxes, their indices, their values, and the memory address each one lives at, incrementing by 4 bytes every step.

Because that address is calculated directly rather than found by checking boxes one by one, reading or writing any single element of an array takes the same tiny amount of work no matter how large the array is or which index you ask for. This is the single biggest reason arrays are useful: direct, instant access by position.

One more precise distinction worth making, because CBSE-level clarity matters here: a true array, as it exists in memory in a language like C, has a fixed size decided the moment it is created. If you declared an array for 5 marks, you cannot silently make room for a sixth without creating a brand-new, larger array and copying everything over. Python's built-in list, which we used above, is actually a more flexible cousin called a dynamic array — it manages that resizing for you behind the scenes when you call methods like append(). It behaves like an array for indexed access (same instant-lookup property), but it is not restricted to a fixed size the way a raw array is. Keeping this distinction in mind will save you from confusing "array" (the concept) with "Python list" (one specific, extended implementation of that concept) in exams.

The Price of Not Knowing the Index: Linear Search

Instant access only works when you already know the index. What if you don't — what if you're asked, "does roll number 56 appear in this list, and if so, where?" Then the computer has no shortcut: it must check boxes one at a time, starting from index 0, until it finds a match or runs out of boxes. This method is called linear search, and it is worth tracing carefully because it shows why the arrangement of data affects speed, not just storage.

def find_roll_number(roll_list, target):
    steps = 0
    for i in range(len(roll_list)):
        steps += 1
        if roll_list[i] == target:
            return i, steps
    return -1, steps

roll_list = [12, 45, 7, 23, 56, 34, 19, 8]
index, steps = find_roll_number(roll_list, 56)
print(index, steps)

Trace it step by step. i = 0: steps becomes 1, check roll_list[0] = 12, not 56, continue. i = 1: steps becomes 2, check 45, no match. i = 2: steps becomes 3, check 7, no match. i = 3: steps becomes 4, check 23, no match. i = 4: steps becomes 5, check roll_list[4] = 56 — match! The function returns immediately with (4, 5). So the output printed is 4 5: the target was found at index 4, and it took 5 comparisons to get there.

Now imagine the roll number you were searching for was 8, sitting at the very last index, 7. The function would need all 8 comparisons before finding it. And if you searched for a roll number that doesn't exist at all, like 99, it would still make all 8 comparisons before concluding "not found," returning -1. In general, for a list of n items, linear search takes at most n steps in the worst case. Computer scientists have a compact shorthand for "grows in proportion to n" — they write it as O(n), read as "order n." You will meet this notation more formally in later chapters; for now, the important habit is simply to count actual steps for a concrete example first, the way we just did, before trusting any shorthand.

This is precisely why data structures matter: an array gives you instant access if you know the position, but finding an unknown position by value still costs real, countable work.

The Stack — Last In, First Out

Return to the canteen's thali pile. The rule was simple: whatever went on top most recently comes off first. This behaviour is called Last In, First Out, abbreviated LIFO, and a data structure built around this exact rule is called a stack. A stack supports two core operations, and by convention they're named after the physical action: push, which places a new item on top, and pop, which removes and returns the item currently on top. Nothing else is directly reachable — you cannot pull an item from the middle or bottom of a stack without first popping everything above it.

In Python, an ordinary list already behaves exactly like a stack if you restrict yourself to its append() and pop() methods, because both operate on the end of the list — which we'll treat as the "top."

stack = []
stack.append("Maths")
stack.append("Science")
stack.append("Hindi")
print(stack)          # ['Maths', 'Science', 'Hindi']

top = stack.pop()
print(top)             # 'Hindi'
print(stack)           # ['Maths', 'Science']

Trace it: three subjects are pushed in the order Maths, Science, Hindi, so Hindi ends up sitting on top — last in. Printing the stack shows all three in that order, with Hindi at the rightmost (top) position. Calling stack.pop() removes and returns whatever is currently on top, which is Hindi — first out, exactly matching LIFO. The variable top now holds 'Hindi', and the stack that remains has only Maths and Science, in that original order, because nothing beneath the top was ever touched.

Stacks are everywhere once you know to look. The "Undo" feature in a word processor keeps a stack of your recent edits and undoes the most recent one first. A web browser's "Back" button keeps a stack of pages you've visited; pressing Back pops the most recently visited page off the top, taking you to the one before it — not to the very first page you ever opened in that tab. In both cases, "most recent action first" is the defining behaviour, which should immediately signal "stack" to you.

The Queue — First In, First Out

Now return to the railway ticket counter. The rule there was the opposite: whoever joined first is served first, and everyone else waits their turn strictly in arrival order. This is called First In, First Out, abbreviated FIFO, and the data structure built around it is a queue. Its two core operations are enqueue (join the back of the line) and dequeue (leave from the front of the line).

Here is an important, often-skipped detail. You might expect Python's plain list to serve as a queue too, just by adding to the end and removing from the front with pop(0). It technically works, but it is a poor choice: a Python list stores its elements contiguously in memory, so removing the very first element means every remaining element has to shift one position to the left to close the gap — work proportional to the length of the list, every single time someone is dequeued. For a busy queue, that adds up fast. Python's standard library provides a purpose-built structure for exactly this situation, called deque (pronounced "deck," short for double-ended queue), which can add or remove from either end without shifting anything else.

from collections import deque

ticket_queue = deque()
ticket_queue.append("Aisha")
ticket_queue.append("Rohan")
ticket_queue.append("Meera")
print(ticket_queue)          # deque(['Aisha', 'Rohan', 'Meera'])

first_served = ticket_queue.popleft()
print(first_served)          # 'Aisha'
print(ticket_queue)          # deque(['Rohan', 'Meera'])

Trace it: Aisha joins first, then Rohan, then Meera, so the queue holds them in arrival order with Aisha at the front. Calling popleft() removes and returns whichever element is at the front, not the end — that's Aisha, matching FIFO exactly, since she arrived first. The queue that remains holds Rohan and Meera, still in their original order, with Rohan now at the front waiting to be served next.

Common Misconception: Students frequently mix up which end of a stack or queue is "active." Remember it through the physical analogies you already understand: a stack only ever touches its top (both push and pop happen there); a queue always adds at the rear and removes from the front — two different ends, never the same one. If a question describes "removing the item that was added most recently," that is a stack. If it describes "removing the item that has been waiting longest," that is a queue. Reading the scenario for which end is touched, and how many ends are involved, resolves the confusion every time.

The diagram below places both structures side by side using the exact examples just traced, so you can see the shape of the rule, not just its name.

Choosing the Right Structure for the Job

With all three structures traced in code, the choice between them stops being a matter of memorizing definitions and becomes a matter of asking the right question about your data: "Do I need to jump straight to a known position? Do I always deal with the most recent item first? Or do I always deal with the oldest waiting item first?"

• Array — use it when items are naturally identified by position and you'll often need to jump directly to a specific one, such as looking up "the mark of the student in seat 14" or storing "runs scored in each of the 20 overs of a T20 innings," where over number 7 is always accessed as index 6.
• Stack — use it when the most recently added item must always be handled first, such as an editor's undo history, a browser's back-button history, or checking whether brackets in an expression like ((3+2)*5) are correctly matched (a classic use you'll encounter again when studying expression evaluation).
• Queue — use it when items must be handled strictly in the order they arrived, such as a printer processing print jobs in the order they were sent, or a ticket counter serving customers in arrival order.

Picking the wrong one doesn't just look inelegant — it can silently produce the wrong result. If a support ticket system used a stack instead of a queue, the very first customer to complain would be served last, after everyone who complained after them, because each new complaint would keep landing "on top." The customer would rightly be furious, and the bug would trace directly back to a data-structure choice, not to any single line of buggy logic.

Test Yourself

Work through these without running code first, then check your reasoning against the explanation.

1. An array subjects = ["Hindi", "English", "Maths", "Science", "SST"] is given. What does subjects[1] evaluate to, and what index would you use to get "SST"?
   Answer: subjects[1] is "English" (the second box, index 1). "SST" sits at index 4, the fifth box, since indexing starts at 0.
2. A stack starts empty. The operations push(5), push(9), push(2), pop(), push(7) are performed in that order. List the final contents of the stack from bottom to top, and state what the pop() call returned.
   Answer: After the three pushes, the stack (bottom to top) is 5, 9, 2. The pop() removes and returns the top item, 2. Then push(7) adds 7 on top. Final stack, bottom to top: 5, 9, 7. The popped value was 2.
3. A dosa stall at a college fest takes orders one at a time and serves them in the exact order they were placed. Priya's order is placed first, then Karan's, then Zoya's. Whose dosa is served first, which structure from this chapter matches, and why would using a stack instead be unfair to Priya?
   Answer: Priya's dosa is served first — this is a queue (FIFO). A stack would serve the most recently placed order first, meaning Zoya's dosa would come out first and Priya, despite ordering first, would wait longest.
4. Using the linear search function traced earlier, how many comparison steps would find_roll_number(roll_list, 8) take on roll_list = [12, 45, 7, 23, 56, 34, 19, 8], and what index would it return?
   Answer: 8 is the last element, at index 7, so the loop must check all 8 positions before finding it. It returns (7, 8): found at index 7, after 8 comparison steps.
5. A quiz app needs to instantly jump to "question number 7 out of 20" whenever the student clicks a specific question number on a review screen. Which structure from this chapter fits best, and why would a stack or queue be a poor choice here?
   Answer: An array fits best — question 7 is simply index 6, reached directly with no searching. A stack or queue only exposes one end (top, or front/rear); jumping to an arbitrary middle question would require removing everything above or before it first, which is not how a review screen should behave.

Summary

A data structure is a deliberate way of arranging data in memory so that the operations you actually need — access, insertion, removal, search — are efficient for your situation, not just "somehow stored." An array is a fixed-position row of boxes, indexed from 0, that gives instant O(1) access when you already know the position, because the address of any index can be calculated directly rather than searched for; Python's list extends this idea into a resizable "dynamic array." When the position is unknown, linear search checks boxes one at a time, costing up to n steps for n items. A stack enforces Last In, First Out through push and pop at a single "top" end, matching situations like undo history or a canteen thali pile. A queue enforces First In, First Out through enqueue at the rear and dequeue at the front, matching situations like a ticket counter line, and is best implemented in Python with collections.deque rather than a plain list, since removing from the front of a list forces every remaining element to shift. Recognizing which rule a real situation obeys — instant lookup by position, most-recent-first, or oldest-first — is the actual skill being tested, in exams and in real programs alike; the code is simply the precise way of expressing that recognition.

Practice Exercises

Now it is time to practice! Complete these challenges to solidify your understanding:

• Exercise 1: Write a short program that demonstrates the core concept from this chapter. Test it with at least 3 different inputs.
• Exercise 2: Find a real-world example where data structures: organizing information like a pro is used in an Indian company (like TCS, Infosys, Flipkart, or ISRO). Write a paragraph explaining the connection.
• Exercise 3: Create a mind-map connecting data structures: organizing information like a pro to at least 3 other topics you have studied.