How Data Structures Affect Programming Performance

𝗬𝗼𝘂𝗿 𝗱𝗮𝘁𝗮 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝗰𝗵𝗼𝗶𝗰𝗲𝘀 𝗮𝗿𝗲 𝗸𝗶𝗹𝗹𝗶𝗻𝗴 .𝗡𝗘𝗧 𝗮𝗽𝗽 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 I optimized 12 enterprise ASP .NET Core systems and found the same problem every time. Most developers spend hours tuning queries, adding indices, and implementing caching. But they ignore the most critical performance factor: data structure selection. The wrong collections can make your app 10x slower than needed. Here's what to use based on your operation: 1. Finding items by key List<T>.Find() → O(n) → Terrible at scale Dictionary<K,V> → O(1) → Lightning fast 2. Frequently inserting at the beginning List<T>.Insert(0, item) → O(n) → Shifts all elements LinkedList<T> → O(1) → No shifting needed 3. Collection with unique items List<T> + Contains check → O(n) per add HashSet<T> → O(1) → Instant uniqueness checks 4. Ordered data with binary search List<T> + Sort → O(n log n) + manual search code SortedDictionary<K,V> → Built-in ordering + O(log n) lookup 5. API response caching Static Dictionary → Memory leaks and stale data MemoryCache with expiration → Automatic cleanup I've seen teams waste days on complex optimizations when the right data structure would fix everything. What is the biggest performance problem you solved by picking a correct data structure? — ♻️ Repost to help others optimize their .NET apps ➕ Follow me ( Anton Martyniuk ) for more —

✨ 𝗩𝗮𝗹𝗴𝗿𝗶𝗻𝗱 𝗮𝗻𝗱 𝗖𝗮𝗰𝗵𝗲𝗴𝗿𝗶𝗻𝗱 – 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗛𝗼𝘄 𝗬𝗼𝘂𝗿 𝗖𝗼𝗱𝗲 𝗥𝗲𝗮𝗹𝗹𝘆 𝗛𝗶𝘁𝘀 𝘁𝗵𝗲 𝗖𝗮𝗰𝗵𝗲! Last week, we ran a poll, and the winning topic was about Valgrind/Cachegrind — an excellent choice! This is one of those topics that looks simple, yet hides a massive impact on performance: even small choices in data structures can make your code hundreds of times faster or slower depending on how it interacts with the cache hierarchy. So, what do all those Cachegrind numbers really mean? ⚡ 𝗜 𝗿𝗲𝗳𝘀 → Total instructions executed by the CPU. • 𝗜𝟭 𝗺𝗶𝘀𝘀𝗲𝘀 → Instructions not found in the fastest L1 cache. • 𝗟𝗟𝗶 𝗺𝗶𝘀𝘀𝗲𝘀 → Instructions not found in L1 or L2, had to fetch from L3 or RAM. ⚙️ 𝗗 𝗿𝗲𝗳𝘀 → Total accesses to data (reads and writes). • 𝗗𝟭 𝗺𝗶𝘀𝘀𝗲𝘀 → Data not in L1, had to go to L2/L3. • 𝗟𝗟𝗱 𝗺𝗶𝘀𝘀𝗲𝘀 → Data not in L1 or L2, had to fetch from L3 or RAM. 🌐 𝗟𝗟 𝗿𝗲𝗳𝘀 → Total accesses reaching the last-level cache (L3). • 𝗟𝗟 𝗺𝗶𝘀𝘀𝗲𝘀 → Accesses that missed even L3, going to main memory. 💡 In short: CPU first tries L1 → L2 → L3 → RAM. • Contiguous structures like vector are cache-friendly → fewer misses → faster. • Pointer-heavy structures like list are scattered → more misses → slower. To see this in action, we prepared two examples with ~1 million elements searching for the last element: 𝗩𝗲𝗰𝘁𝗼𝗿 (optimized `-O3`): • Time: 𝟲.𝟵 μ𝘀 • Instructions executed: ~𝟴.𝟵𝟴 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 • Data accesses: ~𝟱.𝟵𝟮 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 • L1 data cache misses: 𝟭𝟰𝟳𝗸 • Last-level cache misses: 𝟳𝟰𝗸 𝗟𝗶𝘀𝘁 (optimized `-O3`): • Time: 𝟭𝟵.𝟳 μ𝘀 (~𝟮.𝟴𝟱× 𝘀𝗹𝗼𝘄𝗲𝗿) • Instructions executed: ~𝟯𝟴𝟬 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 (~𝟰𝟮× 𝗺𝗼𝗿𝗲) • Data accesses: ~𝟭𝟯𝟭 𝗺𝗶𝗹𝗹𝗶𝗼𝗻 (~𝟮𝟮× 𝗺𝗼𝗿𝗲) • L1 data cache misses: 𝟮.𝟭𝟭𝗠 (~𝟭𝟰× 𝗺𝗼𝗿𝗲) • Last-level cache misses: 𝟮.𝟭𝟭𝗠 (~𝟮𝟴× 𝗺𝗼𝗿𝗲) 💡 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆: Even with compiler optimizations, vector remains far more cache-friendly than list. Contiguous memory layout wins. 🛠 𝗖𝗼𝗺𝗺𝗮𝗻𝗱𝘀 𝘂𝘀𝗲𝗱: g++ -std=c++23 -O3 -g vector_find.cpp -o vector_find_O3 g++ -std=c++23 -O3 -g list_find.cpp -o list_find_O3 valgrind --tool=cachegrind --cache-sim=yes ./vector_find_O3 valgrind --tool=cachegrind --cache-sim=yes ./list_find_O3 Below are the 𝗿𝗲𝘀𝘂𝗹𝘁𝘀 𝗮𝗻𝗱 𝗰𝗼𝗱𝗲 for both examples. 💬 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻 𝗳𝗼𝗿 𝘆𝗼𝘂: Did you know how much your choice of data structures can affect cache performance? Have you ever used tools like Valgrind/Cachegrind to analyze your code? Share your experience in the comments! C++ MasterClass #ModernCpp #CppMasterClass #CppTips #CppCommunity #Performance #LowLevelProgramming #SystemsProgramming #CppBestPractices #TechExplained #ComputerArchitecture #WriteBetterCode #CacheOptimization #MemoryHierarchy #HighPerformanceComputing #Multithreading #Concurrency

Pop quiz: you're building a text editor and need to pick a data structure to represent the text. What do you choose? If you said "string", keep reading. String is the obvious choice for representing a character array, but the way it's stored (a contiguous block of memory) is terrible for mutable performance if the length is long. Just look at its big O characteristics: • concatenation: O(n + m) • insertion: O(n) • deletion: O(n) • substring: O(m) (n = original string length, m = new string length) A text editor that models file content as strings would be SUPER slow for even moderately sized files. This is what ropes are for. Instead of storing the entire string as a block of memory, a rope represents the string as a balanced binary tree where leaves contain short substrings and parent nodes contain the summed lengths of the *left* subtree. ⚡ Balanced binary trees are MUCH faster for mutability: • concatenation: O(log n + log m) • insertion: O(log n) • deletion: O(log n) • substring: O(log n + log m) By storing left-subtree substring lengths, ropes can efficiently seek around the tree and mostly get log n performance. And that's why your editor responds quickly when you modify the middle of a large file.

While solving a bitmask Dynamic Programming problem on LeetCode, I encountered a TLE (Time Limit Exceeded) error in my Java solution. Interestingly, the same logic worked perfectly in C++. 🤔 After some digging, I discovered the root cause: I was using Integer[] for memoization instead of int[]. 🔍 Why does this matter? Using Integer[] introduces object overhead: Integer is a wrapper class — meaning each element in the array is an object. Every access involves boxing (int → Integer) and unboxing (Integer → int). In bitmask DP problems (where state space is 2^n, and recursive calls are deep and frequent), this overhead becomes costly. I replaced Integer[] with a simple int[] and used -1 to denote unvisited states. 🚀 Result? It passed! ✅ TLE submission (Integer[]): 🔗 https://lnkd.in/gAm8TYGd ✅ Accepted submission (int[]): 🔗 https://lnkd.in/ginWESXg 📌 Takeaway: For performance-critical problems like bitmask DP, always prefer int[] over Integer[] in Java to avoid unnecessary overhead. #Java #DynamicProgramming #LeetCode #Coding #DataStructures #Algorithms #BitmaskDP #PerformanceMatters #LearningInPublic

Time Complexity Cheatsheet for Every Engineer When you write an algorithm, its speed and efficiency depend on how well you understand time and space complexity. That’s why mastering Big O notation is a crucial skill for every developer, especially when optimizing performance and preparing for technical interviews. Here’s a quick breakdown 👇 - Time Complexity tells you how your algorithm’s runtime grows as the input size increases. - Space Complexity measures how much additional memory is required during execution. This cheatsheet summarizes the most common algorithms and their complexities, from searching and sorting to graph traversal and dynamic programming. 🔹 Searching Algorithms • Linear Search: O(n) — Simple, but slow for large datasets. • Binary Search: O(log n) — Fast but requires sorted data. 🔹 Sorting Algorithms • Bubble / Selection / Insertion Sort: O(n²) — Easy to understand but inefficient. • Merge / Quick / Heap Sort: O(n log n) — Efficient, scalable sorting approaches. • Counting / Radix / Bucket Sort: O(n + k) — Great for limited integer or uniform data. 🔹 Data Structures • Hash Tables: O(1) average for search, insert, delete — collisions can degrade to O(n). • Binary Search Trees (BST): O(log n) on average, O(n) if unbalanced. • Balanced BST (AVL/Red-Black): Guarantees O(log n) operations. • Stack / Queue: Constant time for push, pop, enqueue, dequeue. 🔹 Graph & DP Algorithms • Graph Traversal (BFS/DFS): O(V + E) — V = vertices, E = edges. • Dijkstra’s Algorithm: O(V²) or O(E + V log V) — optimized with priority queues. • Dynamic Programming: O(n²) to O(2ⁿ) — depends on problem type and overlap. Pro Tip: Don’t just memorize complexities - understand the trade-offs. Each algorithm shines in specific scenarios: • Small datasets? Use simpler sorts. • Large systems? Focus on O(log n) or O(n log n). • Real-time systems? Optimize for space and constant-time operations. Mastering these fundamentals will not only make you a better coder — it will make you a better problem solver. Follow Gaurav Mehta for more tech insights and updates.