List Method in C#

1. Add(T item)

Adds a single element at the end of the list. If the internal array has enough capacity, the item is simply placed at the next index. If not, the list automatically resizes typically doubling its capacity.

public void Add(T item);

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> languages = new List<string>();
        languages.Add("C#");
        languages.Add("Java");
        languages.Add("Python");
        foreach (var lang in languages)
            Console.WriteLine(lang);
    }
}

C#
Java
Python

Time & Space Complexity

3. Insert(int index, T item)

Inserts an element at a specific position in the list. All elements after the given index are shifted one position to the right.

public void Insert(int index, T item);

Time & Space Complexity

• Avoid inserting frequently in the middle or start it causes shifting.
• For frequent insertions, consider using LinkedList<T> instead.

4. InsertRange(int index, IEnumerable<T> collection)

The InsertRange method allows you to insert multiple elements into a list starting at a specific index. All elements at and after the specified index are shifted forward to make space for the new elements.

public void InsertRange(int index, IEnumerable<T> collection);

Time & Space Complexity

Note :- InsertRange is efficient for inserting multiple elements at once compared to inserting them individually in a loop.

5. Clear()

The Clear() method removes all elements from a list and resets its Count to zero. It does not reduce the list’s capacity. To free unused memory, you can use TrimExcess() after clearing.

public void Clear();

Time & Space Complexity

• Clear() removes references to objects, allowing them to be garbage collected.
• The capacity of the list remains unchanged. To reduce memory usage, call TrimExcess().

12. Contains(T item)

The Contains() method checks if a specific item exists in a list. Returns true if the item is found, otherwise false if the item is not present.

public bool Contains(T item);

Time & Space Complexity

• Uses EqualityComparer<T>.Default to check equality.
• Best suited for small or unsorted lists.
• For large or frequently searched lists, consider using a HashSet<T> for faster lookups.

13. Exists(Predicate<T> match)

The Exists() method checks whether any element in the list satisfies a given condition (predicate). Returns true if at least one element matches the condition, otherwise returns false if no elements match.

public bool Exists(Predicate<T> match);

List<int> numbers = new List<int>() { 1, 3, 5, 7 };
// Check if any number is even
bool hasEven = numbers.Exists(n => n % 2 == 0);
Console.WriteLine($"Has Even Number? {hasEven}");

Time & Space Complexity

• Ideal for predicate-based searches without manually iterating through the list.
• Stops scanning after the first match, making it more efficient than a full search when a match exists.
• Commonly used with lambda expressions for concise and readable code.

14. Find(Predicate<T> match)

The Find() method returns the first element in the list that satisfies a given condition (predicate). If no element matches, it returns default (null for reference types, 0 for numeric types etc.).

public T? Find(Predicate<T> match);

Time & Space Complexity

• Returns only the first match.
• Use FindAll() if you need all matching elements.
• Supports lambda expressions or predicates, making it concise for conditional searches.

15. FindAll(Predicate<T> match)

The FindAll() method returns a new list containing all elements that satisfy the specified condition (predicate). The original list remains unchanged, making it safe for filtering without modifying data.

public List<T> FindAll(Predicate<T> match);

Time & Space Complexity

• Returns a new List<T>, leaving the original list intact.
• Ideal for filtering elements based on conditions.
• Works well with lambda expressions or predicates for clean, readable code.

16. FindIndex()

The FindIndex() method returns the index of the first element in a list that satisfies a specified condition (predicate). Overloads allow you to specify a starting index and/or a range of elements to search. Returns -1 if no element matches the condition.

public int FindIndex(Predicate<T> match);
public int FindIndex(int startIndex, Predicate<T> match);
public int FindIndex(int startIndex, int count, Predicate<T> match);

Time & Space Complexity

• Useful when you want to modify, insert or remove elements by index.
• Stops searching after the first match, making it efficient for early matches.
• Works well with lambda expressions for concise code.

17. FindLast() and FindLastIndex()

• FindLast(): Returns the last element in the list that satisfies a given predicate.
• FindLastIndex(): Returns the index of the last element that matches the predicate.
• Both methods scan the list from the end towards the beginning.
• Returns default (null for reference types) or -1 if no match is found.

public T? FindLast(Predicate<T> match);

public int FindLastIndex(Predicate<T> match);
public int FindLastIndex(int startIndex, Predicate<T> match);
public int FindLastIndex(int startIndex, int count, Predicate<T> match);

Time & Space Complexity

• Scans from end to start, making it ideal for finding the latest occurrence.
• Useful when you need the last matching element or its index without reversing the list.
• Supports lambda expressions or predicates for concise, readable code.

18. TrueForAll(Predicate<T> match)

The TrueForAll() method checks whether all elements in a list satisfy a specified condition (predicate). Returns true only if every element matches the condition, otherwise returns false if any element fails the condition.

public bool TrueForAll(Predicate<T> match);

Time & Space Complexity

• Stops scanning as soon as one element fails the predicate, making it efficient for validation.
• Useful for data validation, filtering and ensuring all items meet a condition.
• Works perfectly with lambda expressions for concise, readable code.

19. Sort()

The Sort() method sorts the elements of a List<T> in ascending order by default. Overloads allow custom comparisons, partial sorting and using custom comparers. Internally, it uses QuickSort/IntroSort for efficient sorting.

public void Sort(); // Default sort using IComparable<T>
public void Sort(Comparison<T> comparison); // Custom comparison
public void Sort(IComparer<T>? comparer); // Custom comparer
public void Sort(int index, int count, IComparer<T>? comparer); // Partial sort

class FirstCharComparer : IComparer<string>
{
    public int Compare(string? x, string? y)
    {
        if (x == null || y == null) return 0;
        return x[0].CompareTo(y[0]);
    }
}

-----------------------------------------------------------------------------------------

// Sample list
List<string> fruits = new List<string>() { "Banana", "Apple", "Cherry", "Mango" };

// 1. Default Sort (IComparable<T>) — Ascending alphabetical
fruits.Sort();
Console.WriteLine("Default Sort: " + string.Join(", ", fruits));
// Output: Apple, Banana, Cherry, Mango

// Reset list
fruits = new List<string>() { "Banana", "Apple", "Cherry", "Mango" };

// 2. Custom Comparison — Sort by descending length
fruits.Sort((a, b) => b.Length.CompareTo(a.Length));
Console.WriteLine("Custom Comparison (by length descending): " + string.Join(", ", fruits));
// Output: Banana, Cherry, Mango, Apple

// Reset list
fruits = new List<string>() { "Banana", "Apple", "Cherry", "Mango" };

// 3. Custom IComparer — Sort by first character
fruits.Sort(new FirstCharComparer());
Console.WriteLine("Custom IComparer (first char ascending): " + string.Join(", ", fruits));
// Output: Apple, Banana, Cherry, Mango

// Reset list
fruits = new List<string>() { "Banana", "Apple", "Cherry", "Mango" };

// 4. Partial Sort — Sort first 3 elements alphabetically
fruits.Sort(0, 3, null); // null uses default comparer
Console.WriteLine("Partial Sort (first 3 elements): " + string.Join(", ", fruits));
// Output: Apple, Banana, Cherry, Mango (only first 3 sorted)

Time & Space Complexity

• Use Comparison<T> or IComparer<T> for custom sorting logic.
• Partial sorting is helpful when you need to sort only a subset of the list.
• Efficient for both small and large lists due to hybrid sorting algorithms.

20. BinarySearch()

Searches for an element in a sorted list using binary search algorithm. Returns the index if found, otherwise a negative number indicating the complement of the insertion point.

public int BinarySearch(T item);
public int BinarySearch(T item, IComparer<T>? comparer);
public int BinarySearch(int index, int count, T item, IComparer<T>? comparer);

using System;
using System.Collections.Generic;

class DescendingComparer : IComparer<int>
{
    public int Compare(int x, int y) => y.CompareTo(x);
}

class Program
{
    static void Main()
    {
        // 1. Default BinarySearch (ascending order)
        List<int> numbers = new List<int>() { 1, 3, 5, 7, 9 };
        int index1 = numbers.BinarySearch(7);
        Console.WriteLine($"Default BinarySearch(7) -> Index: {index1}"); 
        // Output: 3
        // 2. BinarySearch with custom comparer (descending order)
        numbers.Sort(new DescendingComparer()); // sort descending: [9,7,5,3,1]
        int index2 = numbers.BinarySearch(7, new DescendingComparer());
        Console.WriteLine($"BinarySearch(7, DescendingComparer) -> Index: {index2}");
        // Output: 1
        // 3. BinarySearch in a range of the list (ascending)
        numbers.Sort(); // back to ascending: [1,3,5,7,9]
        // search in first 4 elements (indices 0,1,2,3)
        int index3 = numbers.BinarySearch(0, 4, 7, Comparer<int>.Default);
        Console.WriteLine($"BinarySearch(7, index:0, count:4) -> Index: {index3}");
        // Output: 3
        // 4. BinarySearch for element not found
        int index4 = numbers.BinarySearch(6);
        Console.WriteLine($"BinarySearch(6) -> Not found, returns: {index4}");
        // Output: -4 (insertion point = 3)
        // 5. BinarySearch with element not in range
        int index5 = numbers.BinarySearch(0, 3, 7, Comparer<int>.Default);
        Console.WriteLine($"BinarySearch(7, index:0, count:3) -> Not in range, returns: {index5}");
        // Output: -4 (insertion point = 3)
    }
}

Default BinarySearch(7) -> Index: 3
BinarySearch(7, DescendingComparer) -> Index: 1
BinarySearch(7, index:0, count:4) -> Index: 3
BinarySearch(6) -> Not found, returns: -4
BinarySearch(7, index:0, count:3) -> Not in range, returns: -4

Time & Space Complexity

• The list must be sorted before calling BinarySearch().
• Overloads allow custom comparers or search within a subset of the list.
• Ideal for fast searches in large datasets.

21. Reverse()

The Reverse() method in C# reverses the order of elements in a List<T>. You can either reverse the entire list or a specific subrange of elements. This method modifies the list in place, so no new list is created.

public void Reverse();                 // Reverses the entire list
public void Reverse(int index, int count);  // Reverses a subrange of the list

Time & Space Complexity

• Reverses the list in place, no additional memory allocation.

22. GetRange()

The GetRange() method in C# returns a new list containing a specific range of elements from an existing List<T>. The original list remains unchanged, making it ideal for extracting subsets, pagination or chunking large lists.

public List<T> GetRange(int index, int count);

Time & Space Complexity

• Creates a new list containing the selected range.
• Original list is not modified.
• Useful for: Pagination of large datasets , Extracting chunks or windows from a list , Temporary sub list operations without affecting the main list

23. ForEach(Action<T> action)

The ForEach() method in C# applies a specified action to each element in a List<T>. It offers a cleaner and more readable alternative to traditional for or foreach loops, especially for simple operations like printing or applying transformations.

public void ForEach(Action<T> action);

Time & Space Complexity

• Cannot break or return early like a traditional for loop.
• Best suited for: Applying transformations to all elements, Printing or logging list items, Simple in-place operations on each element.

24. Enumerator (GetEnumerator())

The GetEnumerator() method in C# provides an enumerator for a List<T>, allowing manual iteration over the elements using MoveNext() and Current. It is the underlying mechanism behind the foreach loop, giving you fine-grained control over iteration.

public List<T>.Enumerator GetEnumerator();

Time & Space Complexity

• Provides manual control over list iteration.
• foreach loops are syntactic sugar over GetEnumerator().
• Useful when you need to: Pause/resume iteration, Track iteration state , Avoid modifying the list while iterating.