Java实现海明码的编码与译码

Java实现海明码(汉明码)的编码与译码

海明码简介

汉明码(Hamming Code),是在电信领域的一种线性调试码,以发明者理查德·卫斯里·汉明的名字命名。汉明码在传输的消息流中插入验证码,当计算机存储或移动数据时,可能会产生数据位错误,以侦测并更正单一比特错误。由于汉明编码简单,它们被广泛应用于内存(RAM)。(摘自百度百科

海明码是一种可以纠正一位差错的编码。它是利用在信息位为k位,增加r位冗余位,构成一个n=k+r位的码字,然后用r个监督关系式产生的r个校正因子来区分无错和在码字中的n个不同位置的一位错。它必需满足以下关系式: 2^r ≥ k+r+1 或 2r ≥ n+1 海明码的编码效率为: R=k/(k+r) 式中 k为信息位位数 r为增加冗余位位数。(摘自搜狗百科

海明码冗余位的位置

海明码的编码规则如下:
可以看到,p1算作二进制中的第一位,p2算作二进制中的第二位,以此类推
海明码的编码规则
但是,冗余位并不一定是在上图的那些位置,也可以放在别的地方(可以自行验证),但是为了方便一般都会这么放。1、2、4、8、16 等下标对应的二进制数只有一位是1,其他位置都是0。这样编码和译码做奇偶校验的时候,只用异或所有下标的二进制数对应位置为1的数。

Java实现

海明码只能纠错一位。下述实现,译码过程实现了自动纠错一位,但如果有多个错误,可能译码出错误的结果。

public class HammingCode {
    /**
     * 偶校验
     */
    public static final int EVEN_PARITY = 0;
    /**
     * 奇校验
     */
    public static final int ODD_PARITY = 1;
    /**
     * 编码译码时使用的校验模式,默认为偶校验
     */
    private int checkMode = EVEN_PARITY;

    /**
     * 译码是否成功
     */
    private boolean decodeSuccess = false;
    /**
     * 译码的时候,是否检测到输入错误
     */
    private boolean errorSrc = false;
    /**
     * 译码的时候,检测到输入错误在第几位
     */
    private Integer errorIndex;


	// 无参构造
    public HammingCode() {}
	// 有参构造, 用与选择是奇校验还是偶校验
    public HammingCode(int checkMode) {
        if (checkMode == ODD_PARITY) {
            this.checkMode = ODD_PARITY;
        } else {
            this.checkMode = EVEN_PARITY;
        }
    }

	// 编码
    public String code(String src) {
        // 校验输入数据
        if (src == null || src.equals("")) {
            return "输入为空";
        }
        String[] srcArray = src.trim().split("");
        for (String srcChar : srcArray) {
            if (!srcChar.equals("0") && !srcChar.equals("1")) {
                return "输入格式不正确";
            }
        }

        int n = src.length();
        int x = 0;
        while ((1 << x) - 1 < n + x) x++;

        // 将原数据填充到扩增的数组中的响应位置
        int[] resultArray = new int[n + x];
        for (int i = 0, j = 0, checkIndex = 1; i < resultArray.length; i++) {
            if (checkIndex == i + 1) {
                checkIndex = checkIndex << 1;
            } else {
                resultArray[i] = Integer.parseInt(srcArray[j++]);
            }
        }

        // 填充数组中校验位的数据
        for (int i = 1; i < resultArray.length; i = i << 1) {
            int verification = checkMode;
            for (int j = i + 1; j <= resultArray.length; j++) {
                if ((i & j) != 0) {
                    verification = verification ^ resultArray[j - 1];
                }
            }
            resultArray[i - 1] = verification;
        }

        // 获取返回字符串
        StringBuilder result = new StringBuilder();
        for (int i : resultArray) {
            result.append(i);
        }
        return result.toString();
    }

	// 译码
    public String decode(String src) {
        // 校验输入数据
        if (src == null || src.equals("")) {
            return "输入为空";
        }
        String[] srcArray = src.trim().split("");
        for (String srcChar : srcArray) {
            if (!srcChar.equals("0") && !srcChar.equals("1")) {
                return "输入格式不正确";
            }
        }

        // 初始化译码相关的结果数据
        initParam();

        int n = src.length();
        int x = 0;
        while ((1 << x) - 1 < n) x++;

        // 从左到右,获取通过校验位校验后的结果
        int[] checkInts = new int[x];
        for (int i = 1, index = 0; i < n; i = i << 1) {
            int verification = Integer.parseInt(srcArray[i - 1]);
            for (int j = i + 1; j <= n; j++) {
                if ((i & j) != 0) {
                    verification = verification ^ Integer.parseInt(srcArray[j - 1]);
                }
            }
            // 奇偶校验对应不同的值
            checkInts[index++] = verification == checkMode ? 0 : 1;
        }

        // 通过校验位,获取出错在第几位
        int errorIndexNum = 0;
        for (int i = 0; i < x; i++) {
            if (checkInts[i] != 0) {
                errorIndexNum += (1 << i);
            }
        }

        // 如果errorIndex大于输入的长度,代表输入数据错误肯定不止一位
        if (errorIndexNum-1 > n) {
            decodeSuccess = false;
            errorSrc = true;
            return "输入数据有误,可能包含不止一位错误,无法解码";
        }
        // 如果出错,纠正错误
        if (errorIndexNum > 0) {
            String indexStr = srcArray[errorIndexNum - 1];
            if (indexStr.equals("0")) {
                srcArray[errorIndexNum - 1] = "1";
            } else {
                srcArray[errorIndexNum - 1] = "0";
            }
            errorSrc = true;
            errorIndex = errorIndexNum;
        }

        // 译码成功,获取并返回原数据
        decodeSuccess = true;
        StringBuilder result = new StringBuilder();
        for (int i = 0, checkIndex = 1; i < n; i++) {
            if (checkIndex == i + 1) {
                checkIndex = checkIndex << 1;
            } else {
                result.append(srcArray[i]);
            }
        }
        return result.toString();
    }
	
	/**
	*  初始化译码相关的结果数据
	*/
    private void initParam() {
        decodeSuccess = false;
        errorSrc = false;
        errorIndex = null;
    }

    public boolean isDecodeSuccess() {
        return decodeSuccess;
    }

    public boolean isErrorSrc() {
        return errorSrc;
    }

    public Integer getErrorIndex() {
        return errorIndex;
    }
}
  • 3
    点赞
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
海明码是一种可以纠正一位差错的编码。在Java中,你可以使用以下步骤来实现海明码的计算: 1. 首先,确定信息位的位数k和冗余位的位数r,并计算码字的总位数n = k + r。 2. 创建一个长度为n的数组,用于存储码字。 3. 根据编码规则,确定冗余位的位置。通常冗余位的下标为2的幂次方(如1、2、4、8、16等)。 4. 遍历码字数组,将信息位进行填充。 5. 针对每个冗余位,计算校验位的值。可以通过对对应位置的信息位进行异或运算得到校验位的值。 6. 将校验位的值存储到码字数组的相应位置。 7. 返回码字数组作为海明码的计算结果。 下面是一个示例代码,演示了如何使用Java实现海明码的计算: ```java import java.util.Arrays; public class HammingCode { public static int[] calculateHammingCode(int[] data) { int k = data.length; int r = 0; while (Math.pow(2, r) < k + r + 1) { r++; } int n = k + r; int[] hammingCode = new int[n]; int[] parityIndices = new int[r]; for (int i = 0; i < r; i++) { parityIndices[i] = (int) Math.pow(2, i); } int dataIndex = 0; for (int i = 1; i <= n; i++) { if (Arrays.binarySearch(parityIndices, i) >= 0) { hammingCode[i - 1] = 0; } else { hammingCode[i - 1] = data[dataIndex]; dataIndex++; } } for (int i = 0; i < r; i++) { int parityBit = 0; for (int j = 1; j <= n; j++) { if (j % (int) Math.pow(2, i + 1) >= (int) Math.pow(2, i)) { parityBit ^= hammingCode[j - 1]; } } hammingCode[(int) Math.pow(2, i) - 1] = parityBit; } return hammingCode; } public static void main(String[] args) { int[] data = {1, 0, 1, 1}; int[] hammingCode = calculateHammingCode(data); System.out.println("海明码计算结果:" + Arrays.toString(hammingCode)); } } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值