Array methods (Sort, Reverse, IndexOf) in C Sharp (C#)

Introduction

Array methods help you organize and find items in a list easily. Sorting arranges items, reversing flips their order, and IndexOf finds where an item is.

When you want to put a list of numbers or words in order from smallest to largest or alphabetically.

When you want to see the list backwards, like reading a list from end to start.

When you want to find the position of a specific item in a list.

Syntax

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 5, 3, 8, 1 };

        // Sort the array
        Array.Sort(numbers);

        // Reverse the array
        Array.Reverse(numbers);

        // Find index of an element
        int position = Array.IndexOf(numbers, 3);
    }
}

Array.Sort(array) changes the array to be in ascending order.

Array.Reverse(array) flips the order of elements in the array.

Examples

Works fine even if the array is empty. IndexOf returns -1 if item not found.

C Sharp (C#)

int[] emptyArray = {};
Array.Sort(emptyArray);
Array.Reverse(emptyArray);
int index = Array.IndexOf(emptyArray, 10);

Sorting or reversing a single-element array keeps it the same. IndexOf finds the element at position 0.

C Sharp (C#)

int[] singleElement = { 42 };
Array.Sort(singleElement);
Array.Reverse(singleElement);
int index = Array.IndexOf(singleElement, 42);

Shows how sorting and reversing change the order and how IndexOf finds elements at start or end.

C Sharp (C#)

int[] numbers = { 10, 20, 30, 40 };
Array.Sort(numbers); // Already sorted
Array.Reverse(numbers); // Now reversed
int indexStart = Array.IndexOf(numbers, 40); // First element after reverse
int indexEnd = Array.IndexOf(numbers, 10); // Last element after reverse

Sample Program

This program shows how to sort, reverse, and find the index of elements in an array. It prints the array before and after changes and shows what happens when searching for a missing item.

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
        int[] numbers = { 7, 2, 9, 4, 3 };

        Console.WriteLine("Original array:");
        PrintArray(numbers);

        Array.Sort(numbers);
        Console.WriteLine("\nAfter sorting:");
        PrintArray(numbers);

        Array.Reverse(numbers);
        Console.WriteLine("\nAfter reversing:");
        PrintArray(numbers);

        int searchValue = 4;
        int index = Array.IndexOf(numbers, searchValue);
        Console.WriteLine($"\nIndex of {searchValue}: {index}");

        int missingValue = 10;
        int missingIndex = Array.IndexOf(numbers, missingValue);
        Console.WriteLine($"Index of {missingValue} (not in array): {missingIndex}");
    }

    static void PrintArray(int[] array)
    {
        foreach (int number in array)
        {
            Console.Write(number + " ");
        }
        Console.WriteLine();
    }
}

Important Notes

Time complexity: Sort is O(n log n), Reverse is O(n), IndexOf is O(n).

Space complexity: These methods work in place, so they use little extra memory.

Common mistake: Forgetting that IndexOf returns -1 if the item is not found.

Use Sort when you need ordered data, Reverse when you want to flip order, and IndexOf to find positions.

Summary

Array.Sort arranges items in ascending order.

Array.Reverse flips the order of items in the array.

Array.IndexOf finds the position of an item or returns -1 if not found.

Practice

1. What does the Array.Sort method do to an array in C#?

easy

A. It reverses the order of the items.

B. It arranges the items in ascending order.

C. It finds the index of a specific item.

D. It removes duplicate items from the array.

Solution

1. Step 1: Understand Array.Sort purpose

   The Array.Sort method organizes the elements of an array in ascending order by default.

2. Step 2: Compare with other methods

   Array.Reverse flips the array, and Array.IndexOf finds an element's position, so they do different things.

3. Final Answer:

   It arranges the items in ascending order. -> Option B

4. Quick Check:

   Array.Sort = ascending order [OK]

Hint: Sort means arrange from smallest to largest [OK]

Common Mistakes:

• Confusing Sort with Reverse
• Thinking Sort finds an element's position
• Assuming Sort removes duplicates

2. Which of the following is the correct way to reverse an array named numbers in C#?

easy

A. numbers.Reverse();

B. numbers.ReverseArray();

C. Array.Sort(numbers);

D. Array.Reverse(numbers);

Solution

1. Step 1: Identify correct method call syntax

   In C#, Array.Reverse is a static method that takes the array as an argument, so Array.Reverse(numbers); is correct.

2. Step 2: Check other options

   numbers.Reverse() is a LINQ extension returning IEnumerable, not reversing in place. Array.Sort sorts, not reverses. ReverseArray() does not exist.

3. Final Answer:

   Array.Reverse(numbers); -> Option D

4. Quick Check:

   Reverse array = Array.Reverse(array) [OK]

Hint: Use Array.Reverse(array) to flip order [OK]

Common Mistakes:

• Using instance method Reverse() which doesn't reverse in place
• Confusing Sort with Reverse
• Calling non-existent methods

3. What will be the output of this C# code?

string[] fruits = {"apple", "banana", "cherry"};
Array.Sort(fruits);
Array.Reverse(fruits);
Console.WriteLine(fruits[0]);

medium

A. cherry

B. banana

C. apple

D. Runtime error

Solution

1. Step 1: Sort the array

   After Array.Sort(fruits);, the array becomes ["apple", "banana", "cherry"] (already sorted).

2. Step 2: Reverse the array

   After Array.Reverse(fruits);, the array becomes ["cherry", "banana", "apple"].

3. Step 3: Print first element

   fruits[0] is now "cherry".

4. Final Answer:

   cherry -> Option A

5. Quick Check:

   Sort then Reverse = descending order [OK]

Hint: Sort then Reverse = descending order, first item is largest [OK]

Common Mistakes:

• Assuming array stays sorted ascending
• Confusing Reverse with Sort
• Expecting runtime error due to method calls

4. The following code throws an error. What is the mistake?

int[] nums = {3, 1, 4};
nums.Sort();
Console.WriteLine(nums[0]);

medium

A. Arrays don't have a Sort() instance method.

B. The array must be reversed before sorting.

C. You must use Console.WriteLine(nums.Sort()); instead.

D. The array must be converted to a list before sorting.

Solution

1. Step 1: Identify method call error

   Arrays in C# do not have an instance method called Sort(). Sorting is done via the static method Array.Sort(array).

2. Step 2: Understand correct usage

   The correct way is Array.Sort(nums); to sort the array in place.

3. Final Answer:

   Arrays don't have a Sort() instance method. -> Option A

4. Quick Check:

   Use Array.Sort(array), not array.Sort() [OK]

Hint: Array.Sort is static; no instance Sort() method [OK]

Common Mistakes:

• Calling Sort() directly on array instance
• Confusing List.Sort() with Array.Sort()
• Trying to print Sort() return value

5. Given the array int[] values = {5, 3, 8, 3, 9};, which code snippet finds the index of the first occurrence of the number 3 and then reverses the array?

hard

A. int index = Array.FindIndex(values, 3);
Array.Sort(values);

B. int index = values.IndexOf(3);
Array.Reverse(values);

C. int index = Array.IndexOf(values, 3);
Array.Reverse(values);

D. int index = Array.IndexOf(values, 3);
Array.Sort(values);

Solution

1. Step 1: Find index of first 3

   Array.IndexOf(values, 3) correctly returns the first index where 3 appears, which is 1.

2. Step 2: Reverse the array

   Array.Reverse(values); reverses the array in place as required.

3. Final Answer:

   int index = Array.IndexOf(values, 3); Array.Reverse(values); -> Option C

4. Quick Check:

   IndexOf + Reverse = int index = Array.IndexOf(values, 3); Array.Reverse(values); [OK]

Hint: Use Array.IndexOf(array, value) to find index [OK]

Common Mistakes:

• Using instance method IndexOf on array (not valid)
• Confusing FindIndex with IndexOf
• Sorting instead of reversing