Character Frequency Counting in DSA C# - Time & Space Complexity

Time Complexity: Character Frequency Counting

O(n)

Understanding Time Complexity

We want to understand how long it takes to count how often each character appears in a string.

The question is: how does the time needed grow as the string gets longer?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

var input = "example";
var frequency = new Dictionary<char, int>();

foreach (var ch in input)
{
    if (frequency.ContainsKey(ch))
        frequency[ch]++;
    else
        frequency[ch] = 1;
}
    

This code counts how many times each character appears in the input string.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each character in the string once.
• How many times: Exactly once for each character, so as many times as the 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	About 10 checks and updates
100	About 100 checks and updates
1000	About 1000 checks and updates

Pattern observation: The work grows evenly as the input grows; doubling input doubles work.

Final Time Complexity

Time Complexity: O(n)

This means the time to count characters grows in a straight line with the string length.

Common Mistake

[X] Wrong: "Since we check if a character exists in the dictionary, it might take longer for bigger strings."

[OK] Correct: Dictionary lookups are very fast and do not slow down as the string grows, so each check is almost constant time.

Interview Connect

Knowing how to analyze counting tasks like this helps you explain your code clearly and shows you understand how your program scales.

Self-Check

"What if we used a nested loop to compare each character with every other character? How would the time complexity change?"

Practice

1. What does character frequency counting in a string help us find?

easy

A. The length of the string

B. The first character of the string

C. How many times each character appears in the string

D. The position of a character in the string

Solution

1. Step 1: Understand character frequency counting

   It means counting how many times each character shows up in a string.

2. Step 2: Identify what is counted

   We count the occurrences of each character, not length or position.

3. Final Answer:

   How many times each character appears in the string -> Option C

4. Quick Check:

   Frequency counting = count characters [OK]

Hint: Frequency means count of each character [OK]

Common Mistakes:

• Confusing frequency with string length
• Thinking frequency means character position
• Mixing frequency with first character only

2. Which C# data structure is best to store character frequencies for a string?

easy

A. List<char>

B. Stack<char>

C. Queue<char>

D. Dictionary

Solution

1. Step 1: Identify data structure needs

   We need to map each character to its count, so key-value pairs are needed.

2. Step 2: Choose correct C# structure

   Dictionary stores characters as keys and counts as values.

3. Final Answer:

   Dictionary -> Option D

4. Quick Check:

   Use Dictionary for key-value pairs [OK]

Hint: Use Dictionary for char counts [OK]

Common Mistakes:

• Using List which stores only values, no keys
• Choosing Queue or Stack which are for order, not mapping
• Trying to use arrays without mapping keys

3. What is the output of this C# code?

string s = "hello";
var freq = new Dictionary();
foreach (char c in s) {
  if (freq.ContainsKey(c)) freq[c]++;
  else freq[c] = 1;
}
foreach (var pair in freq) {
  Console.Write(pair.Key + ":" + pair.Value + " ");
}

medium

A. h:1 e:1 l:2 o:1

B. h:1 e:1 l:1 o:1

C. h:1 e:1 l:3 o:1

D. h:1 e:2 l:2 o:1

Solution

1. Step 1: Count characters in "hello"

   h=1, e=1, l=2, o=1

2. Step 2: Check code logic

   Code counts each character correctly and prints key:value pairs with spaces.

3. Final Answer:

   h:1 e:1 l:2 o:1 -> Option A

4. Quick Check:

   Count 'l' twice, others once [OK]

Hint: Count each char carefully, 'l' appears twice [OK]

Common Mistakes:

• Counting 'l' only once
• Adding extra counts for characters
• Misreading output format

4. Find the error in this code that counts character frequency:

string s = "test";
var freq = new Dictionary();
foreach (char c in s) {
  freq[c]++;
}

medium

A. Dictionary not initialized

B. Incrementing freq[c] without checking if key exists

C. Using wrong loop variable

D. String s is empty

Solution

1. Step 1: Analyze dictionary usage

   freq[c]++ tries to increment value without checking if key exists first.

2. Step 2: Identify runtime error

   This causes a KeyNotFoundException because key may not exist initially.

3. Final Answer:

   Incrementing freq[c] without checking if key exists -> Option B

4. Quick Check:

   Check key before incrementing [OK]

Hint: Always check key before incrementing dictionary value [OK]

Common Mistakes:

• Assuming dictionary keys exist by default
• Ignoring KeyNotFoundException
• Not initializing dictionary

5. Given a string, how can you find the character with the highest frequency using C#?
Choose the best approach.

hard

A. Use a Dictionary to count frequencies, then find max value key

B. Sort the string and pick the first character

C. Use a List<char> to store characters and count manually

D. Use a Stack<char> to push characters and pop the most frequent

Solution

1. Step 1: Count frequencies with Dictionary

   Use Dictionary to store counts of each character.

2. Step 2: Find character with max frequency

   Iterate dictionary to find key with highest value.

3. Final Answer:

   Use a Dictionary to count frequencies, then find max value key -> Option A

4. Quick Check:

   Dictionary + max search = highest frequency [OK]

Hint: Count with Dictionary, then find max count key [OK]

Common Mistakes:

• Sorting string does not give frequency info
• Using List without mapping counts
• Stack is not suitable for frequency counting