String Basics and Memory Representation in DSA C

Mental Model

A string is a sequence of characters stored one after another in memory, ending with a special marker to show where it stops.

Analogy: Think of a string like a train of connected boxes, each holding one letter, with a special box at the end that says 'this is the last one'.

S -> [H] -> [E] -> [L] -> [L] -> [O] -> [\0]
↑start pointer

Dry Run Walkthrough

Input: string: "HELLO" stored in memory

Goal: Understand how each character is stored in order and how the string ends

Step 1: Store 'H' at first memory location

S -> [H] -> [] -> [] -> [] -> [] -> []
↑start pointer

Why: First character must be stored at the start

Step 2: Store 'E' at next memory location

S -> [H] -> [E] -> [] -> [] -> [] -> []
↑start pointer

Why: Characters are stored one after another

Step 3: Store 'L' at next memory location

S -> [H] -> [E] -> [L] -> [] -> [] -> []
↑start pointer

Why: Continue storing characters in order

Step 4: Store second 'L' at next memory location

S -> [H] -> [E] -> [L] -> [L] -> [] -> []
↑start pointer

Why: Store repeated characters as normal

Step 5: Store 'O' at next memory location

S -> [H] -> [E] -> [L] -> [L] -> [O] -> []
↑start pointer

Why: Store last character before end marker

Step 6: Store '\0' (null character) to mark end

S -> [H] -> [E] -> [L] -> [L] -> [O] -> [\0]
↑start pointer

Why: Null character shows where string ends in memory

Result:

S -> [H] -> [E] -> [L] -> [L] -> [O] -> [\0]
String ends with null character to mark termination

Annotated Code

DSA C

#include <stdio.h>

int main() {
    char str[] = "HELLO"; // string stored with null terminator

    // Print each character and its memory index
    for (int i = 0; str[i] != '\0'; i++) {
        printf("Index %d: %c\n", i, str[i]);
    }

    // Print the null terminator explicitly
    printf("Index %d: %d (null terminator)\n", 5, str[5]);

    return 0;
}

for (int i = 0; str[i] != '\0'; i++) {

Traverse characters until null terminator to print each character

printf("Index %d: %c\n", i, str[i]);

Print character at current index

printf("Index %d: %d (null terminator)\n", 5, str[5]);

Print the null terminator value explicitly to show string end

Output

Index 0: H

Index 1: E

Index 2: L

Index 3: L

Index 4: O

Index 5: 0 (null terminator)

Complexity Analysis

Time: O(n) because we visit each character once to print

Space: O(n) because the string uses memory proportional to its length plus one for the null terminator

vs Alternative: Compared to storing characters without a null terminator, this method allows easy detection of string end but requires extra space for the terminator

Edge Cases

Empty string ""

Only the null terminator is stored at the first position, indicating no characters

DSA C

for (int i = 0; str[i] != '\0'; i++) {

String with one character "A"

Character 'A' stored at index 0, null terminator at index 1

DSA C

for (int i = 0; str[i] != '\0'; i++) {

When to Use This Pattern

When you see problems about storing or manipulating text in low-level languages, think about strings as arrays of characters ending with a null marker to know where they stop.

Common Mistakes

Mistake: Forgetting the null terminator at the end of the string
Fix: Always ensure strings end with '\0' so functions know where the string ends

Summary

A string is a sequence of characters stored in memory ending with a null character to mark its end.

Use this when you need to store and process text in languages like C that do not store string length separately.

The key insight is the null terminator '\0' which tells the program where the string stops.

Practice

1. Which of the following correctly describes how strings are stored in C?

easy

A. As an array of characters ending with a null character '\0'.

B. As a linked list of characters.

C. As a single integer representing the string length.

D. As a floating-point number encoding characters.

Solution

1. Step 1: Understand C string storage

   In C, strings are stored as arrays of characters with a special null character '\0' marking the end.

2. Step 2: Compare options with this knowledge

   Only As an array of characters ending with a null character '\0'. correctly states this; others describe different data structures or types.

3. Final Answer:

   As an array of characters ending with a null character '\0'. -> Option A

4. Quick Check:

   C strings end with '\0' = A [OK]

Hint: Remember C strings always end with '\0' to mark their end [OK]

Common Mistakes:

• Thinking strings are linked lists in C
• Assuming strings store length explicitly
• Confusing string storage with other data types

2. Which of the following is the correct way to declare and initialize a string literal in C?

easy

A. char str = "hello";

B. char str[5] = 'hello';

C. char str[] = "hello";

D. char str[] = {'h','e','l','l','o'};

Solution

1. Step 1: Check string declaration syntax

   In C, to store a string literal, use an array of chars with double quotes and square brackets.

2. Step 2: Evaluate each option

   A uses char (single char) with double quotes (wrong). B uses single quotes for multiple chars (wrong). D misses null terminator '\0'. C correctly declares and initializes with null terminator.

3. Final Answer:

   char str[] = "hello"; -> Option C

4. Quick Check:

   Use char array with double quotes = C [OK]

Hint: Use char array with double quotes for string literals [OK]

Common Mistakes:

• Using single quotes for strings
• Not including null terminator
• Declaring char variable instead of array

3. What will be the output of the following C code?

char str[] = "abc";
printf("%c", str[3]);

medium

A. c

B. \0 (null character, prints nothing visible)

C. a

D. Runtime error

Solution

1. Step 1: Understand string indexing and null terminator

   The string "abc" is stored as {'a','b','c','\0'}. Index 3 is the null character '\0'.

2. Step 2: Determine printf output for str[3]

   Printing '%c' with '\0' prints nothing visible (null character), no error occurs.

3. Final Answer:

   \0 (null character, prints nothing visible) -> Option B

4. Quick Check:

   Index 3 is '\0' = A [OK]

Hint: Remember string ends with '\0' at last index + 1 [OK]

Common Mistakes:

• Assuming str[3] is 'a' or 'c'
• Expecting runtime error for accessing null char
• Confusing null char with printable character

4. Identify the error in the following C code snippet:

char str[5] = "hello";
str[5] = '!';

medium

A. Array index out of bounds when assigning str[5].

B. Incorrect use of single quotes for string.

C. Missing null terminator in string initialization.

D. No error, code runs fine.

Solution

1. Step 1: Analyze array size and indexing

   Array str has size 5, valid indices are 0 to 4. Accessing str[5] is out of bounds.

2. Step 2: Check string initialization and assignment

   "hello" fits exactly 5 chars including '\0'? No, 'hello' needs 6 chars including '\0'. But main error is str[5] assignment which is invalid index.

3. Final Answer:

   Array index out of bounds when assigning str[5]. -> Option A

4. Quick Check:

   Index 5 invalid for size 5 array = D [OK]

Hint: Array indices go from 0 to size-1 only [OK]

Common Mistakes:

• Ignoring out of bounds access
• Confusing array size with string length
• Thinking str[5] is valid index

5. Given the code below, what will be the output?

char str1[] = "abc";
char *str2 = str1;
str2[1] = 'z';
printf("%s", str1);

hard

A. abc

B. Runtime error

C. a\0c

D. azc

Solution

1. Step 1: Understand pointer and array relation

   str2 points to str1 array. Changing str2[1] changes str1[1].

2. Step 2: Apply the character change and print

   str2[1] = 'z' changes 'b' to 'z'. Printing str1 shows "azc".

3. Final Answer:

   azc -> Option D

4. Quick Check:

   Pointer modifies original array = B [OK]

Hint: Pointer to array modifies original string content [OK]

Common Mistakes:

• Thinking str1 remains unchanged
• Expecting null character insertion
• Assuming runtime error due to pointer