Arrays and Strings - Complete DSA Guide

Table of Contents
1. Introduction

2. Arrays Fundamentals

3. String Fundamentals

4. Common Patterns

5. Essential Problems

6. Time & Space Complexity

7. Practice Problems

Introduction
Arrays and Strings form the foundation of data structures and algorithms. They are the most fundamental
data types and appear in almost every coding interview and competitive programming problem.

Why Arrays and Strings Matter

• Ubiquitous: Found in virtually every program

• Foundation: Building blocks for more complex data structures

• Interview Frequency: Most common topics in technical interviews

• Real-world Applications: Used extensively in software development

Arrays Fundamentals

What is an Array?
An array is a collection of elements stored at contiguous memory locations. Elements can be accessed
using indices.

Key Properties
• Fixed Size: Size is determined at creation (in most languages)

• Homogeneous: All elements are of the same type

• Random Access: O(1) access time using indices

• Contiguous Memory: Elements stored in adjacent memory locations

Basic Operations
 Access: arr[i] - O(1)
Insert: arr[i] = value - O(1) for replacement, O(n) for insertion
Delete: O(n) for deletion with shifting
Search: O(n) for unsorted, O(log n) for sorted

Array Types
1. Static Arrays: Fixed size, allocated at compile time

2. Dynamic Arrays: Resizable, allocated at runtime (ArrayList, Vector)

String Fundamentals

What is a String?
A string is a sequence of characters. In most programming languages, strings are implemented as arrays
of characters.

Key Properties
• Immutable: In many languages (Java, Python), strings cannot be modified

• Mutable: In some languages (C++), strings can be modified

• Indexed Access: Characters can be accessed using indices

• Length Property: Built-in method to get string length

String Operations

Access: str[i] - O(1)

Concatenation: str1 + str2 - O(n+m)
Substring: str.substring(i, j) - O(j-i)
Search: str.indexOf(pattern) - O(n*m) naive, O(n+m) KMP

Common Patterns

1. Two Pointers Technique

Used for problems involving pairs, palindromes, or sorted arrays.

Template:
 python

def two_pointers(arr):
left, right = 0, len(arr) - 1
while left < right:
# Process arr[left] and arr[right]
if condition:
left += 1
else:
right -= 1

Applications:

• Finding pairs with target sum

• Palindrome checking

• Removing duplicates

2. Sliding Window
Used for subarray/substring problems with specific constraints.

Template:

python

def sliding_window(arr):
left = 0
result = 0
for right in range(len(arr)):
# Expand window
# Update result if valid
while not valid_condition:
# Shrink window
left += 1
return result

Applications:

• Maximum subarray sum

• Longest substring without repeating characters

• Minimum window substring

3. Prefix Sum
Used for range sum queries and subarray problems.
Template:

python

def prefix_sum(arr):
prefix = [0] * (len(arr) + 1)
for i in range(len(arr)):
prefix[i + 1] = prefix[i] + arr[i]
return prefix

Applications:

• Range sum queries

• Subarray sum equals K

• Maximum subarray sum

Essential Problems

1. Two Sum
Problem: Find two numbers that add up to a target sum.

Approach: Use hash map for O(n) solution.

python

def two_sum(nums, target):

seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return []

2. Valid Palindrome
Problem: Check if a string is a palindrome.

Approach: Two pointers from both ends.

 python

def is_palindrome(s):
left, right = 0, len(s) - 1
while left < right:
if s[left] != s[right]:
return False
left += 1
right -= 1
return True

3. Maximum Subarray (Kadane's Algorithm)

Problem: Find the contiguous subarray with the largest sum.

Approach: Dynamic programming approach.

python

def max_subarray(nums):
max_sum = current_sum = nums[0]
for num in nums[1:]:
current_sum = max(num, current_sum + num)
max_sum = max(max_sum, current_sum)
return max_sum

4. Longest Substring Without Repeating Characters

Problem: Find the length of the longest substring without repeating characters.

Approach: Sliding window with hash set.

python

def length_of_longest_substring(s):
char_set = set()
left = max_length = 0

for right in range(len(s)):

while s[right] in char_set:
char_set.remove(s[left])
left += 1
char_set.add(s[right])
max_length = max(max_length, right - left + 1)

return max_length
5. Merge Sorted Array
Problem: Merge two sorted arrays in-place.

Approach: Start from the end to avoid overwriting.

python

def merge(nums1, m, nums2, n):

i, j, k = m - 1, n - 1, m + n - 1

while i >= 0 and j >= 0:

if nums1[i] > nums2[j]:
nums1[k] = nums1[i]
i -= 1
else:
nums1[k] = nums2[j]
j -= 1
k -= 1

while j >= 0:
nums1[k] = nums2[j]
j -= 1
k -= 1

Time & Space Complexity

Array Operations Complexity

Operation Time Complexity Space Complexity

Access O(1) O(1)

Search O(n) O(1)

Insertion O(n) O(1)

Deletion O(n) O(1)

Sorting O(n log n) O(1) to O(n)

String Operations Complexity

Operation Time Complexity Space Complexity

Access O(1) O(1)

Concatenation O(n) O(n)

Substring O(k) O(k)

Pattern Search O(n*m) to O(n+m) O(1) to O(m)

Common Algorithm Complexities
Algorithm Time Complexity Space Complexity

Two Pointers O(n) O(1)

Sliding Window O(n) O(k)

Prefix Sum O(n) O(n)

Binary Search O(log n) O(1)

Practice Problems

Beginner Level
1. Remove Duplicates from Sorted Array

2. Plus One

3. Move Zeroes

4. Reverse String

5. Valid Anagram

Intermediate Level
1. 3Sum

2. Container With Most Water

3. Longest Palindromic Substring

4. Group Anagrams

5. Product of Array Except Self

Advanced Level
1. Trapping Rain Water

2. Minimum Window Substring

3. Sliding Window Maximum

4. Longest Repeating Character Replacement

5. Find All Anagrams in a String

Tips for Success

Problem-Solving Strategy
 1. Understand: Read the problem carefully

2. Examples: Work through examples manually

3. Pattern: Identify the pattern or technique needed

4. Pseudocode: Write pseudocode before coding

5. Code: Implement the solution

6. Test: Test with edge cases

7. Optimize: Look for optimization opportunities

Common Pitfalls
• Off-by-one errors: Careful with array bounds

• Empty inputs: Handle edge cases

• Integer overflow: Consider large numbers

• Immutable strings: Remember string properties in your language

• Time limits: Consider time complexity for large inputs

Best Practices
• Use meaningful variable names

• Add comments for complex logic

• Handle edge cases explicitly

• Consider space-time tradeoffs

• Practice regularly to build intuition

Conclusion
Arrays and Strings are fundamental data structures that form the basis for more advanced topics.
Mastering these concepts and common patterns will provide a solid foundation for tackling complex
algorithmic problems. Focus on understanding the underlying principles rather than memorizing
solutions, and practice regularly to build problem-solving intuition.