array_string.md

Array & Vector Operations

Table of Contents

• Initialization
• Common Operations
• Sorting
• String Operations
• Conversions
• Quick Reference

---

Initialization

C++ - Vector Initialization

// 1D Vector
vector<int> vec(size);           // size elements with default value
vector<int> vec(size, 0);        // size elements initialized to 0
vector<int> vec = {1, 2, 3};     // Initialize with values
vector<int> vec(arr, arr + n);   // From array

// 2D Vector
vector<vector<int>> vec(rows, vector<int>(cols));        // 2D with default values
vector<vector<int>> vec(rows, vector<int>(cols, 0));     // 2D initialized to 0

Java - Array & ArrayList Initialization

// Array
int[] arr = new int[size];                    // size elements (default 0)
int[] arr = {1, 2, 3};                        // Initialize with values
int[][] arr2D = new int[rows][cols];          // 2D array

// ArrayList
ArrayList<Integer> list = new ArrayList<>();
ArrayList<Integer> list = new ArrayList<>(List.of(5, 2, 9, 1, 3));

// List interface (ArrayList implements List)
List<Integer> list = new ArrayList<>();

---

Common Operations

C++ Operations

// Max/Min element
int maxVal = *max_element(vec.begin(), vec.end());
int minVal = *min_element(vec.begin(), vec.end());

// Find element
auto it = find(vec.begin(), vec.end(), target);
if (it != vec.end()) {
    int index = it - vec.begin();
}

// Sum of array/vector
int sum = accumulate(vec.begin(), vec.end(), 0);
int sum = accumulate(arr, arr + n, 0);  // For arrays

// Push/Pop
vec.push_back(10);        // Add at end
vec.pop_back();           // Remove from end

// Size and clear
int size = vec.size();
vec.clear();              // Remove all elements

Java Operations

// Max/Min element
int maxVal = Collections.max(list);
int minVal = Collections.min(list);

// For arrays
int maxVal = Arrays.stream(arr).max().getAsInt();
int minVal = Arrays.stream(arr).min().getAsInt();

// Sum
int sum = list.stream().mapToInt(Integer::intValue).sum();
int sum = Arrays.stream(arr).sum();

// Add/Remove
list.add(10);             // Add at end
list.remove(list.size() - 1);  // Remove from end

// Size and clear
int size = list.size();
list.clear();             // Remove all elements

---

Sorting

C++ Sorting

// sort array (ascending)
sort(arr, arr + n);

sort(vec.begin(), vec.end()); // sort vector (ascending)
sort(vec.begin(), vec.end(), greater<int>()); // descending

// Custom comparator
sort(vec.begin(), vec.end(), [](int a, int b) {
  return a > b;
});

// Sort 2D vector by first element
sort(vec2D.begin(), vec2D.end(), [](auto& a, auto& b) {
  return a[0] < b[0];
});

Java Sorting

// Array
int[] arr = {1,14,8,9};
Arrays.sort(arr); // sort ascending
Arrays.sort(intervals, (a,b) -> Integer.compare(a[0], b[0])); // sort a 2D array by first element OR
Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

// Strings
String a = "HelloWorld";
char[] charr = a.toCharArray(); // for string sort, we need to perform character sort by converting it into array
Arrays.sort(charr);
String sortedString = new String(charr); // HWdellloor
String sortedDescString = new StringBuilder(new String(charr)).reverse().toString(); // roollledWH

// ArrayList
ArrayList<Integer> list = new ArrayList<>(List.of(5, 2, 9, 1, 3));
Collections.sort(list); // sort ascending
Collections.sort(list, Collections.reverseOrder()); // sort descending

// Iterate string
String str = "hello";
for (int i = 0; i < str.length(); i++) {
  System.out.println(str.charAt(i));
}

for (char ch : str.toCharArray()) {
  System.out.println(ch);
}

// Iterate String array
String[] arr = {"eat", "tea", "tan"};
for (String word : arr) {
  System.out.println(word);
}

for (int i = 0; i < arr.length; i++) {
  System.out.println(arr[i]);
}

---

Conversions

C++ Conversions

// Vector to array
int arr[vec.size()];
copy(vec.begin(), vec.end(), arr);

// Array to vector
vector<int> vec(arr, arr + n);

// String to vector of chars
string str = "hello";
vector<char> vec(str.begin(), str.end());

Java Conversions

// ArrayList to array
Integer[] arr = list.toArray(new Integer[list.size()]);

// Primitive int array
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

// Array to ArrayList
Integer[] arr = {1, 2, 3};
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(arr));

// ArrayList to 2D array
List<List<Integer>> result = new ArrayList<>();
int[][] arr2D = result.stream()
    .map(l -> l.stream().mapToInt(Integer::intValue).toArray())
    .toArray(int[][]::new);

// Or for ArrayList<int[]>
ArrayList<int[]> res = new ArrayList<>();
int[][] arr = res.toArray(new int[res.size()][]);

// Add array to List<List>
result.add(Arrays.asList(arr[i - 1], arr[i]));

---

Java - StringBuffer/StringBuilder

// StringBuffer (thread-safe)
StringBuffer sb = new StringBuffer("hello");
sb.append(" world");
String result = sb.toString();

// StringBuilder (faster, not thread-safe)
StringBuilder sb = new StringBuilder("hello");
sb.append(" world");
String result = sb.toString();

---

Merge Arrays

C++ - Merge Two Arrays

void merge(vector<int>& arr1, int len1, vector<int>& arr2, int len2) {
    for (int i = 0; i < len2; i++) {
        arr1[len1] = arr2[i];
        len1++;
    }
    sort(arr1.begin(), arr1.end());
}

// Better approach using insert
arr1.insert(arr1.end(), arr2.begin(), arr2.end());
sort(arr1.begin(), arr1.end());

Java - Merge Two Arrays

// Using System.arraycopy
int[] result = new int[arr1.length + arr2.length];
System.arraycopy(arr1, 0, result, 0, arr1.length);
System.arraycopy(arr2, 0, result, arr1.length, arr2.length);
Arrays.sort(result);

// Using ArrayList
List<Integer> list = new ArrayList<>();
for (int num : arr1) list.add(num);
for (int num : arr2) list.add(num);
Collections.sort(list);

---

Quick Reference

C++ Vector Methods

Operation	Syntax	Time Complexity
Access	vec[i] or vec.at(i)	O(1)
Push back	vec.push_back(x)	O(1) amortized
Pop back	vec.pop_back()	O(1)
Insert at index	vec.insert(vec.begin() + i, x)	O(n)
Erase at index	vec.erase(vec.begin() + i)	O(n)
Size	vec.size()	O(1)
Empty	vec.empty()	O(1)
Clear	vec.clear()	O(n)
Front	vec.front()	O(1)
Back	vec.back()	O(1)
Sort	sort(vec.begin(), vec.end())	O(n log n)
Find	find(vec.begin(), vec.end(), x)	O(n)
Max element	*max_element(vec.begin(), vec.end())	O(n)
Sum	accumulate(vec.begin(), vec.end(), 0)	O(n)

Java ArrayList Methods

Operation	Syntax	Time Complexity
Access	list.get(i)	O(1)
Add at end	list.add(x)	O(1) amortized
Add at index	list.add(i, x)	O(n)
Remove at index	list.remove(i)	O(n)
Size	list.size()	O(1)
Empty	list.isEmpty()	O(1)
Clear	list.clear()	O(n)
Contains	list.contains(x)	O(n)
Index of	list.indexOf(x)	O(n)
Sort	Collections.sort(list)	O(n log n)
Max element	Collections.max(list)	O(n)
Min element	Collections.min(list)	O(n)
Sum	list.stream().mapToInt(Integer::intValue).sum()	O(n)

Array vs ArrayList (Java)

Feature	Array	ArrayList
Size	Fixed	Dynamic
Type	Primitive or Object	Object only
Performance	Slightly faster	Slightly slower
Syntax	arr[i]	list.get(i)
Length	arr.length	list.size()
Sort	Arrays.sort(arr)	Collections.sort(list)

---

Tips & Tricks

C++ Tips

1. Reserve capacity: Use vec.reserve(n) to avoid reallocations
2. emplace_back: Use emplace_back() instead of push_back() for efficiency
3. Resize vs Reserve: resize() changes size, reserve() only capacity
4. Range-based loops: Use for (auto& x : vec) for cleaner code
5. Algorithms: Use STL algorithms instead of manual loops

Java Tips

6. Initial capacity: new ArrayList<>(capacity) to avoid resizing
7. Arrays.asList: Creates fixed-size list, use new ArrayList<>(Arrays.asList()) for mutable
8. Stream operations: Use streams for functional-style operations
9. Array vs ArrayList: Use arrays for fixed size, ArrayList for dynamic
10. Boxing/Unboxing: Avoid unnecessary boxing with primitive streams

Common to Both

11. Binary search: Array must be sorted first
12. Index out of bounds: Always check bounds before access
13. Empty check: Check before accessing first/last element
14. Sorting stability: Both use stable sorts (maintains relative order)
15. Space complexity: Arrays/vectors use O(n) space

References :

• https://www.w3schools.com/java/java_ref_string.asp
• https://www.geeksforgeeks.org/cpp/cpp-string-functions/