String Traversal with Examples

What Is String Traversal?

String traversal is the process of visiting the characters of a string one by one in a defined order. Traversal is one of the most fundamental techniques used when solving string problems because many algorithms need to inspect or process every character.

For example, given the string "HELLO", a forward traversal visits the characters in this order: H → E → L → L → O.

Traversing a String Using an Index

The most common approach is to use a for loop with an index. The loop starts at index 0 and continues until the index reaches the string length.

const text = "HELLO";

for (let i = 0; i < text.length; i++) {
  console.log(text[i]);
}

The loop accesses each character using its index. For a string of length n, this traversal visits all n positions.

Understanding the Index During Traversal

Consider the string "CODE". Each character has a corresponding index:

Character: C  O  D  E
Index:     0  1  2  3

During traversal, the index moves from 0 through 3. The condition i < text.length prevents the loop from accessing an invalid position.

Using a for...of Loop

JavaScript provides the for...of loop for directly iterating over the characters of a string. This approach is useful when the index itself is not required.

const text = "HELLO";

for (const character of text) {
  console.log(character);
}

The loop automatically moves from one character to the next, making the code simpler when only the character value is needed.

Traversal With Character Position

When both the character and its position are required, an indexed loop is often more convenient.

const text = "CODE";

for (let i = 0; i < text.length; i++) {
  console.log("Index:", i, "Character:", text[i]);
}

This pattern is useful when an algorithm needs to compare characters at different positions or modify the result based on the current index.

Reverse String Traversal

Traversal does not have to start at the beginning. A string can also be traversed from the last character toward the first character. Reverse traversal starts at text.length - 1 and decreases the index until it reaches 0.

const text = "HELLO";

for (let i = text.length - 1; i >= 0; i--) {
  console.log(text[i]);
}

The output is: O → L → L → E → H. Reverse traversal is useful for string reversal, suffix processing, and algorithms that compare characters from opposite ends.

Building a Result During Traversal

Traversal becomes more useful when the visited characters are used to construct a result. For example, a string can be reversed by adding each character to a new string while traversing from right to left.

const text = "HELLO";
let reversed = "";

for (let i = text.length - 1; i >= 0; i--) {
  reversed += text[i];
}

console.log(reversed);
// OLLEH

In production code, the best implementation can depend on the language and input size. The important algorithmic idea is that traversal visits the characters in reverse order.

Counting Characters During Traversal

A common use of traversal is counting specific characters. The following example counts the number of vowels in a string.

const text = "javascript";
let vowelCount = 0;

for (const character of text) {
  if ("aeiou".includes(character)) {
    vowelCount++;
  }
}

console.log(vowelCount);

The same traversal pattern can be adapted to count digits, spaces, uppercase letters, specific symbols, or other character categories.

Searching During Traversal

Traversal can also be used to find a particular character manually. This is useful for understanding the basic search process behind many string algorithms.

const text = "developer";
const target = "v";

let position = -1;

for (let i = 0; i < text.length; i++) {
  if (text[i] === target) {
    position = i;
    break;
  }
}

console.log(position);
// 4

The break statement stops the traversal as soon as the target is found. This avoids unnecessary work when only the first occurrence is required.

Comparing Characters During Traversal

Some problems require comparing characters at different positions. For example, a palindrome check can compare the first and last characters, then move toward the center.

const text = "level";

let left = 0;
let right = text.length - 1;
let isPalindrome = true;

while (left < right) {
  if (text[left] !== text[right]) {
    isPalindrome = false;
    break;
  }

  left++;
  right--;
}

console.log(isPalindrome);
// true

This is a two-pointer form of string traversal. Instead of processing one character at a time from one direction, two positions move toward each other.

Skipping Characters During Traversal

Traversal does not always need to process every character in the same way. Conditions can be used to ignore spaces, punctuation, or other unwanted characters.

const text = "hello world";

for (const character of text) {
  if (character === " ") {
    continue;
  }

  console.log(character);
}

The continue statement skips the current iteration and moves to the next character.

Traversal With Case Normalization

When a problem is case-insensitive, the input can be normalized before traversal. This prevents uppercase and lowercase versions of the same letter from being treated differently.

const text = "JavaScript".toLowerCase();

for (const character of text) {
  console.log(character);
}

Another option is to normalize each character while processing it, although normalizing the complete input once is often simpler when the entire algorithm uses the same comparison rule.

Traversal With a Frequency Map

A very common pattern is to traverse the string and store information about each character in a hash map or JavaScript object. This approach is used for character-frequency and anagram problems.

const text = "banana";
const frequency = {};

for (const character of text) {
  frequency[character] =
    (frequency[character] || 0) + 1;
}

console.log(frequency);
// { b: 1, a: 3, n: 2 }

The traversal itself takes linear time, while the additional map stores the information needed for later lookups.

Nested String Traversal

Some problems involve comparing every character with other characters. This can require nested loops, where one traversal is performed inside another.

const text = "abc";

for (let i = 0; i < text.length; i++) {
  for (let j = i + 1; j < text.length; j++) {
    console.log(text[i], text[j]);
  }
}

Unlike a simple traversal, nested traversal can take O(n²) time. This distinction becomes important when optimizing string algorithms.

String Traversal Patterns

Time Complexity of String Traversal

A single traversal of a string containing n characters takes O(n) time because each character is visited once.

for (let i = 0; i < text.length; i++) {
  // Constant amount of work
}

If a second complete traversal is performed one after another, the total is still O(n), because O(n) + O(n) simplifies to O(n). However, nested traversals can increase the complexity to O(n²).

Common Mistakes in String Traversal

• Starting at index 1 when the first character is required.
• Using i <= text.length instead of i < text.length.
• Starting reverse traversal at text.length instead of text.length - 1.
• Forgetting to decrement the index during reverse traversal.
• Comparing characters without considering case sensitivity.
• Ignoring spaces or punctuation when the problem requires normalization.
• Using nested loops when a single traversal or frequency map could solve the problem.
• Forgetting that JavaScript strings are immutable when attempting direct character modification.

Where String Traversal Is Used

String traversal is a basic technique behind many practical and algorithmic tasks, including:

• Counting characters and vowels
• Finding duplicate characters
• Checking palindromes
• Reversing strings
• Validating user input
• Searching for specific patterns
• Comparing strings
• Building character-frequency maps
• Processing text and log data
• Solving coding interview problems

Key Takeaways

• String traversal means visiting characters in a defined order.
• An indexed for loop provides direct access to both characters and positions.
• A for...of loop is convenient when only character values are required.
• Reverse traversal starts from length - 1.
• Two-pointer traversal is useful for comparing characters from opposite ends.
• Traversal can be combined with maps, counters, conditions, and other data structures.
• A single traversal is generally O(n), while nested traversal may become O(n²).