Question

当我们反转整数1的所有位时，应该返回什么整数？我们如何使用Java代码执行此操作？

不应使用内置函数的java。不应该使用String reverse，转换为字符串等。只允许按位操作。

import java.util.*;
import java.lang.*;
import java.io.*;

class BitReverseInt
{
    public static void main (String[] args) throws java.lang.Exception{
        System.out.println(reverser(1));
    }

    public static int reverser(int given){
          int input = given;
          int temp = 0;
          int output = 0;
          while(input > 0){
            output = output << 1;
            temp = input & 1;
            input = input >> 1;
            output = output | temp;
          }

          return output;
    }
}

Answer 1

位反转可以通过交换相邻的单个位，然后交换相邻的2位字段，然后是4位，等等，如下所示。这五个赋值语句可以按任何顺序执行。

/********************************************************
 * These are the bit masks used in the bit reversal process

   0x55555555 = 01010101010101010101010101010101
   0xAAAAAAAA = 10101010101010101010101010101010
   0x33333333 = 00110011001100110011001100110011
   0xCCCCCCCC = 11001100110011001100110011001100
   0x0F0F0F0F = 00001111000011110000111100001111
   0xF0F0F0F0 = 11110000111100001111000011110000
   0x00FF00FF = 00000000111111110000000011111111
   0xFF00FF00 = 11111111000000001111111100000000
   0x0000FFFF = 00000000000000001111111111111111
   0xFFFF0000 = 11111111111111110000000000000000

 */

    uint x = 23885963;    // 00000001011011000111100010001011

    x = (x & 0x55555555) <<  1 | (x & 0xAAAAAAAA) >>  1; 
    x = (x & 0x33333333) <<  2 | (x & 0xCCCCCCCC) >>  2; 
    x = (x & 0x0F0F0F0F) <<  4 | (x & 0xF0F0F0F0) >>  4; 
    x = (x & 0x00FF00FF) <<  8 | (x & 0xFF00FF00) >>  8; 
    x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16;

    // result x == 3508418176   11010001000111100011011010000000

通过查看每个中间结果，您可以看到发生了什么。

enter image description here

希望这能为您提供所需的内容。 John Doe的回答将第4步和第5步合并为一个表达式。这适用于大多数机器。

Answer 2

这是Integer.reverse（int）的实际实现。

    public static int reverse(int i) {
    // HD, Figure 7-1
    i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555;
    i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333;
    i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f;
    i = (i << 24) | ((i & 0xff00) << 8) |
        ((i >>> 8) & 0xff00) | (i >>> 24);
    return i;
}

Answer 3

return Integer.reverse(given);

Integer.reverse Reference

Answer 4

您可以像这样使用do while循环：

public static int reverse(int number){
        int reverse = 0;
        int remainder = 0;
        do{
            remainder = number%10;
            reverse = reverse*10 + remainder;
            number = number/10;

        }while(number > 0);

        return reverse;
    }

对于按位操作：这里是：

// value=your integer, numBitsInt=how much bit you will use to reverse 
public static int reverseIntBitwise(int value, int numBitsInt) {

    int i = 0, rev = 0, bit;

    while (i++ < numBitsInt) {

        bit = value & 1;

        value = value >> 1;

        rev = rev ^ bit;

        if (i < numBitsInt)
            rev = rev << 1;
    }
    return rev;
}

Answer 5

有很多方法可以在Java中反转给定数字的位。

首先，Java语言具有内置按位补码运算符（〜）。所以（〜数字）反转数字位。

其次，可以使用 Integer.reverse（数字）

第三，如果这是测试的一部分，或者你只想玩位，你可以参考下面的代码。

/*
The logic uses moving bitmask from right to left:

 1. Get the bit of given number, by binary and(&) with bitmask
 2. XOR(^) with the bitmask, so here we reverse the bit.
 3. OR(|) this reversed bit with the result(result has all Zero initially)

This logic is repeated for each 32 bits by moving the mask from right to left, 
one bit at a time using (<<) left shift operator on bitmask.
*/
public class ReverseBits {

    public static int reverseBits(int input) {
        print("Input", input);
        int bitmask = 1;
        int result = 0;
        do {
            //print("Bitmask", bitmask);
            result = result | (bitmask ^ (input & bitmask)) ;
            //print("Result", result);
            bitmask = bitmask << 1;
        } while (bitmask != 0);
        print("Reverse", result);
        return result;
    }

    public static void print(String label, int input) {
        System.out.println(label +"\t:"+Integer.toBinaryString(input));
    }

    public static void main(String[] args) {
        reverseBits(Integer.MIN_VALUE);
        reverseBits(Integer.MAX_VALUE);
        reverseBits(reverseBits(170));
    }
}

<强>输出：

Input   :10000000000000000000000000000000
Reverse :1111111111111111111111111111111
Input   :1111111111111111111111111111111
Reverse :10000000000000000000000000000000
Input   :10101010
Reverse :11111111111111111111111101010101
Input   :11111111111111111111111101010101
Reverse :10101010

反转int中的所有位并返回int

5 个答案: