String Basics and Memory Representation in DSA C++ - Time & Space Complexity

Time Complexity: String Basics and Memory Representation

O(n)

Understanding Time Complexity

We want to understand how the time to work with strings grows as the string gets longer.

How does the number of steps change when we do basic string operations like copying or accessing characters?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

#include <iostream>
#include <string>

int main() {
    std::string s = "hello";
    for (size_t i = 0; i < s.size(); ++i) {
        char c = s[i];
        std::cout << c;
    }
    return 0;
}
    

This code prints each character of a string one by one by accessing each index.

Identify Repeating Operations

• Primary operation: Accessing each character in the string using indexing.
• How many times: Once for each character in the string (n times, where n is string length).

How Execution Grows With Input

As the string gets longer, the number of steps grows directly with its length.

Input Size (n)	Approx. Operations
10	10 character accesses and prints
100	100 character accesses and prints
1000	1000 character accesses and prints

Pattern observation: Doubling the string length doubles the work needed.

Final Time Complexity

Time Complexity: O(n)

This means the time to process the string grows in a straight line with its length.

Common Mistake

[X] Wrong: "Accessing a character by index in a string is constant time, so the whole loop is constant time."

[OK] Correct: While each character access is fast, the loop runs once for every character, so total time grows with string length.

Interview Connect

Understanding how string operations scale helps you write efficient code and explain your reasoning clearly in interviews.

Self-Check

"What if we replaced the loop with a recursive function that processes one character at a time? How would the time complexity change?"

Practice

1. What does the following C++ code represent?
char str[] = "hello";

easy

A. An array of characters ending with a null character

B. A pointer to a constant string literal

C. A string object from the C++ standard library

D. A dynamically allocated string

Solution

1. Step 1: Understand the declaration type

   The code declares str as a character array initialized with the string "hello".

2. Step 2: Recognize the null terminator in C-style strings

   In C++, character arrays initialized with string literals automatically include a null character '\0' at the end to mark the string's end.

3. Final Answer:

   An array of characters ending with a null character -> Option A

4. Quick Check:

   C-style string = char array + '\0' [OK]

Hint: Remember C strings always end with '\0' null character [OK]

Common Mistakes:

• Confusing array with pointer
• Forgetting the null terminator
• Thinking it's a C++ string object

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

easy

A. char *str = "hello";

B. char str = "hello";

C. char str[] = 'hello';

D. string str = 'hello';

Solution

1. Step 1: Check pointer declaration syntax

   char *str = "hello"; declares a pointer to a string literal correctly.

2. Step 2: Identify errors in other options

   char str = "hello"; uses a single char variable for a string literal, which is invalid.
   char str[] = 'hello'; uses single quotes for multiple characters, which is invalid.
   string str = 'hello'; uses single quotes with string type, which requires double quotes.

3. Final Answer:

   char *str = "hello"; -> Option A

4. Quick Check:

   Pointer to string literal uses char * and double quotes [OK]

Hint: String literals need char* with double quotes [OK]

Common Mistakes:

• Using single quotes for strings
• Assigning string literal to char variable
• Confusing char array and pointer syntax

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

char str[] = "abc";
std::cout << sizeof(str) << std::endl;

medium

A. 3

B. Undefined behavior

C. 5

D. 4

Solution

1. Step 1: Understand sizeof on char array initialized with string

   The array str contains characters 'a', 'b', 'c' plus a null terminator '\0'. So total 4 characters.

2. Step 2: sizeof returns total bytes of array

   Since each char is 1 byte, sizeof(str) returns 4.

3. Final Answer:

   4 -> Option D

4. Quick Check:

   sizeof(char array with "abc") = 4 [OK]

Hint: Count characters plus null terminator for sizeof [OK]

Common Mistakes:

• Ignoring null terminator in size
• Confusing sizeof with string length
• Expecting runtime output instead of compile-time size

4. Identify the error in the following code snippet:

char *str = "hello";
str[0] = 'H';
std::cout << str << std::endl;

medium

A. Output will be empty string

B. Pointer str is not initialized

C. Modifying a string literal causes undefined behavior

D. Syntax error in assignment

Solution

1. Step 1: Understand string literal immutability

   String literals are stored in read-only memory. Modifying them causes undefined behavior.

2. Step 2: Analyze the code's modification attempt

   The code tries to change the first character of the string literal via pointer, which is not allowed.

3. Final Answer:

   Modifying a string literal causes undefined behavior -> Option C

4. Quick Check:

   String literals are immutable in C++ [OK]

Hint: Never modify string literals through pointers [OK]

Common Mistakes:

• Assuming string literals are modifiable arrays
• Ignoring const correctness
• Confusing pointer initialization with mutability

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

char str1[] = "abc";
char *str2 = str1;
str2[1] = 'z';
std::cout << str1 << std::endl;

hard

A. abc

B. azc

C. a\0c

D. Runtime error

Solution

1. Step 1: Understand array and pointer relationship

   str1 is a modifiable character array. str2 points to the same array.

2. Step 2: Modify character via pointer

   Changing str2[1] changes the second character of str1 from 'b' to 'z'.

3. Step 3: Print the modified array

   Printing str1 outputs "azc" reflecting the change.

4. Final Answer:

   azc -> Option B

5. Quick Check:

   Pointer modifies array content directly [OK]

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

Common Mistakes:

• Thinking string literals are modifiable
• Confusing pointer and array copy
• Expecting original string unchanged