Я хочу передать массив функции, отменить его без использования метода Array.Reverse () и вернуть перевернутый массив. На самом деле я пытаюсь сделать это без использования временной переменной в этом случае. Ниже мой фрагмент кода. Пожалуйста, поправьте меня, где я ошибаюсь.

class Program
{
    static void Main(string[] args)
    {
        int[] array = { 1, 2, 3, 4, 5 };
        int[] reverse = new int[5];
        reverse = ReverseArray(array, reverse);

        foreach (int item in reverse)
        {
            Console.WriteLine(reverse);
        }
    }

    public static int[] ReverseArray(int[] arr, int[] rev)
    {
        int x = arr.Length - 1;
        for (int i = 0; i <= x; i++)
        {
            rev[i] = arr[x];
            x--;
        }
        return rev;
    }
}
c#
-3
tkhan17 22 Окт 2018 в 18:57

2 ответа

Лучший ответ

На самом деле я пытаюсь сделать это без использования временной переменной в этом случае.

Давайте сначала проигнорируем этот бит и будем использовать временную переменную там, где это имеет смысл. Мы можем вернуться к этому.

Есть несколько различных способов решения общей проблемы «перевернуть массив». Мы можем перевернуть сам массив на месте, мы можем создать новый массив, который является обратным массиву, который нам был дан, или мы можем заполнить другой массив, который нам дан, чтобы быть обратным первому массиву, который нам был дан. Ваше решение содержит смесь из трех и, следовательно, не справляется ни с одним из них должным образом.

Чтобы заполнить второй предоставленный нам массив, нам не нужен временный интервал, поскольку мы не меняем местами и не хотим останавливаться на средней точке:

static void Main(string[] args)
{
    int[] array = { 1, 2, 3, 4, 5 };
    int[] reverse = new int[5];
    ReverseArray(array, reverse);

    foreach (int item in reverse)
    {
        Console.WriteLine(item);
    }
}

public static void ReverseArray(int[] arr, int[] rev)
{
    int x = arr.Length - 1;
    for (int i = 0; i < arr.Length; i++, x--)
    {
        rev[i] = arr[x];
    }
}

Мы просмотрели каждый элемент в arr и поместили его в соответствующую позицию в rev.

Чтобы вернуть новый массив, мы делаем то же самое, но создаем новый массив внутри самого метода:

static void Main(string[] args)
{
    int[] array = { 1, 2, 3, 4, 5 };
    int[] reverse = ReverseArray(array);

    foreach (int item in reverse)
    {
        Console.WriteLine(item);
    }
}

public static int[] ReverseArray(int[] arr)
{
    int[] rev = new int[arr.Length];
    int x = arr.Length - 1;
    for (int i = 0; i < arr.Length; i++, x--)
    {
        rev[i] = arr[x];
    }

    return rev;
}

Вариант этого вообще не создает новый массив, а просто выполняет итерацию по нему, создавая IEnumerable<int>. Это быстрее возвращает первый результат и не использует столько памяти с большими массивами, но повторно выполняет реверсирование каждый раз, когда он используется, поэтому он зависит от того, насколько он полезен соответственно:

static void Main(string[] args)
{
    int[] array = { 1, 2, 3, 4, 5 };
    IEnumerable<int> reverse = ReverseArray(array);

    foreach (int item in reverse)
    {
        Console.WriteLine(item);
    }
}

public static IEnumerable<int> ReverseArray(int[] arr)
{
    for (int i = arr.Length - 1; i >= 0; i--)
    {
        yield return arr[i];
    }
}

Чтобы перевернуть массив на месте, мы хотим проложить путь от внешнего к среднему, меняя местами элементы:

static void Main(string[] args)
{
    int[] array = { 1, 2, 3, 4, 5 };
    ReverseArray(array);

    foreach (int item in array)
    {
        Console.WriteLine(item);
    }
}

public static void ReverseArray(int[] arr)
{
    int x = arr.Length - 1;
    for (int i = 0; i < x; i++, x--)
    {
        int temp = arr[x];
        arr[x] = arr[i];
        arr[i] = temp;
    }
}

Это нарушает ваше произвольное правило без временных переменных. Мы можем обойти это с помощью небольшого трюка, хотя в этом нет никакой реальной пользы.

static void Main(string[] args)
{
    int[] array = { 1, 2, 3, 4, 5 };
    ReverseArray(array);

    foreach (int item in array)
    {
        Console.WriteLine(item);
    }
}

public static void ReverseArray(int[] arr)
{
    int x = arr.Length - 1;
    for (int i = 0; i < x; i++, x--)
    {
        arr[x] ^= arr[i];
        arr[i] ^= arr[x];
        arr[x] ^= arr[i];
    }
}

Однако нет никакого смысла в том, чтобы не использовать 4-байтовую временную переменную.

1
Jon Hanna 22 Окт 2018 в 16:21

x может не нуждаться в уменьшении, вы можете использовать arr.Length - 1 - i вместо x для индекса массива, иначе вы будете уважать только половину массива.

public static int[] ReverseArray(int[] arr, int[] rev)
{
    int x = arr.Length - 1;
    for (int i = 0; i <= x; i++)
    {
        rev[i] = arr[arr.Length - 1 - i];
    }
    return rev;
}

И я бы передал только один массив для метода, и вы можете объявить обратный массив в методе.

public static int[] ReverseArray(int[] arr)
{
    int[] reverse = new int[arr.Length];
    int x = arr.Length - 1;
    for (int i = 0; i <= x; i++)
    {
        reverse[i] = arr[arr.Length - 1 - i];
    }
    return reverse;
}

c # онлайн

< Сильный > Результат

5
4
3
2
1
1
D-Shih 22 Окт 2018 в 16:09
52933342