Le nombre de « 1 » binaire

Le problème est telle que pour un octet (8 bits) de la variable de nombre entier non signé, qui est la représentation binaire requis nombre de « 1 »

En plus de plus de 21

Un nombre entier de 8 bits, sauf le dernier, l'autre est une puissance entière de deux. Si plus de 1 après que le moule 2 , le dernier est lié à 1, le nombre de 1, sinon il se termine par un 0. Ensuite ** / ** 2, une fois descendant, le haut descendront bas une, la suivante pour vérifier, jusqu'à ce que le nombre entier est 0.

	public int count1(int n) {
        int num = 0;
        while (n > 0) {
            if (n % 2 == 1)//模1相加
                num++;
            n /= 2;

        }
        return num;
    }

Et une opération

La même chose est le dernier à voir si chacun. L' opération entière effectuée avec 00.000.001 (&) , parce que les 7 premiers bits est égal à 0, le résultat sera 0 avant le 7, si le dernier bit est égal à 1, les extrémités de résultat avec un 1, l'ensemble grâce à un nombre de 1, num + 1 , se termine par une 0 réponse est 0, num + 0. A cette époque, le dernier test inutile est terminé, celui de droite, le processus est répété jusqu'à ce qu'un zéro.

	public int count2(int n) {
        int num = 0;
        while (n > 0) {
            num += (n&1);//讲位运算的结果加上 1 or 0
            n = n >> 1;
        }
        return num;
    }

manipulation efficace bits

Nous avons constaté que les deux premières opérations, pour un certain nombre, comme 10000000, qui gaspillent beaucoup de temps inutile 0, la complexité de l'algorithme peut faire seulement avec le numéro « 1 » à ce sujet ?
Le n et n-1 & opération ET , le dernier peut être instantanément jugé dès le début de la « 1 » le plus proche, donc un numéro, puis le résultat est attribué à n. Donc , ne juge pas un par un, le dernier.

Chaque fois que cette opération, cela signifie que n est un « un ».

Puisque n doit être de la plus récente « 1 » emprunter pour financer pour répondre à la 1 opération, sinon le nombre de -1 est inférieur à 0. Après moins 1, par lui-même inchangé les bits précédents est égal à 0, l'arrière doit être modifié entre 0 et 1 ensemble.

Et l'opération d'affectation est ensuite effectuée, le premier peut être effacé, num + 1. Après avoir répété le processus jusqu'à ce que n est égal à 0.

	public static int count3(int n) {
        int num = 0;
        while (n > 0) {
            n = n & (n - 1);
            num++;
        }
        return num;
    }

Une méthode pour la violence et certaines branches du droit, une table de consultation est écrit à l'avance toutes les circonstances, cela ne les liste pas.

Si cela est utile pour vous, s'il vous plaît cliquer sur le dessous une touche triple Merci