How to reverse an array (in C#) without using Array.Reverse() method?

如何在不使用Array.Reverse()方法的情况下反转数组(在C#中)？

For example,

例如,

int[] arr = {1,3,4,9,8};
// some code here
Console.WriteLine(string.Join(",", arr));

should result in

应该会导致

8,9,4,3,1

I got this as an interview task.

这是我的面试任务。

优秀答案推荐

The code to be substituted in place of // some code here in the question is:

在问题中替换//某些代码的代码是：

for (int i = 0; i < arr.Length / 2; i++)
{
   int tmp = arr[i];
   arr[i] = arr[arr.Length - i - 1];
   arr[arr.Length - i - 1] = tmp;
}

You should iterate only through the first half of the array (arr.Length / 2). If you iterate through the whole array (arr.Length), it will be reversed twice, yielding the same element order as before it started.

您应该只迭代数组的前半部分(arr.Length/2)。如果遍历整个数组(arr.Length)，它将被反转两次，生成与开始之前相同的元素顺序。

Basically, you are asked to reimplement Array.Reverse(Array). If you look at how it is implemented in the framework itself and ignore many technical details around, you’ll find that it just calls its three-parameter version (which reverses specified part of an array) on the whole array.

基本上，您需要重新实现Array.Reverse(数组)。如果您查看它是如何在框架本身中实现的，而忽略周围的许多技术细节，您会发现它只是在整个数组上调用它的三参数版本(颠倒数组的指定部分)。

Array.Reverse(Array,Int32,Int32) is a while-loop that swaps elements and maintains two indexes:

Array.Reverse(Array，Int32，Int32)是一个WHILE循环，它交换元素并维护两个索引：

1. i points to the first element of the reversed part, and


2. j points to the last element of the reversed part.

Rewritten to be substituted in place of // some code here in the question:

重写以替换问题中//此处的一些代码：

int i = 0;
int j = arr.Length - 1;
while (i < j)
{
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
    i++;
    j--;
}

This is easier to grasp than the implementation using for-loop, does less arithmetic and elegantly evades the gotcha with double reversion.

这比使用for-loop的实现更容易掌握，做的算术更少，并且通过双重回归优雅地避开了陷阱。

That is So Simple Start loop from Array legth and so on watch code and you will get understand :)))

这是来自数组、LEGTH等观察代码的如此简单的开始循环，您将理解：)

        int[] arr = new int[5] { 1, 2, 3, 4, 5 };

        for (int i = arr.Length-1; i >= 0; i--)
        {
            Console.WriteLine(arr[i]);
        }

int[] arr1 = {1,3,4,9,8};
int[] arr2 = new int[5];

int j = 0;

for(int i = arr1.Length - 1; i >= 0; i--)
{
  arr2[j] = arr1[i];
  j++;
}

Well, obviously you can just copy to a new array, in reverse order.

显然，您只需以相反的顺序复制到新的数组中。

To do the operation "in place", you can work from both ends towards the middle: Load the first and last elements, then store them back, the first into the last location, and the last into the first location. Then do the second and the next-to-last, etc. If you have an even number of elements you do N/2 iterations. If an odd number you do (N-1)/2 iterations and leave the middle element where it was.

要进行“就地”操作，您可以从两端向中间操作：加载第一个和最后一个元素，然后将它们存储回去，第一个元素存储到最后一个位置，最后一个元素存储到第一个位置。然后做第二个和倒数第二个，依此类推。如果你有偶数个元素，你就做N/2次迭代。如果是奇数，则进行(N-1)/2次迭代，并将中间的元素保留在原来的位置。

There are probably other algorithms that would be marginally faster when considering cache line size and other memory characteristics, but they wouldn't be worth it unless you were in a really performance-critical situation.

在考虑高速缓存线大小和其他内存特征时，可能有其他算法会稍微快一些，但除非您处于真正的性能关键型情况下，否则它们不值得这么做。

for (int i = 0; i < array.Length - i; i++)
 {
   var value = array[array.Length - i - 1];
   array[array.Length - i - 1] = array[i];
   array[i] = value;
 }

// without using Reverse method and without using additional array
// try yield operator starting from the last element

//不使用反转方法，不使用额外的数组//尝试从最后一个元素开始的Year运算符

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

char[] strx = { '1','2','3','4','5','6','7','8','9' };
int i = strx.Length;
string ktr ="";

while (i>0)
{
   i--;
   ktr += strx[i];

   if (i==0)
   {
      i = strx.Length;

      while (i > 0)
      {
         i--;
         strx[i] = ktr[i];
      }

   }
}
int j;
Console.WriteLine("Array strx in reverse order: ");
for (j = 0; j < strx.Length; j++ ) 
{
  Console.Write("{0}", strx[j]);
}

try something like:

试着这样做：

var counter = 1;
var newArr = new int[arr.length];
for(int i = 0; i < arr.length; i++)
{
  newArr[i] = arr[arr.length - counter];
  counter++;
}

I didn't test that but it should be on the right track. Any reason you dont want to use Array.Reverse? Its probably a well-optimized version of the algorithm.

我没有测试这一点，但它应该是在正确的轨道上。有任何不想使用数组的原因吗？它可能是该算法的优化版本。

You can do this in many ways, from the most fast to the most stupid like:

你可以用很多方法来做到这一点，从最快的到最愚蠢的，比如：

int[] arr = new int[] { 1,2,3 };
arr = (from a in arr orderby a descending select a).ToArray();

But I cannot understand why are you pursuing such a futile quest, if that is to impress someone somewhere then use this instead of the for loops :)

但我不明白你为什么要追求如此徒劳的追求，如果这是为了在某个地方给某人留下深刻印象，那么就使用这个而不是For循环：)

I am not good at loops at all. But this is what seems simple to me -

我一点也不擅长弧圈球。但在我看来这很简单--

 int[] array1 = { 1, 2, 3, 4, 5 };

 int[] reverseArray = new int[array1.Length];

 for (int i = 0; i <= array1.Length - 1; i++)
  {
    reverseArray[i] = array1[array1.Length - i - 1];
  }

This is the dynamic solution for reversing the array of any datatype.Some of the key points in my algorithm is first calculate the half of array length and add check to stop iteration when array indexes have same value.The stage having same indexes depict that it start the reverse operation again.So at this stage break the outer loop by using "goto Statement".

该算法的关键点之一是先计算数组长度的一半，当数组索引相同时增加检查停止迭代，索引相同的阶段描述再次开始反转操作，所以在这个阶段使用GOTO语句来中断外循环。

string[] unreversed = {"A","B","C","D","E","F","G","H","I","J","K"};
            int q=unreversed.Length;
            int t = q / 2;
            var temp1 = "A";
            for(int i = 0;i<unreversed.Length;i++)
            {
                q = q - 1;
                for(int k=q;k<=q;k++)
                {
                    if (unreversed[k] != unreversed[i] && i!=t)
                    {
                        temp1 = unreversed[i];
                        unreversed[i] = unreversed[k];
                        unreversed[k] = temp1;

                    }
                    else
                    {
                        goto printarray;

                    }

                }

            }
            printarray:
            foreach (var k in unreversed)
            {
                Console.WriteLine(k);

            }

//Create temp array with the same size.
int[] arrTemp = new int[arr.Length];
int i = 0;
//Assign last value of arr to first value of arrTemp
for (int j = arr.Length - 1; j >= 0; j--)
{
    arrTemp[i] = arr[j];
    i++;
}
arr = arrTemp;

I prefer a LINQ expression that uses an index:

我更喜欢使用索引的LINQ表达式：

using System.Linq;

int[] arr = { 1, 3, 4, 9, 8 };
arr = arr.Select((n, idx) => new {n, idx})
    .OrderByDescending(r => r.idx)
    .Select(r => r.n).ToArray();

You can try this, Without using additional temporary variable:

您可以尝试这样做，而无需使用其他临时变量：

for(int i = left; i < right/2; i++)
{
    (nums[i], nums[right - i - 1]) = (nums[right - i - 1], nums[i]);
}

C# Solution

C#解决方案

using System;
public class Program { public static void Main() { int[] arr = new int[] { 1, 2, 3, 4, 5, 6 };
 //---------------------------------------------------------------------------------------------------------------------
    // 1 Print Array as 1, 2, 3, 4, 5, 6
    //---------------------------------------------------------------------------------------------------------------------
    Console.WriteLine(string.Join(",", arr));
    //---------------------------------------------------------------------------------------------------------------------
    // 2> Write code to reverse it
    //---------------------------------------------------------------------------------------------------------------------     
    int temp=0;
    int left=0,right=arr.Length-1;
    while(left<right)
    {
        temp=arr[left];
        arr[left]=arr[right];
        arr[right]=temp;
        left++;
        right--;
    }       
    //---------------------------------------------------------------------------------------------------------------------
    // 3> Print reversed Array as 6, 5, 4, 3, 2, 1
    //---------------------------------------------------------------------------------------------------------------------
    Console.WriteLine(string.Join(",", arr));
}

Stack stack=new Stack;
var newArr = new int[arr.length];

for(int i = 0; i < arr.length; i++)
{
  stack.push(arrr[i])
}
for(int i = 0; i < arr.length; i++)
{
  newarr[i]= stack.pop()
}

int[] array1 = { 1, 2, 3, 4, 5 };

for (int x = 4; x < array1.Length && x != -1; x--)
{
    int tmp;
    tmp=array1[x];
    Console.Write("{0} ", tmp);
}

That's my solution for this.

这就是我的解决方案。

It is better to use Array.Reverse method

最好使用Arrae.Reverse方法

int[] arr ={1,3,4,9,8};
Array.Reverse(arr);

You can read more description Here

你可以阅读更多描述这里

int[] triangles = new int[]{0,1,2,3}    
for (int j = triangles.Length; j > (triangles.Length / 2); j--)
                    {
                        var temp = triangles[j - 1];
                        triangles[j - 1] = triangles[triangles.Length - j];
                        triangles[triangles.Length - j] = temp;
                    }

I would prefer to reverse an array from the end of it. My solution's above.

我更喜欢从数组的末尾反转数组。我的解决方案在上面。

    public int[] Reverse(params int[] numbers)
    {
        for (int i = 0; i < numbers.Length / 2; i++)
        {
            int tmp = numbers[i];
            numbers[i] = numbers[numbers.Length - i - 1];
            numbers[numbers.Length - i - 1] = tmp;
        }

        return numbers;
    }

Here is an example of reversing an array using the Length() function and a simple for loop.

下面是使用Long()函数和一个简单的for循环来反转数组的示例。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            int[] arr = new int[] {4, 8, 2, 9, 5, 5};
            
            int length = arr.Length;
            
            for(int i = 0; i < arr.Length; i++)
            {
               Console.WriteLine(arr[length-1] + " ");
               length = length - 1;
            }            
        }        
    }
}

Console.WriteLine("Enter a string");
string input = Console.ReadLine();

string s = "";
for (int i = input.Length-1 ; i >= 0; i--)
{
    s = s + input[i];
}
Console.WriteLine(s);

Can do this with single for loop..

可以使用单个for循环来实现这一点。

   int[] arr ={1,3,4,9,8};


   for(int i=arr.length-1;i>=0;i--)
   {
      Console.Write(arr[i]);
   }