C#移动数组的元素直到指定点，并将指定元素拉到前面

我的问题是，我想在数组中有一个特定的元素，将它复制到另一个变量，将整个数组只向上移动到该元素，然后将该元素放在前面。在一幅漂亮的图画中，它看起来是这样的

[0, 1, 2, 3, 4, 5]
          ^

[0, 1, 2, null, 4, 5]
          ^ (3)

[null, 0, 1, 2, 4, 5]
             ^ (3)

[null, 0, 1, 2, 4, 5]
 ^ (3)

[3, 0, 1, 2, 4, 5]
 ^

我已经尝试使用for循环将元素带到前面，然后插入3，但我担心我的方法不是最有效或最快的方法

这是我试过的

        int elementAt = 3;
        int[] array = { 0, 1, 2, 3, 4, 5 };
        int mem = array[elementAt];
        for (int i = elementAt; i > 0; i--)
            array[i] = array[i - 1];
        array[0] = mem;

我怀疑类似数组的东西。复制可以做得更快

编辑： 下面的每个答案在特定场景中都有自己的用途。 这个问题没有明确的答案，让这些结果让你选择使用哪种方法

iterations, index, arraysize
HIGH, HIGH, HIGH
Speed for ShiftRightAt: 6616, ticks: 28007912
Speed for shiftlist: 3556, ticks: 15054635
Speed for arrayCopy: 1742, ticks: 7376152
Speed for MoveValueToFront: 67, ticks: 285901
LOW, LOW, HIGH
Speed for ShiftRightAt: 0, ticks: 28
Speed for shiftlist: 42, ticks: 180476
Speed for arrayCopy: 33, ticks: 142717
Speed for MoveValueToFront: 0, ticks: 67
HIGH, LOW, HIGH
Speed for ShiftRightAt: 0, ticks: 1399
Speed for shiftlist: 3624, ticks: 15341777
Speed for arrayCopy: 3177, ticks: 13449012
Speed for MoveValueToFront: 0, ticks: 926
LOW, HIGH, HIGH
Speed for ShiftRightAt: 73, ticks: 311428
Speed for shiftlist: 41, ticks: 174652
Speed for arrayCopy: 18, ticks: 79768
Speed for MoveValueToFront: 65, ticks: 277266
HIGH, HIGH, LOW
Speed for ShiftRightAt: 0, ticks: 1379
Speed for shiftlist: 0, ticks: 3902
Speed for arrayCopy: 0, ticks: 728
Speed for MoveValueToFront: 0, ticks: 914
LOW, LOW, LOW
Speed for ShiftRightAt: 0, ticks: 3
Speed for shiftlist: 0, ticks: 32
Speed for arrayCopy: 0, ticks: 11
Speed for MoveValueToFront: 0, ticks: 12
HIGH, LOW, LOW
Speed for ShiftRightAt: 0, ticks: 135
Speed for shiftlist: 0, ticks: 3850
Speed for arrayCopy: 0, ticks: 998
Speed for MoveValueToFront: 0, ticks: 840
LOW, HIGH, LOW
Speed for ShiftRightAt: 0, ticks: 15
Speed for shiftlist: 0, ticks: 16
Speed for arrayCopy: 0, ticks: 9
Speed for MoveValueToFront: 0, ticks: 39

测试方法：

---

你漂亮的画作正是你需要写的东西

public static void ShiftRightAt<T>(T[] array, int index)
{
    if (index < 0 || index >= array.Length) return; // throw exception

    var element = array[index]; // take out the element

    for (int i = index; i > 0; i--)
    {
        array[i] = array[i - 1];
    }

    array[0] = element;
}

publicstaticvoidshiftrightat（T[]数组，int索引）
{
if（index<0 | | index>=array.Length）返回；//抛出异常
var element=array[index]；//取出元素
对于（int i=index；i>0；i--）
{
数组[i]=数组[i-1]；
}
数组[0]=元素；
}

使用列表更容易。之后，将其转换回数组

var array = new int[] { 0, 1, 2, 3, 4, 5 };                 
var list = array.ToList();
list.Remove(3);
list.Insert(0, 3);
array = list.ToArray();

如果您不能（或不想）使用

列表

，也可以使用以下选项：

public int[] moveElement(int[] array, int index)
{
    int[] save = new int[] { array[index] };
    var rest = array.Take(index).Concat(array.Skip(index + 1));
    return save.Concat(rest).ToArray();
}

编辑

如果不同的数据类型需要此选项，则这是一个通用版本：

public T[] moveElement<T>(T[] array, int index)
{
    T[] save = new T[] { array[index] };
    var rest = array.Take(index).Concat(array.Skip(index + 1));
    return save.Concat(rest).ToArray();
} 

public T[]移动元素（T[]数组，int索引）
{
T[]save=newt[]{array[index]}；
var rest=array.Take（index）.Concat（array.Skip（index+1））；
返回save.Concat（rest.ToArray（）；
} 

这是一个使用数组的示例。复制，因此它应该足够快：

int elementAt = 3;
int[] array = { 0, 1, 2, 3, 4, 5 };

int[] arr1=new int[array.Length];
arr1[0] = array[elementAt];
Array.Copy(array, 0, arr1, 1, elementAt);
Array.Copy(array, elementAt+1, arr1, elementAt+1, array.Length-elementAt-1);
//arr1={3, 0, 1, 2, 4, 5}

编辑

我对结果不满意，因为我认为

数组.Copy

应该更快。我认为这个版本大大提高了速度：

int saved = array[elementAt];
Array.Copy(array, elementAt + 1, array, elementAt, array.Length - elementAt - 1);
Array.Copy(array, 0, array, 1, array.Length - 1);
array[0] = saved;

---

以下是您可以使用的扩展方法：

public static int[] MoveValueToFront(this int[] values, int searchValue)
{
    if (values == null || values.Length == 0)
    {
        return values;
    }

    var rest = values.TakeWhile(v => v != searchValue).ToArray();

    if (rest.Length == values.Length)
    {
        return values;
    }

    values[0] = searchValue;
    rest.CopyTo(values, 1);

    return values;
}

这将允许您执行以下操作：

[TestMethod]
public void TestMoverExtension()
{

    var testValues = new int[] { 0, 1, 2, 3, 4, 5 };

    var result = testValues.MoveValueToFront(3);


    CollectionAssert.AreEqual(new int[] { 3, 0, 1, 2, 4, 5 }, result);
}

---

你试过什么了吗？你为此写了什么代码？您在代码中遇到了什么问题？我尝试使用for循环将最后一个元素放在前面，然后插入该变量，但我担心这不是最有效、最快的方法。请分享您的尝试。否则它看起来像是“为我编写代码”问题将

数组

转换为

列表

，将元素保存为变量，从列表中删除元素，将其插入索引0。这是最快的方法吗？数组复制可以更快吗？哦，我刚注意到你的问题，你已经这么做了。嗯，这是我认为最快的方法（如果你不想用不安全的东西炸毁），我会很乐意使用不安全的，如果它意味着更多的速度。如果你正在寻找速度，请在C++中编写你的程序。那更接近金属，真的是法斯特。比我的“解决方案”快近20倍。列表消耗的资源不是比数组多吗？列表使用隐藏在引擎盖下的数组，主要隐藏在一些基于方法的抽象后面，用于隐藏未使用的元素，并在需要更多空间时增加数组。有一个恒定的大小，这将使用一个2^（上限）log2（N）的数组，在大多数情况下这应该是一个微不足道的跳跃。这实际上比使用相同测试方法的OPs（检查OP的方法）要慢（虽然可读性更高）。下面是您的结果和您的操作方法。这是一个进步。在某些测试案例中，它的速度更快，不是吗？是的。每个解决方案都有其强场景和弱场景。例如，在（低、高、低、高、高、低）迭代次数少、索引大小大、数组大小小的情况下，您做得最好。在（低、低、低-高、高、低、低、高、高）中，低-低移位trightat仅以3个刻度获胜。