Introduction to Sequential Data(Arrays & Strings)

Array Memory Layout and Access — Watch how an array stores elements in contiguous memory and how accessing, updating, and inserting operations work step by step.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // Fixed-size array
    int fixedArr[5] = {10, 20, 30, 40, 50};
    
    // Access element at index 2
    cout << "fixedArr[2] = " << fixedArr[2] << endl; // 30
    
    // Update element at index 2
    fixedArr[2] = 99;
    cout << "After update, fixedArr[2] = " << fixedArr[2] << endl; // 99
    
    // Dynamic array (vector)
    vector<int> dynamicArr = {10, 20, 30, 40, 50};
    
    // Append to end - O(1) amortized
    dynamicArr.push_back(60);
    
    // Insert at position 1 - O(n)
    dynamicArr.insert(dynamicArr.begin() + 1, 25);
    
    // Delete at position 3 - O(n)
    dynamicArr.erase(dynamicArr.begin() + 3);
    
    // Traverse and print
    cout << "Dynamic array: ";
    for (int val : dynamicArr) {
        cout << val << " ";
    }
    cout << endl;
    
    // Size of array
    cout << "Size: " << dynamicArr.size() << endl;
    
    return 0;
}

# Python uses lists as dynamic arrays
arr = [10, 20, 30, 40, 50]

# Access element at index 2 - O(1)
print(f"arr[2] = {arr[2]}")  # 30

# Update element at index 2 - O(1)
arr[2] = 99
print(f"After update, arr[2] = {arr[2]}")  # 99

# Append to end - O(1) amortized
arr.append(60)

# Insert at position 1 - O(n)
arr.insert(1, 25)

# Delete at position 3 - O(n)
del arr[3]

# Traverse and print
print(f"Array: {arr}")

# Size of array
print(f"Size: {len(arr)}")

# Negative indexing (Python-specific)
print(f"Last element: {arr[-1]}")
print(f"Second to last: {arr[-2]}")

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayIntro {
    public static void main(String[] args) {
        // Fixed-size array
        int[] fixedArr = {10, 20, 30, 40, 50};
        
        // Access element at index 2 - O(1)
        System.out.println("fixedArr[2] = " + fixedArr[2]); // 30
        
        // Update element at index 2 - O(1)
        fixedArr[2] = 99;
        System.out.println("After update: " + fixedArr[2]); // 99
        
        // Dynamic array (ArrayList)
        ArrayList<Integer> dynamicArr = new ArrayList<>(Arrays.asList(10, 20, 30, 40, 50));
        
        // Append to end - O(1) amortized
        dynamicArr.add(60);
        
        // Insert at position 1 - O(n)
        dynamicArr.add(1, 25);
        
        // Delete at position 3 - O(n)
        dynamicArr.remove(3);
        
        // Traverse and print
        System.out.println("Dynamic array: " + dynamicArr);
        
        // Size
        System.out.println("Size: " + dynamicArr.size());
    }
}

String as a Character Sequence — Watch how a string stores characters sequentially, how indexing works, and how common operations like concatenation and substring create new strings.

#include <iostream>
#include <string>
using namespace std;

int main() {
    // String creation
    string s = "HELLO";
    
    // Access character at index 1 - O(1)
    cout << "s[1] = " << s[1] << endl; // 'E'
    
    // Length - O(1)
    cout << "Length: " << s.length() << endl; // 5
    
    // Strings ARE mutable in C++
    s[0] = 'J';
    cout << "After mutation: " << s << endl; // "JELLO"
    
    // Concatenation - O(n + m)
    string greeting = s + " WORLD";
    cout << "Concatenated: " << greeting << endl;
    
    // Substring - O(k)
    string sub = s.substr(1, 3); // from index 1, take 3 chars
    cout << "Substring: " << sub << endl; // "ELL"
    
    // Find character - O(n)
    size_t pos = s.find('L');
    cout << "First 'L' at index: " << pos << endl; // 2
    
    // Comparison - O(n)
    cout << "Equal? " << (s == "JELLO") << endl; // 1 (true)
    
    // Reverse
    string rev = string(s.rbegin(), s.rend());
    cout << "Reversed: " << rev << endl; // "OLLEJ"
    
    return 0;
}

# String creation
s = "HELLO"

# Access character at index 1 - O(1)
print(f"s[1] = {s[1]}")  # 'E'

# Length - O(1)
print(f"Length: {len(s)}")  # 5

# Strings are IMMUTABLE in Python
# s[0] = 'J'  # This would raise TypeError!

# To "modify", create a new string
s_modified = 'J' + s[1:]
print(f"Modified: {s_modified}")  # "JELLO"
print(f"Original unchanged: {s}")  # "HELLO"

# Concatenation - O(n + m)
greeting = s + " WORLD"
print(f"Concatenated: {greeting}")

# Substring (slicing) - O(k)
sub = s[1:4]
print(f"Substring: {sub}")  # "ELL"

# Find character - O(n)
pos = s.find('L')
print(f"First 'L' at index: {pos}")  # 2

# Comparison - O(n)
print(f"Equal? {s == 'HELLO'}")  # True

# Reverse - O(n)
rev = s[::-1]
print(f"Reversed: {rev}")  # "OLLEH"

# Efficient concatenation with join - O(total_length)
parts = ["Hello", " ", "World"]
result = "".join(parts)
print(f"Joined: {result}")

public class StringIntro {
    public static void main(String[] args) {
        // String creation
        String s = "HELLO";
        
        // Access character at index 1 - O(1)
        System.out.println("s.charAt(1) = " + s.charAt(1)); // 'E'
        
        // Length - O(1)
        System.out.println("Length: " + s.length()); // 5
        
        // Strings are IMMUTABLE in Java
        // Cannot modify characters in place
        
        // To "modify", use StringBuilder (mutable)
        StringBuilder sb = new StringBuilder(s);
        sb.setCharAt(0, 'J');
        String modified = sb.toString();
        System.out.println("Modified: " + modified); // "JELLO"
        System.out.println("Original: " + s); // "HELLO"
        
        // Concatenation - O(n + m)
        String greeting = s + " WORLD";
        System.out.println("Concatenated: " + greeting);
        
        // Substring - O(k)
        String sub = s.substring(1, 4);
        System.out.println("Substring: " + sub); // "ELL"
        
        // Find character - O(n)
        int pos = s.indexOf('L');
        System.out.println("First 'L' at: " + pos); // 2
        
        // Comparison - O(n)
        System.out.println("Equal? " + s.equals("HELLO")); // true
        
        // Reverse using StringBuilder - O(n)
        String rev = new StringBuilder(s).reverse().toString();
        System.out.println("Reversed: " + rev); // "OLLEH"
        
        // Efficient concatenation with StringBuilder
        StringBuilder builder = new StringBuilder();
        builder.append("Hello");
        builder.append(" ");
        builder.append("World");
        System.out.println("Built: " + builder.toString());
    }
}

Array vs String: In-Place Reversal Comparison — Watch how an array can be reversed in-place using two pointers (O(1) space), while a string must create a new copy (O(n) space) due to immutability.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

int main() {
    // === ARRAY: Mutable, in-place reversal ===
    vector<int> arr = {1, 2, 3, 4, 5};
    
    // Reverse in-place using two pointers
    int left = 0, right = arr.size() - 1;
    while (left < right) {
        swap(arr[left], arr[right]);
        left++;
        right--;
    }
    // arr is now {5, 4, 3, 2, 1} — modified in place
    
    cout << "Reversed array: ";
    for (int x : arr) cout << x << " ";
    cout << endl;
    
    // === STRING: Mutable in C++ (unlike Python/Java) ===
    string s = "ABCDE";
    
    // Can reverse in-place in C++
    reverse(s.begin(), s.end());
    cout << "Reversed string: " << s << endl; // "EDCBA"
    
    // Frequency counting using small alphabet
    string text = "hello world";
    int freq[26] = {0};
    for (char c : text) {
        if (c >= 'a' && c <= 'z') {
            freq[c - 'a']++;
        }
    }
    cout << "Frequency of 'l': " << freq['l' - 'a'] << endl; // 3
    
    return 0;
}

# === ARRAY (list): Mutable, in-place reversal ===
arr = [1, 2, 3, 4, 5]

# Reverse in-place using two pointers
left, right = 0, len(arr) - 1
while left < right:
    arr[left], arr[right] = arr[right], arr[left]
    left += 1
    right -= 1
# arr is now [5, 4, 3, 2, 1] — modified in place
print(f"Reversed array: {arr}")

# Or simply: arr.reverse() or arr[::-1]

# === STRING: Immutable in Python ===
s = "ABCDE"

# Cannot modify in place: s[0] = 'X'  → TypeError!
# Must create new string
reversed_s = s[::-1]
print(f"Reversed string: {reversed_s}")  # "EDCBA"
print(f"Original unchanged: {s}")  # "ABCDE"

# Frequency counting using small alphabet
text = "hello world"
freq = [0] * 26
for c in text:
    if c.isalpha():
        freq[ord(c.lower()) - ord('a')] += 1
print(f"Frequency of 'l': {freq[ord('l') - ord('a')]}")  # 3

# Or use Counter for convenience
from collections import Counter
print(Counter(text))  # {'l': 3, 'o': 2, ...}

import java.util.*;

public class ArrayVsString {
    public static void main(String[] args) {
        // === ARRAY: Mutable, in-place reversal ===
        int[] arr = {1, 2, 3, 4, 5};
        
        // Reverse in-place using two pointers
        int left = 0, right = arr.length - 1;
        while (left < right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
        // arr is now {5, 4, 3, 2, 1}
        System.out.println("Reversed array: " + Arrays.toString(arr));
        
        // === STRING: Immutable in Java ===
        String s = "ABCDE";
        
        // Cannot modify in place
        // Must use StringBuilder for reversal
        String reversedS = new StringBuilder(s).reverse().toString();
        System.out.println("Reversed string: " + reversedS); // "EDCBA"
        System.out.println("Original unchanged: " + s); // "ABCDE"
        
        // Frequency counting using small alphabet
        String text = "hello world";
        int[] freq = new int[26];
        for (char c : text.toCharArray()) {
            if (Character.isLetter(c)) {
                freq[Character.toLowerCase(c) - 'a']++;
            }
        }
        System.out.println("Frequency of 'l': " + freq['l' - 'a']); // 3
    }
}

#include <iostream>
#include <vector>
#include <string>
using namespace std;

// Demonstrates: Traversal, the most fundamental operation
void traverseArray(vector<int>& arr) {
    cout << "Array traversal: ";
    for (int i = 0; i < arr.size(); i++) {
        cout << arr[i];
        if (i < arr.size() - 1) cout << ", ";
    }
    cout << endl;
}

void traverseString(const string& s) {
    cout << "String traversal: ";
    for (int i = 0; i < s.length(); i++) {
        cout << s[i];
        if (i < s.length() - 1) cout << ", ";
    }
    cout << endl;
}

int main() {
    vector<int> nums = {10, 20, 30, 40, 50};
    string text = "HELLO";
    
    traverseArray(nums);
    traverseString(text);
    
    // Both use the same index-based access pattern
    // Both iterate in O(n) time
    // The syntax is nearly identical — that's the beauty
    // of sequential data structures
    
    return 0;
}

# Demonstrates: Traversal, the most fundamental operation
def traverse_array(arr):
    print("Array traversal:", end=" ")
    for i in range(len(arr)):
        print(arr[i], end="")
        if i < len(arr) - 1:
            print(", ", end="")
    print()

def traverse_string(s):
    print("String traversal:", end=" ")
    for i in range(len(s)):
        print(s[i], end="")
        if i < len(s) - 1:
            print(", ", end="")
    print()

nums = [10, 20, 30, 40, 50]
text = "HELLO"

traverse_array(nums)
traverse_string(text)

# Pythonic traversal (for-each style)
for num in nums:
    print(num, end=" ")
print()

for char in text:
    print(char, end=" ")
print()

# Both use identical patterns — sequential data is sequential data

public class TraversalDemo {
    // Demonstrates: Traversal, the most fundamental operation
    public static void traverseArray(int[] arr) {
        System.out.print("Array traversal: ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) System.out.print(", ");
        }
        System.out.println();
    }
    
    public static void traverseString(String s) {
        System.out.print("String traversal: ");
        for (int i = 0; i < s.length(); i++) {
            System.out.print(s.charAt(i));
            if (i < s.length() - 1) System.out.print(", ");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40, 50};
        String text = "HELLO";
        
        traverseArray(nums);
        traverseString(text);
        
        // Enhanced for-each loop
        for (int num : nums) {
            System.out.print(num + " ");
        }
        System.out.println();
        
        for (char c : text.toCharArray()) {
            System.out.print(c + " ");
        }
        System.out.println();
    }
}