[原创]由结构二级指针所想到的

好久没有敲代码了，于是这两天找个题（求两个字符串的最长公共子串）练练。用的是最简单也最笨的方法，即扫描一个短串，用长串来匹配。本意是想练练结构体二级指针的，用结构来存储所有的公共子串，结果误打误撞发现了一些问题。

如上图，我分别画出了二级指针seq_p以及一级指针seq_p[0]、seq_p[1]的内存示意图，由图可知，虽然seq_p[0]的值等于*seq_p的值，但seq_p[1]的值并不等于(*seq_p)+1的值，因为(*seq_p)+1的值为*seq_p的值加上一个结构（8个字节）的偏移量，而内存是按字节编址的，因此(*seq_p)+1的值为0x551848≠0x5518b0。因此，如果之前是用seq_p[i]来malloc空间的话，之后用((*seq_p)+i)->seq来存储公共子串便会出现内存访问不到的段错误，反之亦然，务必保持前后一致，这里笔者建议使用seq_p[i]的形式。

由此得出结论，若p为二级指针，则p[i]的值不一定等于(*p)+i的值；若p为一级指针，则p[i]的值等于(*p)+i的值，这是因为为一级指针malloc空间的时候，分配的空间是连续的。

核心函数代码如下。

#include "findSeq.h"
typedef struct SEQ_type {
    char *seq;
    int len;
} SEQ;

void findSeq(const char *s1, const char *s2) {
    const char *temp1 = NULL;
    const char *temp2 = NULL;

    //使得temp1存取较短的字符串
    if (strlen(s1) < strlen(s2)) {
        temp1 = s1;
        temp2 = s2;
    } else {
        temp1 = s2;
        temp2 = s1;
    }

    //用结构体二级指针，用字符串数组指针会简单些，其实用结构体一级指针就可以了
    SEQ **seq_p = NULL;
    if ((seq_p = (SEQ **) malloc(strlen(temp1) * sizeof(SEQ *))) == NULL ) {
        printf("malloc error");
        return;
    }
    int i = 0;
    for (i = 0; i < strlen(temp1); i++) {
        if ((seq_p[i] = (SEQ *) malloc(sizeof(SEQ))) == NULL ) {
            printf("seq malloc error");
            return;
        } else
            ;
    }
    for (i = 0; i < strlen(temp1); i++) {
        if (((seq_p[i])->seq = (char *) malloc(
                (strlen(temp1) + 1) * sizeof(char))) == NULL ) {
            printf("Malloc Error");
            return;
        } else
            ;

        (seq_p[i])->len = 0;
    }
    //按较短的字符串来扫描较长的字符串从而发现最长公共子串
    const char *c1 = temp1;
    const char *c2 = temp2;
    char *tmp = NULL;
    int seqCnt = 0;
    i = 0;
    while (c1 != '\0') {
        tmp = (seq_p[i])->seq;
        while (*c1 != *c2 && *c2 != '\0') {
            c2++;
        }
        if (*c2 == '\0') {
            c1++;
            c2 = temp2;
            continue;
        }
        while (*c1 == *c2 && *c1 != '\0') {
            *(tmp++) = *c1;
            (seq_p[i])->len++;
            c1++;
            c2++;
        }
        *tmp = '\0';
        seqCnt++;
        if (*c1 == '\0')
            break;
        else {
            int backNum = strlen((seq_p[i])->seq);
            while (backNum-- != 1) {
                c1--;
            }
            c2 = temp2;
            i++;
        }
    }
    //排序，使得子串由长到短排列
    int tempForChange = 0;
    i = 0;
    int j = 0;
    while (i < seqCnt - 1) {
        j = i + 1;
        while (j < seqCnt) {
            if (seq_p[i]->len < seq_p[j]->len) {
                tempForChange = seq_p[i];
                seq_p[i] = seq_p[j];
                seq_p[j] = tempForChange;
            }
            j++;
        }
        i++;
    }
    //输出最长公共子串
    for (i = 0; i < seqCnt; i++) {
        if (seq_p[i]->len == seq_p[0]->len)
            printf("%s\n", seq_p[i]->seq);
        else
            break;
    }
    //释放指针
    for (i = 0; i < strlen(temp1); i++)
    {
        free(seq_p[i]);
        seq_p[i] = NULL;
    }

    free(seq_p);
    free(tmp);
    seq_p = NULL;
    tmp = NULL;

}