C# 'de hızlı dizi kaydırma uygulaması?

Question

Sağa ve sola doğru bir yer N konumuna göre kaydırmalıyım.

Kaydettiğim tarafta çıkan öğeler diğer tarafa geri dönmelidir. Sağ 13 ile

Shift: 15 tarafından bırakılan

[0,1,2,3,4,5,6,7,8,9] -> [7,8,9,0,1,2,3,4,5,6] 

Shift: Bu işlem milyonlarca kez olacak ve gerçekten hızlı olmalı

[0,1,2,3,4,5,6,7,8,9] -> [5,6,7,8,9,0,1,2,3,4] 

.

Geçerli uygulamam aşağıdaki gibidir. Yapılacak bir optimizasyon varsa lütfen bir göz atın ve önerin.

if (shift > 0) 
{ 
    int offset = array.Length % shift; 
    if (offset > 0) 
    { 
     byte[] temp = new byte[offset]; 
     if (!right) 
     { 
      Array.Copy(array, temp, offset); 
      Array.Copy(array, offset, array, 0, array.Length - offset); 
      Array.Copy(temp, 0, array, array.Length - offset, temp.Length); 
     } 
     else 
     { 
      Array.Copy(array, array.Length - offset, temp, 0, offset); 
      Array.Copy(array, 0, array, offset, array.Length - offset); 
      Array.Copy(temp, 0, array, 0, temp.Length); 
     } 
    } 
} 

o kaymıştır alacak miktarına bir ipucu olarak

(ama optimizasyon yol açabilir şüphe):

- depends on the entropy of the array itself 
- for aray that are full of same values it will get shifted roughtly 0 
- more entropy means higher shift value 
- direction of shift will be used generally more to the left 

PS. Güvenli olmayan kod çalıştırmak için güvenlik izni alınamıyor:/

PS2: Ortaya çıkan dizi, ileri işleme için farklı bir kitaplığa doğru bir dizi olarak geçirilmelidir, bu yüzden yalnızca sarmak ve yeniden dizine sığamıyorum.

PS3: Yöntem, ref yöntemini kullandığı için aynı dizide çalışmayı tercih ediyorum ve bunu yeni bir dizide yapıyor ve sonra da kopyalama işlemi zaman alacaktır (parça için 'temp' dizisini kullanıyorum) Bu kayma nedeniyle düşüyor).

Answer 1

Bunun yerine Buffer.BlockCopy kullanmalısınız. Dizi indekslemesini atlar ve hızlı hafıza kopyalarını gerçekleştirir. Unutmayın, BlockCopy bayt cinsinden veriyi dizi elemanının büyüklüğüne göre değil, bunun için hesaplamak için sizeof()'u kullandığınızdan emin olun. Eğer hiç kopyasını yapmayın bir modülo

public byte[] ShiftBytes(byte[] arr, int shift, bool isRight) 
{ 
    byte[] newBytes = new byte[arr.Length]; 
    shift = (isRight) ? shift : -1 * shift; 
    for (int i = 0; i < arr.Length; i++) 
     newBytes[i] = arr[(((i + shift) % arr.Length) 
      + arr.Length) % arr.Length]; 
    return newBytes; 
} 

Answer 2

Sadece dizinin ilk öğesinin dizinini kaydedin. Değişen dizide değer elde etmeniz gerektiğinde, iterasyon indeksinize eklemeniz yeterlidir.
Vardiya yapmanız gerektiğinde, vardiya değerini ilk öğenin dizinine ekleyin.

Answer 3

Böyle bir şey kullanabilirsiniz. Referansı diziye ve kaydırma değerine depolayan hafif nesneler oluşturun. Daha sonra değeri almak gerektiğinde bunun yerine bu nesneleri kullanın.

Aynı dizide birkaç vardiya "yığını" oluşturmanız gerekiyorsa, durumu yalnızca bir katman oluşturmama durumuna getirin (iletilen nesneden geçişi ekleyin).Eğer gerçekten yeni, kaymıştır dizi Buffer.BlockCopy() kullanmak oluşturmak varsa

Answer 4

ile sadece dairesel endeksi cant

Answer 5

(ı örnekte bir int dizisi kabul, herhangi bir başka türü için aynı işleri):

int [] sourceArray = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 
int [] targetArray = new int[sourceArray.Length]; 

int shift = 13; 
int offset = shift % sourceArray.Length; 

Buffer.BlockCopy(sourceArray, offset*sizeof(int), targetArray, 0 , (sourceArray.Length - offset)*sizeof(int)); 
Buffer.BlockCopy(sourceArray, 0, targetArray, (sourceArray.Length - offset) * sizeof(int), offset * sizeof(int)); 

Answer 6

Jerry Penner's answer dayanarak:

internal static void ShiftCircular(int offset, object[] array) 
{ 
    if (offset == 0 || array.Length <= 1) 
     return; 

    offset = offset % array.Length; 

    if (offset == 0) 
     return; 

    if (offset < 0) 
     offset = array.Length + offset; 

    Array.Reverse(array, 0, array.Length); 
    Array.Reverse(array, 0, offset); 
    Array.Reverse(array, offset, array.Length - offset); 
} 

Dairesel sol ve sağ kaydırmayı destekler ve yalnızca verilen dizide çalışır.