"Day 6: Java LinkedList and Merge Sort Challenge"

#100DaysOfCode – Day 77 Delete in a Doubly Linked List Problem: Given a doubly linked list and an integer x, remove the node at position x (1-indexed) and return the head of the updated list. Example: Input: 1 <-> 2 <-> 3 <-> 4, x = 3 Output: 1 <-> 2 <-> 4 My Approach: 1️⃣ Handled edge cases deleting the head or an empty list. 2️⃣ Traversed to the node at position x. 3️⃣ Updated both prev and next pointers to unlink the node cleanly. Time Complexity: O(N) Space Complexity: O(1) Understanding pointer manipulation in linked lists builds the foundation for mastering advanced data structures. Every prev and next link matters! #100DaysOfCode #Java #ProblemSolving #DSA #GeeksforGeeks #LinkedList #Pointers #TakeUForward #CodeNewbie #CodingJourney

Day 46/100 Problem Statement : You are given an integer array target. You have an integer array initial of the same size as target with all elements initially zeros. In one operation you can choose any subarray from initial and increment each value by one. Return the minimum number of operations to form a target array from initial. The test cases are generated so that the answer fits in a 32-bit integer. Input: target = [1,2,3,2,1] Output: 3 Solution : https://lnkd.in/gsXFvUr3  public int minNumberOperations(int[] target) {         final int n=target.length;         int ans=target[0];         for(int i=1; i<n; i++)             ans+=Math.max(target[i]-target[i-1], 0);         return ans;     } #100DaysDSA #100DaysOfCode #Java #Leetcode #Neetcode #Neetcode250 #TUF

📌 LeetCode Day 57 — #107. Binary Tree Level Order Traversal II Problem Description: Given the root of a binary tree, return the bottom-up level order traversal of its nodes' values. That means you need to traverse the tree level by level from left to right, but from the bottom level up to the root. Approach: Use a Queue (BFS): Perform a standard level order traversal using a queue. Store Each Level: For each level, store the node values in a temporary list. Insert at Beginning: Instead of appending levels at the end, insert each level at index 0 to reverse the order. Return Result: The final list represents the bottom-up traversal. Complexity Analysis: Time Complexity: O(n) — every node is visited once. Space Complexity: O(n) — queue and result storage for all nodes. Hashtags: #BinaryTree #BFS #LogicBuilding #LeetCode100Days #Day57 #Java #ProblemSolving

📅 Day 57 of #160DaysofDSA 💡 Problem:Count distinct elements in every window Given an integer array arr[] and a number k. Find the count of distinct elements in every window of size k in the array. 🔍 Approach (Two Pointers + HashMap) We use the sliding window technique with two pointers left and right. ▪️ As we move right, we add elements to the window and update their frequency in a HashMap. ▪️ Once the window reaches size k , we record the count of distinct elements → which is simply the size of the HashMap. ▪️ Then we slide the window by incrementing left and removing its frequency from the map. Time Complexity : O(n) Space Complexity : O(k) #DSA #Java #GFG #SlidingWindow #TwoPointers #Hashmap #geekforgeeks #Day57

#100DaysOfCode – Day 73 String Manipulation Problem: Valid Anagram (LeetCode #242) Task: Given two strings s and t, return true if t is an anagram of s, otherwise false. Example: Input: s = "anagram", t = "nagaram" → Output: true Input: s = "rat", t = "car" → Output: false My Approach:- Method 1 – Sorting Converted both strings into character arrays. Sorted them and compared if equal, they’re anagrams! Time Complexity: O(n log n) Method 2 – Frequency Count (Optimized) Counted occurrences of each character in s and t. If every count matches, it’s a valid anagram. Time Complexity: O(n) | Space: O(1) String problems may look simple, but optimizing from sorting to counting makes a huge difference. Small logic shifts often lead to big performance gains! #100DaysOfCode #Java #ProblemSolving #LeetCode #CodingJourney #takeUforward #DataStructures #Algorithms #StringManipulation #GeeksForGeeks #CodeNewbie

🗓 Day 7 / 100 – #100DaysOfLeetCode 🔢 Problem 2536: Increment Submatrices by One Today’s challenge involved processing multiple submatrix increment queries on an n x n matrix, initially filled with zeros. 🧠 My Approach Instead of updating every cell inside each submatrix (which would be too slow for up to 10⁴ queries), I used a row-wise difference array technique. For each query [r1, c1, r2, c2]: Increment prefix[row][c1] Decrement prefix[row][c2+1] (if within bounds) This allows efficient marking of increments. Later, prefix-summing each row reconstructs the final matrix. ⏱ Time Complexity O(q × n) where q = number of queries (We touch r2 - r1 + 1 rows per query) 💾 Space Complexity O(n²) for the prefix matrix #LeetCode #Java #ProblemSolving #CodingChallenge #100DaysOfCode #DSA #LearningEveryday

@Lazy Loading & JdbcTemplate @Lazy delays bean creation until the bean is actually required. This improves startup time and reduces unnecessary initialization. JdbcTemplate simplifies database operations by handling boilerplate code. It manages connections, statements, and exceptions automatically. Together they optimize performance and reduce repetitive code. #SpringFramework #Java #SoftwareEngineering #BackendDevelopment

💻 Day 03/10 of Linked List Series: Inserting a Node at the Beginning of a Linked List Let’s understand how we can add a new node at the start of a linked list 👇 ⚙️ Algorithm: Insert at Beginning Create a new node with the given data (for example, 'A'). Set the next pointer of this new node to point to the current head of the list. Now, make this new node the new head of the linked list. 💡 In simple terms: you’re placing a new link before the first link in the chain. 🧩 Example Explanation: Initial list: B → C → D We want to insert 'A' at the beginning. Steps: Create a new node 'A'. Point 'A' → 'B'. Return node 'A'. ✅ Final list becomes: A → B → C → D ✨ This operation is one of the most common and easiest insert operations in linked lists — it just needs a few pointer adjustments! 📚 Stay tuned for the next part in this #LinkedListSeries! Follow my Brand 👉 #CodeWithLakkojuEswaraSai #CodeWithLakkojuEswaraSai_LinkedList #DSA #Java #10000coders

#Day-56) LeetCode #3217: Delete Nodes From Linked List Present in Array Today’s medium-level challenge was a classic linked list cleanup with a twist—removing nodes whose values appear in a separate array. I leaned on a HashSet for O(1) lookups and handled edge cases like head deletion with precision. 🔧 Problem: Given an array `nums` and a linked list `head`, remove all nodes from the list whose values are in `nums`. 💡 Approach: - Store `nums` in a HashSet for fast lookup. - Traverse the list using `prev` and `curr` pointers. - Carefully handle head node removal. - Return the updated head. 📌 Language: Java   📈 Time Complexity: O(n + m)   📦 Space Complexity: O(m) #LeetCode #Java #LinkedList #DSA #CodingChallenge #ProblemSolving #PranshuCodes Aditya Gupta Arjit Singh

#100DaysOfCode – Day 76 Insert a Node in a Doubly Linked List Problem: Given a position p and a value x, insert a new node with data x after the p-th node (0-based indexing) in a doubly linked list. Example: Input: p = 2, x = 6 Output: 2 <-> 4 <-> 5 <-> 6 My Approach: Traversed to the p-th node using a simple loop. Updated pointers of the prev and next nodes carefully to maintain bidirectional linkage. Handled edge cases for insertion at the end of the list. Time Complexity: O(N) Space Complexity: O(1) Understanding pointer manipulation in linked lists builds a strong base for advanced data structure problems like deletion, reversal, and flattening of linked lists. #takeUforward #100DaysOfCode #DSA #Java #ProblemSolving #GeeksForGeeks #LinkedList #Pointers #CodingChallenge #CodeNewbie #LearningEveryday