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

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
 
namespace Rextester
{
    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;
        }
        
        private static int GetPreviousIndex(int index, int length, int minIndex, int maxIndex)
        {
            index = (index == (maxIndex + 1) % length) ? minIndex - 1 : index - 1;
            index = (index + length) % length;
            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);
            int startIndex = GetPreviousIndex(minIndex, array.Length, minIndex, maxIndex);
            int startElement = array[startIndex];
            int index = startIndex;
            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;
            }
            array[index] = startElement;
        }
        
        public static void Main(string[] args)
        {
            int[] array = { 2, 3, 1, 4, 5, 10, 6, 7, 8 };
            Console.WriteLine(string.Join(", ", array));
            ShiftRight(array);
            Console.WriteLine(string.Join(", ", array));
        }
    }
}

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));
    }
}