Data Structure & Algorithms
  • 🖌️Unlocking the Power of Algorithms with C#
  • Data Structure
    • Data Structure
    • Big O
    • Array
    • Linked Lists
    • Stacks
    • Queues
    • Hash Tables
    • Trees
    • Graphs
    • Heap Sort
    • ParkingLot Algorithm
    • LRU cache
    • Priority Queue
  • Algorithms
    • Algorithm
    • Recursion
    • Sorting
    • Searching
    • Dynamic Programming
  • Problems
    • Array
      • Two Sum
      • Two Sum II - Input Array Is Sorted
      • Contains Duplicate
      • Maximum Subarray
      • House Robber
      • Move Zeroes
      • Rotate Array
      • Plus One
      • Find number of subarrays with even length
      • Find number of subarrays with even sum
      • Find Missing Element
      • Reduce Array Size to The Half
      • Remove Duplicates
      • Merge Sorted Arrays
      • Arrays Intersection
      • 3Sum
      • Trapping Rain Water
      • Maximum sum of a subarray
      • Longest Subarray
      • Subarray Sum Equals K
      • Container With Most Water
      • Missing Number
      • Roman to Integer
      • First Missing Positive
      • Unique Integers That Sum Up To 0
      • Integer to Roman
      • Flatten
    • String
      • Check if two strings are permutation of each other
      • String Compression
      • Palindrome Permutation
      • Determine if a string has all Unique Characters
      • One Away
      • Longest Substring Without Repeating Characters
      • Valid Palindrome
      • Valid Palindrome II
      • Backspace String Compare
      • First Unique Character in a String
      • Is Subsequence
      • URLify a given string
      • String has same characters at same position
      • Number of Ways to Split a String
      • Check whether two Strings are anagram of each other
      • Print last `n` lines of a big file or big string.
      • Multiply Strings
    • Matrix
      • Search a 2D Matrix
      • Search a 2D Matrix II
      • Rotate Matrix
      • Spiral Matrix
      • Set Matrix Zeroes
    • Bit Manipulation
      • Sum of Two Integers
      • Reverse Number
      • Reverse Number II
      • Binary Bits Count
      • Binary Bits Count II
    • Stack
      • Valid Parentheses
      • Balance or not expression
      • Decode String
    • Tree
      • Binary Tree Inorder Traversal
      • Binary Tree Preorder Traversal
      • Binary Tree Postorder Traversal
      • Binary Tree Level Order Traversal
      • Binary Tree Return All Root-To-Leaf Paths
      • Binary Tree Height-Balanced
      • Valid Binary Search Tree
      • Binary Tree Sum of all left leaves.
    • Linked List
      • Linked List Delete Middle Node
      • Merge Sorted Linked List
      • Reverse Linked List
      • Remove Duplicates from Sorted List
      • Remove Duplicates from Unsorted List
      • Linked List Cycle
    • Graph
      • The Number Of Islands
      • Number of Closed Islands
      • Max Area of Island
      • Rotting Oranges
      • Number of Provinces
      • Course Schedule
      • Surrounded Regions
      • Snakes and Ladders
      • Widest Path Without Trees
      • Knight Probability in Chessboard
      • Possible moves of knight
      • Check Knight Tour Configuration
      • Steps by Knight
      • Network Delay Time
    • Greedy
      • Best Time to Buy and Sell Stock
      • Best Time to Buy and Sell Stock II
      • Smallest Subset Array
      • Jump Game
    • Backtracking
      • Towers of Hanoi
      • Subsets
      • Combination Sum
      • Sudoku Solver
      • Word Search
    • Heap
      • Kth Largest Element in an Array
      • Top K Frequent Elements
    • Sorting
      • Order Colors String
    • Recursion
      • Number To Text
      • Divide Number
Powered by GitBook
On this page
  1. Problems

Array

We can use following major approaches to solve array related problem:

  1. Iterative Approach: This is a straightforward method where you loop over the elements in the array one by one, performing some operation on each element. It’s often used when you need to process each element in the array individually or when the order of processing doesn’t matter.

  2. Two-Pointer Approach: This technique involves maintaining two pointers into the array and moving them to solve the problem. The pointers can either move in the same direction (e.g., in a sliding window approach) or in opposite directions (e.g., when searching for a pair of elements that sum to a target value). This approach is often used when the problem involves pairs of elements or a subarray of elements.

  3. Sliding Window: This is a variant of the two-pointer approach where the pointers represent the start and end of a “window” into the array. The window “slides” over the array by moving the pointers. This approach is often used when the problem involves a subarray of elements and has a condition involving the sum or product of the elements in the subarray.

  4. Dynamic Sliding Window: This is a variant of the sliding window approach where the size of the window can change dynamically based on certain conditions. For example, you might expand the window when the sum of the elements in the window is less than a target value and shrink the window when the sum is greater than the target.

  5. Hashing: This technique involves using a hash table (like a dictionary in C#) to store elements of the array for quick lookup. It’s often used when you need to find if an array contains a certain element or when you need to count the occurrences of elements.

  6. Dynamic Programming: This is a method for solving complex problems by breaking them down into simpler subproblems and solving each subproblem only once, storing their results to avoid duplicate work. It’s often used when the problem involves making a sequence of decisions or when the problem can be broken down into overlapping subproblems.

  7. Recursion: This involves breaking down the problem into smaller subproblems that are similar to the original problem. This approach is useful for problems that have a recursive structure.

Each of these techniques has its own strengths and is suited to different types of problems. The key to choosing the right technique is understanding the nature of the problem and the properties of the array you’re working with.

PreviousDynamic ProgrammingNextTwo Sum

Last updated 1 year ago