Why Strings Are a Data Structure Not Just Text in DSA Typescript - Why This Pattern

Mental Model

A string is more than just letters; it is a sequence of characters stored in order, like a chain of boxes each holding one letter.

Analogy: Imagine a string as a row of mailboxes, each mailbox holding one letter. You can open each mailbox in order to read or change the letter inside.

S -> t -> r -> i -> n -> g -> null
↑

Dry Run Walkthrough

Input: string: "cat"

Goal: Show how the string is stored and accessed as a sequence of characters, not just a word.

Step 1: Store 'c' in the first box

[c] -> null
↑

Why: We start by placing the first character in the first position.

Step 2: Add 'a' in the next box linked after 'c'

[c] -> [a] -> null
↑

Why: Each character is stored in order, linked one after another.

Step 3: Add 't' in the next box linked after 'a'

[c] -> [a] -> [t] -> null
↑

Why: The string is a chain of characters linked in sequence.

Step 4: Access characters one by one from the first box

[c] -> [a] -> [t] -> null
↑

Why: To read or change the string, we move through each character in order.

Result:

[c] -> [a] -> [t] -> null
String stored as linked characters, not just text.

Annotated Code

DSA Typescript

class StringNode {
  char: string;
  next: StringNode | null;
  constructor(char: string) {
    this.char = char;
    this.next = null;
  }
}

class StringLinkedList {
  head: StringNode | null = null;

  constructor(str: string) {
    if (str.length === 0) return;
    this.head = new StringNode(str[0]);
    let current = this.head;
    for (let i = 1; i < str.length; i++) {
      current.next = new StringNode(str[i]);
      current = current.next;
    }
  }

  print(): void {
    let current = this.head;
    let result = '';
    while (current !== null) {
      result += current.char + ' -> ';
      current = current.next;
    }
    result += 'null';
    console.log(result);
  }
}

const myString = new StringLinkedList("cat");
myString.print();

this.head = new StringNode(str[0]);

Create the first node with the first character to start the chain

current.next = new StringNode(str[i]);

Link each new character node to the previous node to form the sequence

current = current.next;

Advance current pointer to the newly added node to continue linking

while (current !== null) { result += current.char + ' -> '; current = current.next; }

Traverse the linked characters to build the string representation

Output

c -> a -> t -> null

Complexity Analysis

Time: O(n) because we create and traverse each character node once for a string of length n

Space: O(n) because each character is stored in its own node, requiring space proportional to string length

vs Alternative: Compared to storing string as a simple array or built-in type, linked nodes allow easy insertion or deletion but use more memory and slower access

Edge Cases

empty string ""

No nodes are created; the head remains null

DSA Typescript

if (str.length === 0) return;

single character string "a"

Only one node is created with no next node

DSA Typescript

this.head = new StringNode(str[0]);

When to Use This Pattern

When you need to manipulate or traverse characters one by one, especially for insertion or deletion, think of strings as linked sequences rather than just text.

Common Mistakes

Mistake: Treating strings as a single block of text without understanding character-by-character structure
Fix: Visualize and implement strings as sequences of linked characters to enable stepwise operations

Summary

Strings are sequences of characters stored in order, like linked boxes holding letters.

Use this view when you want to access or change characters one by one or insert/delete characters efficiently.

The key insight is that strings behave like chains of linked nodes, not just plain text.

Practice

1. Why are strings considered a data structure and not just plain text?

easy

A. Because strings are only used for displaying text on the screen.

B. Because strings store characters in a specific order and allow operations like indexing and slicing.

C. Because strings cannot be changed once created.

D. Because strings are only sequences of numbers.

Solution

1. Step 1: Understand what a data structure is

   A data structure organizes data to allow efficient access and modification.

2. Step 2: Analyze string properties

   Strings store characters in order and support operations like indexing, slicing, and searching, which are typical data structure features.

3. Final Answer:

   Because strings store characters in a specific order and allow operations like indexing and slicing. -> Option B

4. Quick Check:

   Strings = Ordered character storage [OK]

Hint: Remember: strings hold ordered characters, not just text [OK]

Common Mistakes:

• Thinking strings are just text without structure
• Confusing immutability with data structure properties
• Assuming strings only display data

2. Which of the following is the correct way to access the third character of a string str in TypeScript?

easy

A. str.charAt(3)

B. str(3)

C. str[2]

D. str.get(2)

Solution

1. Step 1: Recall string indexing in TypeScript

   Strings use zero-based indexing, so the first character is at index 0.

2. Step 2: Identify correct syntax for accessing characters

   Using square brackets with index accesses the character at that position, so str[2] gets the third character.

3. Final Answer:

   str[2] -> Option C

4. Quick Check:

   Index 2 = third character [OK]

Hint: Use zero-based index with square brackets to access characters [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Using 1-based indexing
• Using non-existent methods like get()

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

const s = "hello";
console.log(s[1] + s[4]);

medium

A. "eo"

B. "he"

C. "hl"

D. "lo"

Solution

1. Step 1: Identify characters at given indices

   Index 1 of "hello" is 'e', index 4 is 'o'.

2. Step 2: Concatenate characters

   Concatenating 'e' + 'o' results in "eo".

3. Final Answer:

   "eo" -> Option A

4. Quick Check:

   s[1] + s[4] = "e" + "o" = "eo" [OK]

Hint: Remember string indices start at 0; add characters at given indices [OK]

Common Mistakes:

• Using 1-based indexing
• Mixing up indices and characters
• Assuming output is an array

4. Identify the error in this TypeScript code that tries to change the first character of a string:

let word = "hello";
word[0] = "H";
console.log(word);

medium

A. Strings are immutable; you cannot change characters by index.

B. The syntax for changing characters is incorrect; use parentheses instead of brackets.

C. You must declare the string as a constant to modify it.

D. The console.log statement is missing parentheses.

Solution

1. Step 1: Understand string immutability in TypeScript

   Strings cannot be changed after creation; individual characters cannot be assigned new values.

2. Step 2: Analyze the code behavior

   Trying to assign to word[0] does not change the string; no error but no effect.

3. Final Answer:

   Strings are immutable; you cannot change characters by index. -> Option A

4. Quick Check:

   Strings cannot be changed by index assignment [OK]

Hint: Remember strings are immutable; use new string to change content [OK]

Common Mistakes:

• Trying to assign characters directly by index
• Confusing arrays with strings
• Expecting console.log syntax error

5. Given the string str = "data", which TypeScript code correctly creates a new string with the first character capitalized, demonstrating string as a data structure?

hard

A. const newStr = str.replace(0, str[0].toUpperCase());

B. str[0] = str[0].toUpperCase(); const newStr = str;

C. const newStr = str.toUpperCase()[0] + str[1];

D. const newStr = str[0].toUpperCase() + str.slice(1);

Solution

1. Step 1: Understand string immutability and methods

   You cannot change characters by index, but you can create new strings using methods like toUpperCase() and slice().

2. Step 2: Analyze each option

   const newStr = str[0].toUpperCase() + str.slice(1); correctly creates a new string by capitalizing the first character and appending the rest. str[0] = str[0].toUpperCase(); const newStr = str; tries to assign to index (invalid). const newStr = str.toUpperCase()[0] + str[1]; only capitalizes first char but appends only one character. const newStr = str.replace(0, str[0].toUpperCase()); uses replace incorrectly (replace expects substring, not index).

3. Final Answer:

   const newStr = str[0].toUpperCase() + str.slice(1); -> Option D

4. Quick Check:

   Create new string with methods, not index assignment [OK]

Hint: Use string methods to build new strings; never assign by index [OK]

Common Mistakes:

• Trying to assign to string index
• Using replace with index instead of substring
• Not including full string after first char