不使用 Array.Reverse() 反轉數組

Question

如何在不使用Array.Reverse()方法的情況下反轉數組（在 C# 中）？

例如，

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

應該導致

8,9,4,3,1

我把這個作為面試任務。

Answer 1

用來代替問題中// some code here是：

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

您應該只遍歷數組的前半部分 ( arr.Length / 2 )。 如果您遍歷整個數組 ( arr.Length )，它將被反轉兩次，產生與開始之前相同的元素順序。

Answer 2

基本上，您需要重新實現Array.Reverse(Array) 。 如果你看看它是如何在框架本身中實現的，而忽略了周圍的許多技術細節，你會發現它只是在整個數組上調用它的三參數版本（反轉數組的指定部分）。

Array.Reverse(Array,Int32,Int32)是一個 while 循環，它交換元素並維護兩個索引：

1. i指向反轉部分的第一個元素，並且
2. j指向反轉部分的最后一個元素。

重寫以代替問題中的// some code here ：

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

這比使用 for-loop 的實現更容易掌握，執行更少的算術運算並優雅地避開雙重回歸的陷阱。

Answer 3

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

Answer 4

這是從 Array legth 開始的如此簡單的循環，等等觀看代碼，你會明白:)))

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

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

Answer 5

// 不使用 Reverse 方法，也不使用額外的數組 // 嘗試從最后一個元素開始的 yield 運算符

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

Answer 6

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

Answer 7

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

Answer 8

好吧，顯然你可以以相反的順序復制到一個新數組。

要進行“就地”操作，您可以從兩端向中間進行操作：加載第一個和最后一個元素，然后將它們存儲回去，第一個放入最后一個位置，最后一個放入第一個位置。 然后執行第二個和倒數第二個等等。如果您有偶數個元素，則執行 N/2 次迭代。 如果是奇數，則執行 (N-1)/2 次迭代並將中間元素保留在原處。

在考慮緩存行大小和其他內存特性時，可能還有其他算法會稍微快一點，但除非您處於真正的性能關鍵情況下，否則它們不值得。

Answer 9

我根本不擅長循環。 但這對我來說似乎很簡單-

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

Answer 10

這是反轉任意數據類型數組的動態解決方案。我算法中的一些關鍵點是首先計算數組長度的一半，並在數組索引具有相同值時添加檢查以停止迭代。具有相同索引的階段描述它再次開始反向操作。因此在此階段使用“ goto Statement ”打破外循環。

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

            }

Answer 11

您可以使用此方法。

public int[] Reversing(int[] array)
    {
        int[] newArray = new int[array.Length];

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

Answer 12

//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;

Answer 13

嘗試類似：

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

我沒有測試，但它應該在正確的軌道上。 您不想使用 Array.Reverse 的任何原因？ 它可能是算法的優化版本。

Answer 14

您可以通過多種方式執行此操作，從最快到最愚蠢，例如：

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

但我不明白你為什么要追求這樣一個徒勞的追求，如果那是為了給某人留下深刻印象，那么使用它而不是 for 循環 :)

Answer 15

我更喜歡使用索引的 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();

Answer 16

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

Answer 17

這是使用Length()函數和簡單的 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;
            }            
        }        
    }
}

Answer 18

你可以試試這個，不使用額外的臨時變量：

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

Answer 19

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

Answer 20

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

這就是我的解決方案。

Answer 21

最好使用 Array.Reverse 方法

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

您可以在此處閱讀更多說明

Answer 22

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

我更願意從它的末尾反轉一個數組。 我的解決方案在上面。

Answer 23

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

Answer 24

可以用單個 for 循環做到這一點..

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


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

Answer 25

   function printReverse(arr) {
      for(var i = arr.length - 1; i >= 0; i--){

    console.log(arr[i]);
      }
   }
printReverse([1, 2, 3, 6, 47, 88]);

 function printReverse(arr) { for (var i = arr.length - 1; i >= 0; i--) { console.log(arr[i]); } } printReverse([1, 2, 3, 6, 47, 88])

Answer 26

您可以向后循環：

int[] arr= new int[] {1, 2, 3, 4, 6};
for(int i=arr.Length-1 ;i>= 0 ; i--)
{
    Console.WriteLine(arr[i].ToString());
}