C语言 on 好冷の小窝

汉明码校验

Sun, 04 Aug 2024 14:02:04 +0800

汉明码简介

汉明码（也叫海明码），常用于数据传输中的校验编码。汉明码具有一位纠错能力，其主要特点如下：

数据分组校验
校验位在$2^x$位
校验位个数和值的确定
校验码的解码和纠正

说白了就是每个校验位负责一组数据的奇偶校验，然后整个数据分成了好几组，最后将各组的校验整合得到整个数据中出现错误的那一位。

编码

假设数据有n位，其中校验码有x位，那么编码后的数据应该有n+x位。x位校验码一共有$2^x$种取值，其中一种取值表示数据正确，则剩下的$((2^x) - 1)$种取值表示有一位数据出错。不难推出如下不等式：

$$ ((2^x) - 1) >= (n+x) $$

使得不等式成立的x的最小值就是汉明码的校验位数。

例如0101 0011数据有8位，则代入不等式可以得到“$((2^x) - 1) >= (8+x)$”，所以x=4。
原始数据0101 0011经过编码之后变成了12位数据，其中第$2^k$位是校验位，其余位为数据位，如下所示：

1	2	3	4	5	6	7	8	9	10	11	12
P1	P2	D1	P4	D2	D3	D4	P8	D5	D6	D7	D8

然后对他们进行分组，首先观察其位置编码：

位置	二进制表示	对应数据	对应取值
1	0001	P1	待定
2	0010	P2	待定
3	0011	D1	0
4	0100	P4	待定
5	0101	D2	1
6	0110	D3	0
7	0111	D4	1
8	1000	P8	待定
9	1001	D5	0
10	1010	D6	0
11	1011	D7	1
12	1100	D8	1

将最低位是1的数据分为第一组：P1, D1, D2, D4, D5, D7

将第二低位是1的数据分为第二组：P2, D1, D3, D4, D6, D7

将最三低位是1的数据分为第三组：P4, D2, D3, D4, D8

将最高位是1的数据分为第四组：P8, D5, D6, D7, D8

再根据每个分组的数据位和偶校验的规则计算校验位具体数值

P1 = D1 ^ D2 ^ D4 ^ D5 ^ D7 // 0 ^ 1 ^ 1 ^ 0 ^ 1
P2 = D1 ^ D3 ^ D4 ^ D6 ^ D7 // 0 ^ 0 ^ 1 ^ 0 ^ 1
P3 = D2 ^ D3 ^ D4 ^ D8 // 1 ^ 0 ^ 1 ^ 1
P4 = D5 ^ D6 ^ D7 ^ D8 // 0 ^ 0 ^ 1 ^ 1
// 计算得到：P1 = 1, P2 = 0, P3 = 1, P4 = 0

原始数据0101 0011经过编码变成1001 1010 0011

解码

汉明码只能对一位数据进行检测和纠正（但是在计算机网络传输过程中，绝大多数情况下都是仅发生一位数据错误，因此汉明码校验仍然在广泛使用），假设收到的数据为1001 1010 0010，此时接收方并不知道数据是否有效，需要对该数据进行汉明码校验，具体如下：

首先对校验码进行校验计算

P1_Check = P1 ^ D1 ^ D2 ^ D4 ^ D5 ^ D7 // 1 ^ 0 ^ 1 ^ 1 ^ 0 ^ 1
P2_Check = P2 ^ D1 ^ D3 ^ D4 ^ D6 ^ D7 // 0 ^ 0 ^ 0 ^ 1 ^ 0 ^ 1
P3_Check = P3 ^ D2 ^ D3 ^ D4 ^ D8 // 1 ^ 1 ^ 0 ^ 1 ^ 0
P4_Check = P4 ^ D5 ^ D6 ^ D7 ^ D8 // 0 ^ 0 ^ 0 ^ 1 ^ 0
// 计算得到：P1_Check = 0, P2_Check = 0, P3_Check = 1, P4_Check = 1

按照对应高低位将校验计算的结果进行排列，得到P4P3P2P1 = 1100，

该数据表示P4和P3校验位检测到数据出错，而P1和P2校验位检测到数据正常（即D2, D3, D4 D8和D5, D6, D7, D8中各有一个数据出现错误，而D1, D2, D4, D5和D1, D3, D4, D6, D7均正常）

所以可以推测出出现错误的是D8表示的数据，即第12位数据位出错，0b1100对应十进制正好为12，只需要将对应位取反即可得到正确数据。

C语言杂记

Tue, 09 Jul 2024 21:01:04 +0800

常见的C99头文件

stdio.h : 标准IO接口 printf(), scanf()
stdlib.h : 通用工具 malloc(), free(), atoi()
stdarg.h : 可变参数处理 va_list
stddef.h : 常用类型以及宏的定义 size_t, NULL
string.h/strings.h : 字符串操作函数 strcat(), strcasecmp()
ctype.h : 字符操作函数或宏 toupper()
time.h : 时间和时区操作函数 time()
stdint.h : 整数类型及各整数类型的极值
stdbool.h : true、false等bool类型

math.h : 数学函数

函数	含义
abs(x)	返回x的绝对值
sin(x)	返回x的正弦值（弧度制）
cos(x)	返回x的余弦值
tan(x)	返回x的正切值
exp(x)	返回Ex的值
asin(x)	返回x的反正弦值
acos(x)	返回x的反余弦值
atan(x)	返回x的反正切值
cbrt(x)	返回x的立方根

常见C语言预处理器指令

#include : 包含一个源代码文件
#define : 定义宏
#undef : 取消已定义的宏
#ifdef : 如果宏已经定义，则返回真
#ifndef : 如果宏没有定义，则返回真
#if : 如果给定条件为真，则编译下面的代码
#else : #if 的代替方案
#elif : 如果前面的 #if 给定条件不为真，当前条件为真，则编译下面代码
#endif : 结束一个 #if……#else 条件编译块
#error : 当遇到标准错误时，输出错误消息
#pragma : 使用标准化方法，向编译器发布特殊的命令到编译器中

位运算符

运算符	描述	实例
`&`	按位“与”
`\|`	按位“或”
`^`	“异或”
`~`	按位“取反”
`<<`	二进制“左移”
`>>`	二进制“右移”

数据类型

数据类型	大小Size
`char`	1字节
`int`	2~4字节
`short int`	2字节
`long int`	4字节
`float`	4字节
`double`	8字节
`long double`	10字节

C中的枚举Enum

简单的示例

#include <stdio.h>

int main(int argc, char *argv[])
{
    enum week{ Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun } day;
    scanf("%d", &day);

    switch(day){
        case Mon: puts("Monday"); break;
        case Tues: puts("Tuesday"); break;
        case Wed: puts("Wednesday"); break;
        case Thurs: puts("Thursday"); break;
        case Fri: puts("Friday"); break;
        case Sat: puts("Saturday"); break;
        case Sun: puts("Sunday"); break;
        default: puts("Error!");
    }

    return 0;
}

指针、可怕的指针

指针是一个变量，它存储另一个变量的内存地址作为其值。

函数指针（用来存放函数的地址）

指针函数（返回值是指针的函数）

例如strcpy(char *str1, const char *str2)返回str1

另外需要注意的杂项

使用const修饰的只读变量不具有“常量表达式”属性，因此无法用来表示定长数组的大小，或者在case语句中使用。“常量表达式”本身会在程序编译时被求值，而“只读变量”只能在程序运行时才被得知。
变量存储类型：
- auto默认；
- register声明告诉编译器，它所声明的变量在程序中使用频率较高，因此可以将register变量放在机器的寄存器中，使程序更小、执行速度更快，（但是编译器可以忽略此选项）；
- static
- extern
*p++问题

若有定义int i =2, a[10], *p=&a[i];，则*p++等价于a[i++]。

++的优先级比*高，但是++是后缀，先使用值再加加，所以是加之前的值去解引用。

待续未完……此外，如有侵权，深感歉意，烦请邮箱联系。

KMP算法

Thu, 11 May 2023 14:32:13 +0800

KMP算法

»>配合视频食用，效果更佳!

KMP简介

KMP算法主要用于字符串匹配。

KMP的主要思想是当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。

前缀表

前缀表是用来匹配回溯的，它记录了模式串与主串不匹配时，模式串应该从哪里开始重新匹配。

前缀： 不包含最后一个字符的所有以第一个字符开头的连续子串。

后缀：不包含第一个字符的所有以最后一个字符结尾的连续子串。

前缀表：记录下标i之前（包括i）的字符串中，有多大长度的_相同前缀后缀_。

长度为前3个字符的子串aab，其最长相同前后缀的长度为0.

长度为前4个字符的子串aaba，其最长相同前后缀的长度为1.

利用前缀表匹配字符串：

前缀表与next数组

next数组可以有很多种版本，其影响的仅是匹配失败后回溯时依据的下标。本文采用的时前缀表统一减去一之后的版本，即

1
2
3

模式串：	"aabaaf"
前缀表：	[0, 1, 0, 1, 2, 0]
next数组：[-1, 0, -1, 0, 1, -1]

next数组的构建

初始化
处理前后缀不同的情况
处理前后缀相同的情况

void get_next(int *next, char *needle)
{
    // 初始化
    // j时前缀的末尾，也代表了前缀的长度
  	// 因为只有相等的时候j才推进，所以它能代表最长相等前后缀的长度，即next数组的值
    int j = -1;
    next[0] = j;
    // 从下标为1开始遍历，i作为后缀的末尾
    for(int i = 1; i < strlen(needle); i++)
    {
        //  由于可能存在递归回退，所以要用while
        while(j >= 0 && needle[i] != neddle[j+1])	// 前后缀不相同
            j = next[j];	// 回溯到前一位next数组对应的值,由于这里时j+1，所以应该是next[j]
        if(needle[i] == needle[j+1])	// 相同继续推进
            j++;
        next[i] = j;	// 将j(前缀的长度)赋值给next[i]
    }
}

用next数组匹配

int KMP(char *haystack, char *needle)
{
    if(strlen(needle) == 0)
        return 0;
    int *next = malloc(strlen(needle) * sizeof(int));
    get_next(next, needle);
    int j = -1;
    for(int i = 0; i < strlen(haystack); i++)
    {
        while(j >= 0 && haystack[i] != needle[j+1]) // 回溯
            j = next[j];
        if(haystack[i] == needle[j+1])  // 向前遍历
            j++;
        if(j == strlen(needle) - 1) // 判断是否匹配完成
            return(i - strlen(needle) + 1); // 返回haystack的下标
    }
    return -1;
}

C语言实现完整代码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int KMP(char *haystack, char *needle)
{
    if(strlen(needle) == 0)
        return 0;
    // get_next
    int *next = malloc(strlen(needle) * sizeof(int));
    int j = -1;
    next[0] = j;
    printf("next[]: [ %d ",next[0]);
    for(int i = 1; i < strlen(needle); i++)
    {
        while(j >= 0 && needle[i] != needle[j+1])
            j = next[j];
        if(needle[i] == needle[j+1])
            j++;
        next[i] = j;
        printf("%d ",next[i]);
    }
    printf("]\n");

    // KMP
    j = -1;
    for(int i = 0; i < strlen(haystack); i++)
    {
        while(j >= 0 && haystack[i] != needle[j+1])
            j = next[j];
        if(haystack[i] == needle[j+1])
            j++;
        if(j == strlen(needle) - 1)
        {
            free(next);
            return(i - strlen(needle) + 1);
        }
    }
    free(next);
    return -1;
}

int main(int argc, char **argv)
{
    if(argc != 3)
        fprintf(stderr, "Usage: ./a.out abcabcbb cab\n");

    int k = KMP(argv[1], argv[2]);
    printf("the index is: %d \n", k);
    return 0;
}