[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_33":94,"_74":95,"_37":96},"articles",{"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":24,"_26":16,"_27":28},"content",[31,32],"pageable",{"_29":22,"_30":20},"totalElements",2,"totalPages",1,"size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_33":114,"_35":115,"_37":116,"_39":117,"_11":118,"_42":-5,"_43":24,"_44":28,"_45":46,"_47":119,"_49":120,"_51":52,"_53":100,"_55":100,"_56":57,"_58":59,"_60":61,"_62":100,"_63":64,"_65":121,"_66":122,"_68":123,"_70":124,"_72":125},{"_33":34,"_35":36,"_37":38,"_39":40,"_11":41,"_42":-5,"_43":24,"_44":28,"_45":46,"_47":48,"_49":50,"_51":52,"_53":54,"_55":54,"_56":57,"_58":59,"_60":61,"_62":54,"_63":64,"_65":20,"_66":67,"_68":69,"_70":71,"_72":73},"id",81,"title","Sorting Algorithms","slug","dsa-cheatsheet-part-10-sorting","excerpt","Visual comparison of sorting algorithms: Bubble, Selection, Insertion, Quick, Merge. See them race side-by-side.","# Sorting Algorithms\n\n## 📋 Quick Reference\n\n| Algorithm | Time (Best) | Time (Avg) | Time (Worst) | Space | Stable |\n|-----------|-------------|------------|--------------|-------|--------|\n| Bubble Sort | O(n) | O(n²) | O(n²) | O(1) | Yes |\n| Selection Sort | O(n²) | O(n²) | O(n²) | O(1) | No |\n| Insertion Sort | O(n) | O(n²) | O(n²) | O(1) | Yes |\n| Merge Sort | O(n log n) | O(n log n) | O(n log n) | O(n) | Yes |\n| Quick Sort | O(n log n) | O(n log n) | O(n²) | O(log n) | No |\n| Heap Sort | O(n log n) | O(n log n) | O(n log n) | O(1) | No |\n\n**One-liner**: *Sorting arranges elements in order; choose algorithm based on data size, memory constraints, and stability needs.*\n\n---\n\n## 🎮 Interactive Visualizer\n\nWatch different sorting algorithms race side-by-side:\n\n```visualizer-sorting\nshowControls: true\nshowCode: true\nalgorithm: quick\n```\n\n**Try these:**\n1. Switch between algorithms using the selector\n2. Compare how many swaps/comparisons each makes\n3. Notice which algorithms are faster on nearly-sorted data\n\n### Side-by-Side Comparison\n\n```visualizer-sorting-comparison\nshowControls: true\nshowCode: true\n```\n\n---\n\n## 🔧 Algorithm Implementations\n\n### Bubble Sort\n\n```java\n// Repeatedly swap adjacent elements if out of order\npublic void bubbleSort(int[] arr) {\n int n = arr.length;\n for (int i = 0; i < n - 1; i++) {\n boolean swapped = false;\n for (int j = 0; j < n - i - 1; j++) {\n if (arr[j] > arr[j + 1]) {\n swap(arr, j, j + 1);\n swapped = true;\n }\n }\n if (!swapped) break; // Optimization: already sorted\n }\n}\n```\n\n### Selection Sort\n\n```java\n// Find minimum, place at beginning, repeat\npublic void selectionSort(int[] arr) {\n int n = arr.length;\n for (int i = 0; i < n - 1; i++) {\n int minIdx = i;\n for (int j = i + 1; j < n; j++) {\n if (arr[j] < arr[minIdx]) {\n minIdx = j;\n }\n }\n swap(arr, i, minIdx);\n }\n}\n```\n\n### Insertion Sort\n\n```java\n// Insert each element into its correct position\npublic void insertionSort(int[] arr) {\n for (int i = 1; i < arr.length; i++) {\n int key = arr[i];\n int j = i - 1;\n while (j >= 0 && arr[j] > key) {\n arr[j + 1] = arr[j];\n j--;\n }\n arr[j + 1] = key;\n }\n}\n```\n\n### Merge Sort\n\n```java\n// Divide, sort halves, merge\npublic void mergeSort(int[] arr, int left, int right) {\n if (left < right) {\n int mid = left + (right - left) / 2;\n mergeSort(arr, left, mid);\n mergeSort(arr, mid + 1, right);\n merge(arr, left, mid, right);\n }\n}\n\nprivate void merge(int[] arr, int left, int mid, int right) {\n int[] temp = new int[right - left + 1];\n int i = left, j = mid + 1, k = 0;\n\n while (i <= mid && j <= right) {\n if (arr[i] <= arr[j]) {\n temp[k++] = arr[i++];\n } else {\n temp[k++] = arr[j++];\n }\n }\n\n while (i <= mid) temp[k++] = arr[i++];\n while (j <= right) temp[k++] = arr[j++];\n\n System.arraycopy(temp, 0, arr, left, temp.length);\n}\n```\n\n### Quick Sort\n\n```java\n// Partition around pivot, sort partitions\npublic void quickSort(int[] arr, int low, int high) {\n if (low < high) {\n int pi = partition(arr, low, high);\n quickSort(arr, low, pi - 1);\n quickSort(arr, pi + 1, high);\n }\n}\n\nprivate int partition(int[] arr, int low, int high) {\n int pivot = arr[high];\n int i = low - 1;\n\n for (int j = low; j < high; j++) {\n if (arr[j] < pivot) {\n i++;\n swap(arr, i, j);\n }\n }\n\n swap(arr, i + 1, high);\n return i + 1;\n}\n```\n\n### Java Standard Library\n\n```java\n// For primitives - Dual-Pivot QuickSort\nint[] arr = {5, 2, 8, 1, 9};\nArrays.sort(arr);\n\n// For objects - TimSort (stable)\nString[] names = {\"Charlie\", \"Alice\", \"Bob\"};\nArrays.sort(names);\n\n// Custom comparator\nArrays.sort(names, (a, b) -> b.compareTo(a)); // Reverse\n\n// Partial sort\nArrays.sort(arr, 0, 5); // Sort indices 0-4 only\n\n// Parallel sort (for large arrays)\nArrays.parallelSort(arr); // Uses ForkJoinPool\n```\n\n---\n\n## 📊 When to Use Which Algorithm\n\n### Small Arrays (n < 50)\n\n**Use: Insertion Sort**\n- Simple, low overhead\n- Very fast for small n\n- Java's Arrays.sort uses it for small subarrays\n\n### General Purpose\n\n**Use: Quick Sort** (primitives) or **Merge Sort/TimSort** (objects)\n- Quick Sort: Fastest in practice for primitives\n- Merge Sort: Stable, guaranteed O(n log n)\n- TimSort: Hybrid, exploits existing order\n\n### Memory Constrained\n\n**Use: Heap Sort or Quick Sort**\n- Both use O(1) or O(log n) extra space\n- Heap Sort is guaranteed O(n log n)\n\n### Nearly Sorted Data\n\n**Use: Insertion Sort or TimSort**\n- O(n) for nearly sorted data\n- TimSort specifically designed for this\n\n### Stability Required\n\n**Use: Merge Sort or TimSort**\n- Maintains relative order of equal elements\n- Critical for multi-key sorting\n\n---\n\n## 🧩 Stability Explained\n\n**Stable sort**: Equal elements maintain their relative order\n\n```java\n// Original: [(Alice, 25), (Bob, 30), (Carol, 25)]\n// Sort by age\n\n// Stable sort result:\n// [(Alice, 25), (Carol, 25), (Bob, 30)]\n// Alice still before Carol (both age 25)\n\n// Unstable sort might give:\n// [(Carol, 25), (Alice, 25), (Bob, 30)]\n// Order of same-age people changed\n```\n\n---\n\n## ⚠️ Common Pitfalls\n\n### 1. Wrong Algorithm Choice\n\n```java\n// ❌ Using bubble sort for large arrays\nbubbleSort(millionElements); // Takes forever!\n\n// ✅ Use efficient algorithm\nArrays.sort(millionElements);\n```\n\n### 2. Quick Sort Worst Case\n\n```java\n// ❌ Already sorted array with naive pivot\nquickSort(sortedArray); // O(n²) if pivot is always first/last!\n\n// ✅ Use random pivot or median-of-three\nint pivot = arr[random.nextInt(high - low + 1) + low];\n```\n\n### 3. Forgetting Stability Needs\n\n```java\n// ❌ Sorting objects with unstable sort\nArrays.sort(people, ageComparator); // May reorder same-age\nArrays.sort(people, nameComparator); // Previous age order lost!\n\n// ✅ Use stable sort for multi-key\n// Java's Arrays.sort for objects IS stable (TimSort)\n```\n\n### 4. Modifying During Sort\n\n```java\n// ❌ Modifying array while sorting with comparator\nArrays.sort(arr, (a, b) -> {\n arr[0] = 999; // DON'T DO THIS!\n return a - b;\n});\n```\n\n---\n\n## 🎯 Interview Practice\n\nTest your sorting algorithm knowledge with 10 curated interview questions:\n\n```visualizer-sorting-comparison-interview\nshowControls: true\n```\n\n---\n\n## 🎤 Interview Tips\n\n**Q: Which sorting algorithm does Java use?**\n\n> For primitives: Dual-Pivot QuickSort. For objects: TimSort (a hybrid of merge sort and insertion sort). TimSort is stable, QuickSort is not.\n\n**Q: When would you use O(n²) algorithms?**\n\n> For small arrays (n < 50), insertion sort is often fastest due to low overhead. Also useful when data is nearly sorted.\n\n**Q: How does QuickSort achieve O(n log n) average?**\n\n> On average, the pivot splits the array roughly in half, giving log n levels of recursion, each doing O(n) work total. Worst case (already sorted with bad pivot) degrades to O(n²).\n\n**Q: What is TimSort?**\n\n> A hybrid algorithm combining merge sort and insertion sort. It identifies \"runs\" (sorted subsequences) and merges them efficiently. Optimized for real-world data that often has existing order.\n\n---\n\n## 📚 Series Navigation\n\n**Previous**: [Part 9: Binary Search](dsa-cheatsheet-part-9-binary-search)\n\n**Next**: [Part 11: Graph Traversal (DFS & BFS)](dsa-cheatsheet-part-11-graph-traversal)\n\n---\n\n**Visualizers**: `Sorting`, `SortingComparison` from `@tomaszjarosz/react-visualizers`\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:25.681449Z","createdAt","2026-06-10T07:19:25.681821Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",5,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Algorithms","readingTime","seriesId",4,"seriesOrder","author",{"_33":57,"_104":59,"_105":106,"_107":108,"_109":-5,"_110":-5,"_111":-5,"_112":-5,"_113":-5},"category",{"_33":100,"_74":61,"_37":101,"_77":102,"_103":-5},"tags",[80,81,82,83,84],"series",{"_33":64,"_74":75,"_37":76,"_77":78,"_79":24},"name","Interactive Data Structures & Algorithms","dsa-visualized-cheatsheet","description","A concise, visual reference for essential data structures and algorithms. Each article features an interactive visualizer showing how the structure/algorithm works step-by-step, along with complexity analysis, use cases, and quick reference code. Perfect for interview prep, quick review, or learning by visualization.","isActive",{"_33":97,"_74":98,"_37":99},{"_33":94,"_74":95,"_37":96},{"_33":91,"_74":92,"_37":93},{"_33":88,"_74":89,"_37":90},{"_33":85,"_74":86,"_37":87},133,"Sorting","sorting",131,"Quicksort","quicksort",132,"Mergesort","mergesort",279,"Comparison","comparison",278,"Algorithm","algorithm",6,"algorithms","Category for Algorithms","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl",95,"ArrayList vs LinkedList","dsa-cheatsheet-part-24-list-comparison","Visual comparison of ArrayList vs LinkedList: see operation complexity differences side-by-side. Know when to use which.","# ArrayList vs LinkedList: Side-by-Side Comparison\n\n## 📋 Quick Reference\n\n| Operation | ArrayList | LinkedList | Winner |\n|-----------|-----------|------------|--------|\n| `get(i)` | **O(1)** | O(n) | ArrayList |\n| `add(e)` (end) | **O(1)*** | O(1) | Tie |\n| `add(0, e)` (front) | O(n) | **O(1)** | LinkedList |\n| `add(i, e)` (middle) | O(n) | O(n) | ArrayList** |\n| `remove(0)` | O(n) | **O(1)** | LinkedList |\n| `remove(size-1)` | **O(1)** | O(1) | Tie |\n| `contains(e)` | O(n) | O(n) | ArrayList** |\n| Memory per element | **~4 bytes** | ~24 bytes | ArrayList |\n\n\\* Amortized (occasional resize)\n\\** Better cache locality\n\n**One-liner**: *ArrayList for random access and memory efficiency; LinkedList only for frequent front insertions or queue/deque operations.*\n\n---\n\n## 🎮 Interactive Visualizer\n\nCompare how ArrayList and LinkedList handle the same operations:\n\n```visualizer-listcomparison\nshowControls: true\nshowCode: true\n```\n\n**Try these operations:**\n1. Random access (get) - see ArrayList's O(1) vs LinkedList's traversal\n2. Add at front - LinkedList just updates pointers\n3. Add at end - both are fast\n4. Add in middle - ArrayList shifts, LinkedList traverses then inserts\n\n---\n\n## 🔧 Internal Structure\n\n### ArrayList (Dynamic Array)\n\n```\nContiguous memory block:\n┌───┬───┬───┬───┬───┬───┬───┬───┐\n│ A │ B │ C │ D │ E │ │ │ │\n└───┴───┴───┴───┴───┴───┴───┴───┘\n 0 1 2 3 4 5 6 7\n ↑\n size=5, capacity=8\n\nget(2): Direct calculation → array[2] → O(1)\nadd(\"F\"): array[5] = \"F\", size++ → O(1)\nadd(0, \"Z\"): Shift all right, then insert → O(n)\n```\n\n### LinkedList (Doubly-Linked)\n\n```\nScattered nodes with pointers:\n┌─────────┐ ┌─────────┐ ┌─────────┐\n│ prev: ∅ │←──→│ prev │←──→│ prev │\n│ data: A │ │ data: B │ │ data: C │\n│ next │←──→│ next │←──→│ next: ∅ │\n└─────────┘ └─────────┘ └─────────┘\n ↑ ↑\n head tail\n\nget(2): head→next→next → O(n)\naddFirst(\"Z\"): Create node, update head pointer → O(1)\naddLast(\"D\"): Create node, update tail pointer → O(1)\n```\n\n---\n\n## 📊 Detailed Complexity Analysis\n\n### Time Complexity\n\n| Operation | ArrayList | LinkedList | Notes |\n|-----------|-----------|------------|-------|\n| `get(index)` | O(1) | O(n) | AL: direct index; LL: traverse |\n| `set(index, e)` | O(1) | O(n) | Same as get |\n| `add(e)` | O(1)* | O(1) | AL: amortized; LL: has tail |\n| `add(index, e)` | O(n) | O(n) | AL: shift; LL: traverse + insert |\n| `addFirst(e)` | O(n) | O(1) | AL: shift all; LL: pointer update |\n| `remove(index)` | O(n) | O(n) | AL: shift; LL: traverse |\n| `removeFirst()` | O(n) | O(1) | AL: shift all; LL: pointer update |\n| `removeLast()` | O(1) | O(1) | Both have tail/size info |\n| `contains(e)` | O(n) | O(n) | AL faster (cache) |\n| `indexOf(e)` | O(n) | O(n) | AL faster (cache) |\n| `clear()` | O(n) | O(n) | Help GC |\n| `size()` | O(1) | O(1) | Both cache size |\n\n\\* Amortized O(1), worst case O(n) during resize\n\n### Space Complexity\n\n| Aspect | ArrayList | LinkedList |\n|--------|-----------|------------|\n| Element storage | 4-8 bytes/ref | 24+ bytes/node |\n| Overhead (empty) | ~88 bytes | ~48 bytes |\n| Overhead (1000 elem) | ~4-16 KB | ~24 KB |\n| Memory locality | Contiguous | Scattered |\n| Cache performance | Excellent | Poor |\n\n---\n\n## ✅ When to Use Which\n\n### Choose ArrayList When\n\n```java\n// ✅ Random access is common\nfor (int i = 0; i < list.size(); i++) {\n process(list.get(i)); // O(1) each\n}\n\n// ✅ Iterating frequently (cache-friendly)\nfor (String item : arrayList) {\n // Sequential memory access = fast\n}\n\n// ✅ Adding mostly at the end\nlist.add(newItem); // O(1) amortized\n\n// ✅ Memory efficiency matters\n// ArrayList: ~4 bytes overhead per element\n// LinkedList: ~24 bytes overhead per element\n\n// ✅ You know approximate size upfront\nList users = new ArrayList<>(1000); // Pre-allocate\n```\n\n### Choose LinkedList When\n\n```java\n// ✅ Frequent insertions/removals at front\nwhile (!queue.isEmpty()) {\n Item item = queue.removeFirst(); // O(1)\n queue.addLast(process(item)); // O(1)\n}\n\n// ✅ Using as Queue or Deque\nDeque deque = new LinkedList<>();\ndeque.offerFirst(urgentTask); // O(1)\ndeque.pollLast(); // O(1)\n\n// ✅ Removing while iterating\nIterator iter = linkedList.iterator();\nwhile (iter.hasNext()) {\n if (shouldRemove(iter.next())) {\n iter.remove(); // O(1) in LinkedList\n }\n}\n\n// ✅ Implementing LRU cache (move to front)\nlinkedList.remove(item); // O(1) if have node ref\nlinkedList.addFirst(item); // O(1)\n```\n\n---\n\n## 🔄 Common Operations Comparison\n\n### Adding Elements\n\n```java\n// Adding at end - Both fast\narrayList.add(\"item\"); // O(1) amortized\nlinkedList.add(\"item\"); // O(1)\n\n// Adding at front - LinkedList wins\narrayList.add(0, \"item\"); // O(n) - shift all elements!\nlinkedList.addFirst(\"item\"); // O(1)\n\n// Adding in middle - ArrayList often faster due to cache\narrayList.add(500, \"item\"); // O(n) but memory sequential\nlinkedList.add(500, \"item\"); // O(n) traverse + O(1) insert\n```\n\n### Removing Elements\n\n```java\n// Remove from front\narrayList.remove(0); // O(n) - shift all\nlinkedList.removeFirst(); // O(1)\n\n// Remove from end\narrayList.remove(arrayList.size() - 1); // O(1)\nlinkedList.removeLast(); // O(1)\n\n// Remove by value (first occurrence)\narrayList.remove(\"item\"); // O(n) find + O(n) shift\nlinkedList.remove(\"item\"); // O(n) find + O(1) unlink\n```\n\n### Iteration Performance\n\n```java\n// Indexed loop - ArrayList wins\n// ArrayList: O(n) total\nfor (int i = 0; i < list.size(); i++) {\n list.get(i); // O(1)\n}\n// LinkedList: O(n²) total!\nfor (int i = 0; i < list.size(); i++) {\n list.get(i); // O(n) each time!\n}\n\n// Iterator/foreach - Both O(n)\nfor (String s : list) {\n // Both traverse sequentially\n}\n\n// ✅ Always use iterator for LinkedList\nIterator iter = linkedList.iterator();\nwhile (iter.hasNext()) {\n String s = iter.next(); // O(1)\n}\n```\n\n---\n\n## 🧩 Real-World Patterns\n\n### Pattern 1: Stack\n\n```java\n// ArrayList is better for stack\nDeque stack = new ArrayDeque<>(); // Best choice\n// ArrayList stack works too (push/pop at end)\n\n// Not LinkedList - unnecessary overhead for LIFO\n```\n\n### Pattern 2: Queue\n\n```java\n// LinkedList works for queue\nQueue queue = new LinkedList<>();\nqueue.offer(task); // O(1) at tail\nqueue.poll(); // O(1) at head\n\n// But ArrayDeque is usually better\nQueue queue = new ArrayDeque<>(); // Faster, less memory\n```\n\n### Pattern 3: Frequent Middle Insertions\n\n```java\n// Neither is great for random middle insertions\n// Consider:\n// - TreeList (Apache Commons) - O(log n) insert\n// - Skip List - O(log n) insert\n// - Balanced tree structure\n```\n\n### Pattern 4: LRU Cache\n\n```java\n// LinkedHashMap is usually best\n// But if building from scratch, LinkedList + HashMap:\nclass LRUCache {\n private final Map> map = new HashMap<>();\n private final LinkedList> list = new LinkedList<>();\n\n public V get(K key) {\n Node node = map.get(key);\n if (node != null) {\n list.remove(node); // O(1) with node reference\n list.addFirst(node); // O(1)\n return node.value;\n }\n return null;\n }\n}\n```\n\n---\n\n## ⚠️ Common Pitfalls\n\n### 1. Indexed Loop on LinkedList\n\n```java\n// ❌ O(n²) - never do this!\nfor (int i = 0; i < linkedList.size(); i++) {\n linkedList.get(i); // O(n) each time\n}\n\n// ✅ Use iterator - O(n)\nfor (String item : linkedList) {\n // Process item\n}\n```\n\n### 2. Using LinkedList as General-Purpose List\n\n```java\n// ❌ LinkedList for everything\nList users = new LinkedList<>(); // Usually wrong\n\n// ✅ ArrayList is almost always better\nList users = new ArrayList<>();\n\n// Only LinkedList for specific patterns (queue, deque)\n```\n\n### 3. Not Pre-sizing ArrayList\n\n```java\n// ❌ Many resizes\nList items = new ArrayList<>();\nfor (int i = 0; i < 10000; i++) {\n items.add(loadItem(i)); // Multiple resizes\n}\n\n// ✅ Pre-size when you know approximate count\nList items = new ArrayList<>(10000);\n```\n\n### 4. Assuming add() is Always Fast\n\n```java\n// ArrayList add(index, element) is O(n)!\nfor (int i = 0; i < 10000; i++) {\n arrayList.add(0, item); // O(n) × n = O(n²)\n}\n\n// If adding at front, use LinkedList or ArrayDeque\n```\n\n---\n\n## 🎯 Interview Practice\n\nTest your ArrayList vs LinkedList knowledge with 10 curated interview questions:\n\n```visualizer-listcomparison-interview\nshowControls: true\n```\n\n---\n\n## 🎤 Interview Tips\n\n**Q: When would you use LinkedList over ArrayList?**\n\n> LinkedList when you need O(1) insertions/removals at the front (queue operations), or when using Iterator.remove() frequently. In practice, ArrayList is better 95% of the time due to cache locality and lower memory overhead.\n\n**Q: Why is ArrayList faster for iteration even though both are O(n)?**\n\n> ArrayList stores elements contiguously in memory, benefiting from CPU cache prefetching. LinkedList nodes are scattered in memory, causing cache misses on every access.\n\n**Q: What's the memory overhead of each?**\n\n> ArrayList: ~4-8 bytes per reference (just the array slot). LinkedList: ~24 bytes per node (object header, prev pointer, next pointer, data reference). For large lists, ArrayList uses 3-6x less memory.\n\n**Q: Should you ever use LinkedList for a queue?**\n\n> ArrayDeque is usually better for queues - it's faster and uses less memory. LinkedList is only useful if you need null elements (ArrayDeque doesn't allow null) or need to remove elements from the middle during iteration.\n\n---\n\n## 📚 Series Navigation\n\n**Previous**: [Part 23: Raft Consensus](dsa-cheatsheet-part-23-raft)\n\n**Series Complete!** Return to [Part 0: Overview](dsa-cheatsheet-part-0-overview)\n\n---\n\n**Visualizer**: `ListComparisonVisualizer` from `@tomaszjarosz/react-visualizers`\n","2026-06-10T07:19:25.796484Z","2026-06-10T07:19:25.796774Z",24,{"_33":57,"_104":59,"_105":106,"_107":108,"_109":-5,"_110":-5,"_111":-5,"_112":-5,"_113":-5},{"_33":100,"_74":61,"_37":101,"_77":102,"_103":-5},[126,127,128,129],{"_33":64,"_74":75,"_37":76,"_77":78,"_79":24},{"_33":136,"_74":137,"_37":138},{"_33":94,"_74":95,"_37":96},{"_33":133,"_74":134,"_37":135},{"_33":130,"_74":131,"_37":132},118,"Performance","performance",254,"Linkedlist","linkedlist",250,"Arraylist","arraylist"]