DSA

 Nice question 👍 You’re asking:

👉 After finishing subarray problems, what’s the next topic left in arrays in DSA?

Let me give you a roadmap of array topics in DSA so you see what comes after subarrays:

🔹 Array Topics in DSA (Progression)

  1. Basics

    • Traversal, Insertion, Deletion

    • Searching (Linear, Binary Search)

  2. Prefix / Suffix Concepts

    • Prefix Sum

    • Suffix Sum

    • Difference Array

  3. Subarrays (you’ve done this)

    • Kadane’s Algorithm (max sum subarray)

    • Sliding Window (fixed & variable size)

    • Two Pointer Technique

    • Problems like Longest Increasing Subarray, Equal 0s & 1s, etc.

✅ You’re here.

  1. Subsequences vs Subarrays

    • Subarray = contiguous

    • Subsequence = not necessarily contiguous
      Example problems:

    • Longest Increasing Subsequence (LIS)

    • Maximum Sum Increasing Subsequence

  2. Sorting-based Array Problems

    • Merge Intervals

    • Inversion Count (using merge sort)

    • Sorting 0s,1s,2s (Dutch National Flag)

  3. Searching in Arrays

    • Binary Search applications

    • Search in Rotated Sorted Array

    • Peak Element

    • Median of Two Sorted Arrays

  4. Two Pointers & Sliding Window Advanced

    • Trapping Rain Water

    • Container With Most Water

    • Minimum Window Substring (array version)

    • Longest Substring/Array with K distinct elements

  5. Matrix (2D Arrays)

    • Spiral Traversal

    • Rotate Matrix

    • Transpose

    • Search in Sorted Matrix

    • Dynamic Programming problems start from here

🔹 After Arrays

Once arrays (including subarrays, subsequences, matrices) are strong, the natural next topics in DSA roadmap are:

  1. Strings

  2. Recursion & Backtracking

  3. Linked List

  4. Stack & Queue

  5. Hashing

  6. Trees (Binary Tree, BST)

  7. Graphs

  8. Dynamic Programming (heavy use of arrays)

⚡ So to answer your question directly:
👉 After subarrays, the next main parts in arrays are:

  • Subsequences (LIS, etc.)

  • Sorting & Searching problems

  • Matrix problems

Do you want me to make you a step-by-step array problem practice roadmap (easy → hard) so you can cover everything in order?


Subtopic Arrays / Strings Java Collections Best Choice
Indexing / Access O(1) random access via index ArrayList also O(1), but slight overhead Array
Fixed frequency count (e.g., only lowercase letters) Use int[26] → very fast HashMap/HashSet is slower Array
General frequency count (any chars, numbers, words) Hard (need large arrays or manual mapping) HashMap<Character,Integer> / HashMap<String,Integer> Collections
Dynamic size Needs resizing manually ArrayList grows automatically Collections
Search element exists? O(n) linear scan HashSet → O(1) lookup Collections
Sorting Arrays.sort(arr) (fast for primitives) Collections.sort(list) (good for objects) Depends
Subarray problems (sum, window) Works best with primitive arrays Collections add overhead Array
K-th largest/smallest Manual sorting required PriorityQueue → O(n log k) Collections
Palindrome / Reverse / Rotation Easy with char[] / StringBuilder Collections not useful Array/String
Duplicate removal Manual loop + extra array HashSet (1 line) Collections

Comments

Post a Comment

Popular posts from this blog

optimsed apporach

//For finding buying and seeling the stock:  class Main {     public static void main(String[] args) {         int[] price = {8, 2, 1, 5, 4, 6};         int min = Integer.MAX_VALUE;         int max = 0;         for(int i=0;i<price.length;i++){             if(price[i]<min){                 min=price[i];             }             else if(price[i]-min>max){                 max=price[i]-min;             }         }         System.out.println("Buy:"+min);                 System.out.println("sell:"+max);     } } //finiding leader in an array: // Online Java Compiler // Use this editor to write, compile and...
Read more

what i learn

  Great question, R — and I love that you're thinking critically about how indexing works in loops. Let's clarify this with precision. 🧠 Why neg[i++] Starts at Index 0 When you write neg[i++] , you're accessing the current value of i , then incrementing it. So if i = 0 , this line: combine[k++] = neg[i++]; means: Use neg[0] (the first element). Then increment i to 1. So you're not saying i++ = 1 — you're saying: "Use i = 0 now, and after this line, i becomes 1." This is called post-increment , and it's a common pattern in Java when you want to use the current index before moving to the next. 🔍 Quick Illustration int i = 0; System.out.println(neg[i++]); // prints neg[0], then i becomes 1 System.out.println(neg[i]); // now prints neg[1] So the loop starts at index 0 because arrays in Java are zero-indexed — meaning the first element is at position 0, not 1. ✅ Summary i++ means "use current i , then increment....
Read more

creative codes

 //finding An equilibrium index is a position in the array where the sum of elements to the left = sum of elements to the right . // Online Java Compiler // Use this editor to write, compile and run your Java code online class Main {     public static void main(String[] args) {         int[] arr = {3, 4, 8, -9, 20, 6};         int n = arr.length;         int sum=0;         boolean found=false;          for(int i=0; i<n;i++)  sum+=arr[i];          int left_sum=0;                    for(int i=0;i<n;i++){              int right_sum=sum-left_sum-arr[i];              if(left_sum==right_sum){                  found=true;                 ...
Read more