String Basics and Memory Representation in DSA Python

Mental Model

A string is a sequence of characters stored one after another in memory, like beads on a string.

Analogy: Imagine a necklace where each bead is a letter. The beads are lined up in order, and you can look at each bead one by one to read the message.

Index:  0   1   2   3   4
String: H -> e -> l -> l -> o -> null
Memory: [H][e][l][l][o]

Dry Run Walkthrough

Input: string: "Hello"

Goal: Understand how each character is stored in memory and accessed by index

Step 1: Store 'H' at index 0

[H] -> null

Why: First character must be stored at the start

Step 2: Store 'e' at index 1

[H] -> [e] -> null

Why: Next character stored right after the first

Step 3: Store 'l' at index 2

[H] -> [e] -> [l] -> null

Why: Continue storing characters in order

Step 4: Store 'l' at index 3

[H] -> [e] -> [l] -> [l] -> null

Why: Store repeated character at next position

Step 5: Store 'o' at index 4

[H] -> [e] -> [l] -> [l] -> [o] -> null

Why: Store last character to complete the string

Result:

[H] -> [e] -> [l] -> [l] -> [o] -> null
String length = 5

Annotated Code

DSA Python

class StringMemory:
    def __init__(self, content):
        self.chars = list(content)  # store characters in list to simulate memory

    def __str__(self):
        # Show characters linked by arrows ending with null
        return ' -> '.join(f'[{c}]' for c in self.chars) + ' -> null'

    def length(self):
        return len(self.chars)

# Driver code
s = StringMemory("Hello")
print(s)
print(f"String length = {s.length()}")

self.chars = list(content) # store characters in list to simulate memory

store each character in order to simulate contiguous memory

return ' -> '.join(f'[{c}]' for c in self.chars) + ' -> null'

visualize string as linked characters ending with null

return len(self.chars)

calculate string length by counting stored characters

Output

[H] -> [e] -> [l] -> [l] -> [o] -> null

String length = 5

Complexity Analysis

Time: O(n) because storing or printing the string requires touching each character once

Space: O(n) because each character is stored separately in memory

vs Alternative: Compared to storing characters separately in scattered memory, contiguous storage allows fast access by index

Edge Cases

empty string ""

stores no characters, length is zero

DSA Python

self.chars = list(content)  # store characters in list to simulate memory

string with one character "A"

stores single character at index 0, length is one

DSA Python

self.chars = list(content)  # store characters in list to simulate memory

When to Use This Pattern

When you see problems about accessing or manipulating characters by position, think of strings as arrays of characters stored in order.

Common Mistakes

Mistake: Thinking strings are stored as single units without individual characters in memory
Fix: Remember strings are sequences of characters stored one after another, allowing access by index

Mistake: Confusing string length with memory size or capacity
Fix: Length counts actual characters stored, not memory reserved

Summary

A string is a sequence of characters stored one after another in memory.

Use this when you need to access or manipulate characters by their position.

The key insight is that each character occupies a spot in order, like beads on a string.