9
votes

Façon la plus efficace d'inverser l'ordre d'un bitparray?

Je me demandais de quoi le moyen le plus efficace d'inverser l'ordre d'un biparray en C #. Pour être clair, je ne veux pas inverser le bitarray en appelant. Not (), je veux inverser l'ordre des bits dans la matrice.

acclamations, Chris


2 commentaires

Que diriez-vous d'utiliser (la lecture) en arrière?


Oui, la taille est fixe (8 bits)


6 Réponses :


33
votes
public void Reverse(BitArray array)
{
    int length = array.Length;
    int mid = (length / 2);

    for (int i = 0; i < mid; i++)
    {
        bool bit = array[i];
        array[i] = array[length - i - 1];
        array[length - i - 1] = bit;
    }    
}

1 commentaires

S'il vous plaît ajouter ceci au code de dotnet officiel quelqu'un



8
votes

Pour une gamme longue et une relative quelques utilisations, il suffit d'envelopper:

    class BitArrayReverse
    {
        private BitArray _ba;

        public BitArrayReverse(BitArray ba) { _ba = ba; }

        public bool this[int index]
        {
            get { return _ba[_ba.Length - 1 - index]; }
            set { _ba[_ba.Length - 1 - index] = value; }
        }

    }


1 commentaires

+1 Nice. Pas vraiment une réponse mais une option intelligente pour certaines situations.



1
votes

parce que la taille si elle est corrigée à 8 bits, la recherche de la "table" de ci-dessous est suffisante - lorsqu'il s'agit d'une liste octet une recherche est probable le moyen le plus rapide. Les frais généraux supplémentaires de Bitset pour obtenir / définir les données peuvent toutefois annuler la prestation de recherche. De plus, le coût de construction initial et les frais généraux persistants doivent être pris en compte (mais les valeurs peuvent être codées dans une matrice littérale ... Ick!)

D'autre part, si les données sont seulement 8 Un peu (jamais) et "la performance est importante", pourquoi utiliser un bittharray du tout? Un bitarray pourrait toujours être utilisé pour les fonctionnalités agréables, telles que "exploser" à un énumérable tandis que c # a déjà une manipulation de bits d'octet décente intégrée.

supposant qu'un cas plus général que les données sont 8 bits alignés ... mais d'une certaine longueur indéterminée

est-ce réellement mieux (plus rapide, plus efficace, etc.) que de le faire "par article" dans le bitarray? Je n'ai aucune idée mais suspect non. Je commencerais certainement avec les méthodes "simples" - ceci est ici comme une preuve de concept et peut (ou peut ne pas être) intéressant de comparer dans une référence. Quoi qu'il en soit, écrire pour la clarté d'abord ... et le ci-dessous n'est pas ça! (Il y a au moins un bogue dedans - je blâme la complexité supplémentaire; -) xxx

sortie: xxx

Le expr.dump () est un fonctionnalité LINQPAD . < / p>


0 commentaires

6
votes

Ce sera le meilleur moyen Pour inverser MSB LSB de n'importe quelle longueur à l'aide de XOR dans la boucle pour la boucle

public static BitArray BitsReverse(BitArray bits)
{
    int len = bits.Count;
    BitArray a = new BitArray(bits);
    BitArray b = new BitArray(bits);

    for (int i = 0, j = len-1; i < len; ++i, --j)
    {
         a[i] = a[i] ^ b[j];
         b[j] = a[i] ^ b[j];
         a[i] = a[i] ^ b[j];
    }

    return a; 
} 
// in   010000011010000011100b
// out  001110000010110000010b


1 commentaires

Vous triple la consommation de mémoire et vous attribuez des opérations. Comment cela peut être efficace?



3
votes
 Dim myBA As New BitArray(4)
 myBA(0) = True
 myBA(1) = False
 myBA(2) = True
 myBA(3) = True
 Dim myBoolArray1(3) As Boolean
 myBA.CopyTo(myBoolArray1, 0)
 Array.Reverse(myBoolArray1)
 myBA = New BitArray(myBoolArray1)

0 commentaires

0
votes

Adapté la réponse de @timloyd et l'a transformée en une extension pour une utilisation plus facile. XXX PRE>

Utilisation: p>

var bits = new BitArray(some_bytes).Reverse();


0 commentaires