时间戳

首页 > 解决方案 > 将数组传递给函数，在不使用 Array.Reverse() 方法的情况下将其反转并返回反转后的数组

c# - 将数组传递给函数，在不使用 Array.Reverse() 方法的情况下将其反转并返回反转后的数组

问题描述

我想将一个数组传递给一个函数，在不使用 Array.Reverse() 方法的情况下反转它并返回反转后的数组。在这种情况下，我实际上是在尝试不使用 temp 变量来做到这一点。下面是我的代码片段。请纠正我在哪里弄错了。

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#

解决方案

在这种情况下，我实际上是在尝试不使用 temp 变量来做到这一点。

让我们先忽略这一点，并在有意义的地方使用临时变量。我们可以回到它。

有几种不同的方法可以处理“反转数组”的一般问题。我们可以就地反转数组本身，我们可以创建一个与我们给定的数组相反的新数组，或者我们可以填充另一个我们给定的数组，作为我们给定的第一个数组的反面。您的解决方案混合了这三者，因此无法正确执行其中任何一个。

要填充第二个数组，我们不需要临时，因为我们没有交换，我们不想停在中间点：

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

我们已经检查了 in 中的每一个元素，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 字节的临时变量确实没有任何价值。

推荐阅读