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

Mental Model

A string is not just letters but a chain of connected characters stored in order. We can think of it as a special list that holds letters one by one.

Analogy: Imagine a string of beads where each bead is a letter. You can count beads, add new beads, or remove some. The beads are linked in a line, so you know the order.

H -> e -> l -> l -> o -> null
↑
start

Dry Run Walkthrough

Input: string: "Hi"

Goal: Show that a string is a sequence of characters connected in order, not just a block of text

Step 1: Start with first character 'H'

H -> null
↑
start

Why: We begin at the first character to know where the string starts

Step 2: Add next character 'i' linked after 'H'

H -> i -> null
↑
start

Why: Each character connects to the next, forming a chain

Step 3: Recognize end of string at null after 'i'

H -> i -> null
↑
start

Why: The null shows the string ends here, no more characters

Result:

H -> i -> null
This shows the string is a linked sequence of characters, not just text.

Annotated Code

DSA Go

package main

import "fmt"

// Node represents a character in the string linked list
type Node struct {
	char rune
	next *Node
}

// StringList holds the start of the string
 type StringList struct {
	head *Node
}

// Append adds a character to the end of the string list
func (s *StringList) Append(c rune) {
	newNode := &Node{char: c, next: nil}
	if s.head == nil {
		s.head = newNode
		return
	}
	curr := s.head
	for curr.next != nil {
		curr = curr.next
	}
	curr.next = newNode
}

// Print shows the string as characters connected by arrows
func (s *StringList) Print() {
	curr := s.head
	for curr != nil {
		fmt.Printf("%c", curr.char)
		if curr.next != nil {
			fmt.Print(" -> ")
		}
		curr = curr.next
	}
	fmt.Println(" -> null")
}

func main() {
	str := StringList{}
	str.Append('H')
	str.Append('i')
	str.Print()
}

if s.head == nil { s.head = newNode return }

set first character as head if list is empty

for curr.next != nil { curr = curr.next }

move to last character node to append new character

curr.next = newNode

link new character at the end of the string

for curr != nil { fmt.Printf("%c", curr.char) if curr.next != nil { fmt.Print(" -> ") } curr = curr.next }

traverse and print characters connected by arrows

Output

H -> i -> null

Complexity Analysis

Time: O(n) because appending requires traversing all n characters to reach the end

Space: O(n) because each character uses a node storing the character and a pointer

vs Alternative: Compared to a simple text block, this linked structure allows easy insertion or deletion at any point without shifting all characters

Edge Cases

empty string

no nodes created, print shows only ' -> null'

DSA Go

if s.head == nil {
	s.head = newNode
	return
}

single character string

one node with character, next is null

DSA Go

if s.head == nil {
	s.head = newNode
	return
}

When to Use This Pattern

When you see problems about manipulating text character by character, think of strings as linked sequences to allow easy insertions and deletions.

Common Mistakes

Mistake: Treating strings as just text blocks and trying to insert characters by shifting all others manually
Fix: Use a linked structure to connect characters so insertions only change pointers, not all characters

Summary

Strings are sequences of characters connected like a chain, not just plain text.

Use this view when you need to change strings by adding or removing characters efficiently.

The key insight is that each character links to the next, making strings a data structure.

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 screen

B. Because strings only contain letters and no other characters

C. Because strings are always immutable and cannot be changed

D. Because strings store characters in a specific order and allow access by position

Solution

1. Step 1: Understand what a data structure is

   A data structure organizes data so it can be accessed and modified efficiently. Strings store characters in order, which fits this definition.

2. Step 2: Analyze string properties

   Strings allow access to each character by its position (index), showing they have structure beyond plain text.

3. Final Answer:

   Because strings store characters in a specific order and allow access by position -> Option D

4. Quick Check:

   Strings = ordered characters [OK]

Hint: Strings have order and indexing, so they are data structures [OK]

Common Mistakes:

• Thinking strings only contain letters
• Assuming strings are just for display
• Believing strings cannot be changed

2. Which of the following is the correct way to get the length of a string s in Go?

easy

A. size(s)

B. length(s)

C. len(s)

D. s.length()

Solution

1. Step 1: Recall Go syntax for string length

   In Go, the built-in function len() returns the length of strings and slices.

2. Step 2: Check other options

   Functions like length(), s.length(), and size() are not valid in Go for strings.

3. Final Answer:

   len(s) -> Option C

4. Quick Check:

   Use len() for string length in Go [OK]

Hint: Use len() to get string length in Go [OK]

Common Mistakes:

• Using s.length() like in other languages
• Trying length() function which doesn't exist in Go
• Using size() which is invalid for strings

3. What will be the output of this Go code?

package main
import "fmt"
func main() {
  s := "hello"
  fmt.Println(string(s[1]))
}

medium

A. e

B. 104

C. h

D. Error

Solution

1. Step 1: Understand string indexing in Go

   Indexing a string like s[1] returns a byte (uint8) representing the ASCII code of the character.

2. Step 2: Analyze the code output

   string(s[1]) converts the byte to a string of length 1, so it prints 'e'.

3. Final Answer:

   e -> Option A

4. Quick Check:

   string(s[1]) = 'e' [OK]

Hint: s[index] is byte; string(s[index]) converts to char [OK]

Common Mistakes:

• Thinking s[1] prints ASCII number
• Expecting error due to indexing
• Confusing byte and string conversion

4. Identify the error in this Go code snippet:

package main
import "fmt"
func main() {
  s := "world"
  s[0] = 'W'
  fmt.Println(s)
}

medium

A. Strings are immutable; cannot assign to s[0]

B. Missing import for fmt package

C. Incorrect syntax for printing string

D. No error; code runs fine

Solution

1. Step 1: Understand string mutability in Go

   Strings in Go are immutable, meaning you cannot change characters by assigning to an index.

2. Step 2: Analyze the code error

   The line s[0] = 'W' tries to modify the first character, which causes a compile-time error.

3. Final Answer:

   Strings are immutable; cannot assign to s[0] -> Option A

4. Quick Check:

   Strings immutable = no s[index] assignment [OK]

Hint: Strings cannot be changed by index assignment [OK]

Common Mistakes:

• Trying to modify string characters directly
• Ignoring immutability of strings
• Assuming code runs without error

5. Given the string s := "GoLang", which code snippet correctly reverses the string and prints it in Go?

hard

A. s = s[::-1]; fmt.Println(s)

B. for i := len(s)-1; i >= 0; i-- { fmt.Print(string(s[i])) }

C. fmt.Println(reverse(s)) // reverse is built-in

D. for i := 0; i < len(s); i++ { fmt.Print(s[len(s)-i]) }

Solution

1. Step 1: Check each option for correctness

   for i := len(s)-1; i >= 0; i-- { fmt.Print(string(s[i])) } uses a for loop from the last index to zero, printing each character converted from byte to string. This correctly reverses the string.

2. Step 2: Analyze other options

   fmt.Println(reverse(s)) // reverse is built-in is invalid because Go has no built-in reverse function. s = s[::-1]; fmt.Println(s) uses Python slice syntax, invalid in Go. for i := 0; i < len(s); i++ { fmt.Print(s[len(s)-i]) } has an off-by-one error accessing s[len(s)-i], which causes runtime error.

3. Final Answer:

   for i := len(s)-1; i >= 0; i-- { fmt.Print(string(s[i])) } -> Option B

4. Quick Check:

   Reverse string with backward loop [OK]

Hint: Loop backward from len(s)-1 to 0 to reverse string [OK]

Common Mistakes:

• Using Python slice syntax in Go
• Assuming built-in reverse function exists
• Off-by-one errors in indexing