Ввести одномерный массив A, вывести его. Произвести циклический сдвиг элементов расположенных вне границ - C#

public class Program
{
    // Поиск индекса минимального элемента
    private static int GetMinIndex(int[] array)
    {
        int minIndex = 0;
        for (int i = 1; i < array.Length; i++)
            if (array[i] < array[minIndex])
                minIndex = i;
        return minIndex;
    }
    
    // Поиск индекса максимального элемента
    private static int GetMaxIndex(int[] array)
    {
        int maxIndex = 0;
        for (int i = 1; i < array.Length; i++)
            if (array[i] > array[maxIndex])
                maxIndex = i;
        return maxIndex;
    }
    
    // Обмен значений элементов
    private static void Swap(ref int x, ref int y)
    {
        var temp = x;
        x = y;
        y = temp;
    }
    
    // Зная текущий индекс (index), длину массива (length), и диапазон
    // игнорируемых элементов [minIndex; maxIndex], опредеяем индекс предыдущего элемента.
    private static int GetPreviousIndex(int index, int length, int minIndex, int maxIndex)
    {
        if (index == (maxIndex + 1) % length) // если предыдущий элемент имеет индекс maxIndex
            index = minIndex - 1;
        else
            index = index - 1;
            
        if (index == -1) // это например на случай если изначальный index (или minIndex) был равен нулю.
            index = length - 1;
            
        return index;
    }
 
    private static void ShiftRight(int[] array)
    {
        int minIndex = GetMinIndex(array);
        int maxIndex = GetMaxIndex(array);
        if (maxIndex - minIndex + 1 >= array.Length - 1)
            return;
        if (minIndex > maxIndex)
            Swap(ref minIndex, ref maxIndex); // хотим, чтобы minIndex <= maxIndex
            
        // находим любой индекс, не входящий в диапазон [minIndex, maxIndex]
        // в данном случае определяем его как предыдущи элемент от элемента minIndex
        int startIndex = GetPreviousIndex(minIndex, array.Length, minIndex, maxIndex);
        
        // запоминаем его, потому что он будет перезаписан на первой итерации цикла
        int startElement = array[startIndex]; 
        
        // текущий индекс
        int index = startIndex;
        
        // (maxIndex - minIndex + 1) - размер отрезка [minIndex; maxIndex]
        // array.Length - (maxIndex - minIndex + 1) - количество сдвигов которые необходимо совершить
        // вычитаем единицу, така как последний двиг особенный
        for (int k = 0; k < array.Length - (maxIndex - minIndex + 1) - 1; k++)
        {
            // определяем индекс предыдущего элемента
            int previousIndex = GetPreviousIndex(index, array.Length, minIndex, maxIndex);
            
            // совершаем сдвиг, перезаписывая текущий элемент предыдущим
            array[index] = array[previousIndex];
            
            // следующий индекс, значение по которому надо перезаписать.
            index = previousIndex;
        }
        
        // совершаем заключающий сдвиг. Нельзя использовать GetPreviousIndex(index, ....), така как тот элемент
        // был перезаписан, а нам нужно его оригинальное значение. Это значение startElement.
        array[index] = startElement;
    }
 
    public static void Main(string[] args)
    {
        int[] array = { 1, 3, 1, 4, 5, 10, 6, 7, 8 };
        Console.WriteLine(string.Join(", ", array));
        ShiftRight(array);
        Console.WriteLine(string.Join(", ", array));
    }
}