C# le moyen le plus rapide pour changement de tableau

Voici mon test du harnais...

var source = Enumerable.Range(1, 100).Cast<int?>().ToArray();
var destination = new int?[source.Length];

var s = new Stopwatch();
s.Start();
for (int i = 0; i < 1000000;i++)
{
    Array.Copy(source, 1, destination, 0, source.Length - 1);
}
s.Stop();
Console.WriteLine(s.Elapsed);

Voici les résultats de 1 million d'itérations de chaque solution (8 Core Intel Xeon E5450 @ 3.00 GHz)

                       100 elements  10000 elements
For Loop                     0.390s         31.839s 
Array.Copy()                 0.177s         12.496s
Aaron 1                      3.789s         84.082s
Array.ConstrainedCopy()      0.197s         17.658s

Faire le choix pour vous-même 🙂

Voici ma solution, similaire à la Tâche en ce que c'est un Tableau simple wrapper et qu'elle prend en O(1) temps de modifier le tableau à gauche.

public class ShiftyArray<T>
{
    private readonly T[] array;
    private int front;

    public ShiftyArray(T[] array)
    {
        this.array = array;
        front = 0;
    }

    public void ShiftLeft()
    {
        array[front++] = default(T);
        if(front > array.Length - 1)
        {
            front = 0;
        }
    }

    public void ShiftLeft(int count)
    {
        for(int i = 0; i < count; i++)
        {
            ShiftLeft();
        }
    }

    public T this[int index]
    {
        get
        {
            if(index > array.Length - 1)
            {
                throw new IndexOutOfRangeException();
            }

            return array[(front + index) % array.Length];
        }
    }

    public int Length { get { return array.Length; } }
}

Courant par Jason Punyon du code de test...

int?[] intData = Enumerable.Range(1, 100).Cast<int?>().ToArray();
ShiftyArray<int?> array = new ShiftyArray<int?>(intData);

Stopwatch watch = new Stopwatch();
watch.Start();

for(int i = 0; i < 1000000; i++)
{
    array.ShiftLeft();
}

watch.Stop();

Console.WriteLine(watch.ElapsedMilliseconds);

Faut ~29ms, quelle que soit la taille de la matrice.

Ne pourriez-vous pas utiliser un Système.Les Collections.Génériques.File d'attente au lieu d'un tableau ?

Je sens que vous avez besoin pour effectuer des actions sur votre valeur le jeter, donc à l'aide d'une file d'attente semble plus approprié :

//dummy initialization
        System.Collections.Generic.Queue<int> queue = new Queue<int>();
        for (int i = 0; i < 7; ++i ) { queue.Enqueue(i); }//add each element at the end of the container

        //working thread
        if (queue.Count > 0)
            doSomething(queue.Dequeue());//removes the last element of the container and calls doSomething on it

Pour toute verser de l'âme de trouver ce fil et sur le point de mettre en œuvre l'un des très bien notés réponses. Tous d'entre eux sont des ordures, je ne suis pas sûr pourquoi. Peut-être Dested demandé une nouvelle matrice de mise en œuvre au premier ou quelque chose qui a été retiré de la question. Eh bien tout simplement si vous souhaitez modifier le tableau et n'ont pas besoin d'un nouveau, de voir une réponse comme tdaines de réponse. Et de lire sur des choses comme la mémoire Tampon Circulaire /Anneau de la mémoire Tampon : http://en.wikipedia.org/wiki/Circular_buffer. Pas de déplacement des données réelles est nécessaire. La performance de déplacement d'un tableau doit pas être liée à la taille de la matrice.

Vous pouvez utiliser le même tableau que la source et la destination pour vite en place de copie:

static void Main(string[] args)
        {
            int[] array = {0, 1, 2, 3, 4, 5, 6, 7};
            Array.ConstrainedCopy(array, 1, array, 0, array.Length - 1);
            array[array.Length - 1] = 0;
        }

Je sais que c'est une vieille question, mais venant de Google, il n'y a pas de simple exemple, grâce à ce est la façon la plus facile de réorganiser une liste, et vous n'avez pas à fournir le type il va s'en sortir, au moment de l'exécution,

   private static List<T> reorderList<T>(List<T> list){
       List<T> newList = new List<T>();

       list.ForEach(delegate(T item)
       {
           newList.Add(item);
       });

       return newList;
   }

Si vous êtes propriétaire de la mémoire vous pouvez envisager d'utiliser Le Code Unsafe et de la bonne vieille pointeurs.

Assurez-vous d'un flux de mémoire et de verrouiller ou de l'utilisation Marshal.AllocHGlobal
Construire tous vos tableaux avec un peu de rembourrage au début et à la fin.
d'incrémenter ou de décrémenter l'ensemble de la matrice de pointeurs à la fois. Vous aurez toujours besoin de boucle de retour et de définir vos valeurs null.

Si vous avez besoin de manière sélective incrémenter ou décrémenter les tableaux, vous devrez ajouter du rembourrage entre eux.

Les tableaux sont incroyablement faible niveau des structures de données, si vous les traiter dans un niveau bas façon, vous pouvez obtenir une énorme prestation.

Un baytrail cela peut surpasser de Jason avec toutes ses 8 Core Intel Xeon E5450 @ 3.00 GHz

Tableau de la copie est un O(n) fonctionnement et crée un nouveau tableau.
Tandis que la matrice de la copie peut certainement être fait rapidement et efficacement, le problème que vous avez dit peut effectivement être résolu d'une manière entièrement différente sans (comme vous l'avez demandé) la création d'un nouveau tableau/structure de données et seulement à la création d'un petit emballage de l'objet par exemple de tableau:

using System;
using System.Text;

public class ArrayReindexer
{
    private Array reindexed;
    private int location, offset;

    public ArrayReindexer( Array source )
    {
        reindexed = source;
    }

    public object this[int index]
    {
        get
        {
            if (offset > 0 && index >= location)
            {
                int adjustedIndex = index + offset;
                return adjustedIndex >= reindexed.Length ? "null" : reindexed.GetValue( adjustedIndex );
            }

            return reindexed.GetValue( index );
        }
    }

    public void Reindex( int position, int shiftAmount )
    {
        location = position;
        offset = shiftAmount;
    }

    public override string ToString()
    {
        StringBuilder output = new StringBuilder( "[ " );
        for (int i = 0; i < reindexed.Length; ++i)
        {
            output.Append( this[i] );
            if (i == reindexed.Length - 1)
            {
                output.Append( " ]" );
            }
            else
            {
                output.Append( ", " );
            }
        }

        return output.ToString();
    }
}

Par l'emballage et le contrôle de l'accès à la matrice de cette manière, nous pouvons maintenant démontrer la façon dont le problème a été résolu avec un O(1) appel de la méthode...

ArrayReindexer original = new ArrayReindexer( SourceArray );
Console.WriteLine( "   Base array: {0}", original.ToString() );
ArrayReindexer reindexed = new ArrayReindexer( SourceArray );
reindexed.Reindex( 1, 1 );
Console.WriteLine( "Shifted array: {0}", reindexed.ToString() );

Produira la sortie:

Base de la matrice de: [ 0, 1, 2, 3, 4, 5, 6 ]

Décalé tableau: [ 0, 2, 3, 4, 5, 6, null ]

Je suis prêt à parier qu'il y aura une raison pour qu'une telle solution ne fonctionne pas pour vous, mais je crois que cela ne correspond pas à vos premiers besoins exprimés. 8 )

Il est souvent utile de réfléchir à toutes les différentes sortes de solutions à un problème avant de mettre en œuvre un spécifique, et peut-être que peut-être la chose la plus importante que cet exemple peut démontrer.

Espérons que cette aide!

using System;
using System.Threading;
namespace ShiftMatrix
{
class Program
{
static void Main(string[] args)
{
MatrixOperation objMatrixOperation = new MatrixOperation();
//Create a matrix
int[,] mat = new int[,]
{
{1, 2},
{3,4 },
{5, 6},
{7,8},
{8,9},
};
int type = 2;
int counter = 0;
if (type == 1)
{
counter = mat.GetLength(0);
}
else
{
counter = mat.GetLength(1);
}
while (true)
{
for (int i = 0; i < counter; i++)
{
ShowMatrix(objMatrixOperation.ShiftMatrix(mat, i, type));
Thread.Sleep(TimeSpan.FromSeconds(2));
}
}
}
public static void ShowMatrix(int[,] matrix)
{
int rows = matrix.GetLength(0);
int columns = matrix.GetLength(1);
for (int k = 0; k < rows; k++)
{
for (int l = 0; l < columns; l++)
{
Console.Write(matrix[k, l] + " ");
}
Console.WriteLine();
}
}
}
class MatrixOperation
{
public int[,] ShiftMatrix(int[,] origanalMatrix, int shift, int type)
{
int rows = origanalMatrix.GetLength(0);
int cols = origanalMatrix.GetLength(1);
int[,] _tmpMatrix = new int[rows, cols];
if (type == 2)
{
for (int x1 = 0; x1 < rows; x1++)
{
int y2 = 0;
for (int y1 = shift; y2 < cols - shift; y1++, y2++)
{
_tmpMatrix[x1, y2] = origanalMatrix[x1, y1];
}
y2--;
for (int y1 = 0; y1 < shift; y1++, y2++)
{
_tmpMatrix[x1, y2] = origanalMatrix[x1, y1];
}
}
}
else
{
int x2 = 0;
for (int x1 = shift; x2 < rows - shift; x1++, x2++)
{
for (int y1 = 0; y1 < cols; y1++)
{
_tmpMatrix[x2, y1] = origanalMatrix[x1, y1];
}
}
x2--;
for (int x1 = 0; x1 < shift; x1++, x2++)
{
for (int y1 = 0; y1 < cols; y1++)
{
_tmpMatrix[x2, y1] = origanalMatrix[x1, y1];
}
}
}
return _tmpMatrix;
}
}
}

Voir C# code ci-dessous pour le supprimer de l'espace de la chaîne. Ce changement de caractère dans le tableau. La Performance est O(n). Aucun autre tableau est utilisé. Donc pas de mémoire supplémentaire soit.

    static void Main(string[] args)
{
string strIn = System.Console.ReadLine();
char[] chraryIn = strIn.ToCharArray();
int iShift = 0;
char chrTemp;
for (int i = 0; i < chraryIn.Length; ++i)
{
if (i > 0)
{
chrTemp = chraryIn[i];
chraryIn[i - iShift] = chrTemp;
chraryIn[i] = chraryIn[i - iShift];
}
if (chraryIn[i] == ' ') iShift++;
if (i >= chraryIn.Length - 1 - iShift) chraryIn[i] = ' ';
}
System.Console.WriteLine(new string(chraryIn));
System.Console.Read();
}