串的存储方式

2024年10月28日 463 字大概 2 分钟

顺序串(栈/堆)

2 种结构体的顺序串存储方式

定长顺序存储串(末尾没有\0)(栈)


typedef struct
{
    char ch[MAXLEN];
    int len;
} SString;

堆分配存储串(末尾有\0)(堆)


// 2. 变长顺序串(堆分配数组)
typedef struct
{
    char *ch;
    int len;
} HString;

// 创
HString *newHString(int size)
{
    HString *s = (HString *)malloc(sizeof(HString));
    s->ch = (char *)malloc(sizeof(char) * size);
    s->len = 0;
    return s;
}

// 销    
void freeHString(HString **s) {
    free((*s)->ch);// 销毁在堆申请的串
    free((*s));    // 销毁串结构体
    (*s) = NULL;   // 销毁悬浮指针
}

2 种纯数组的顺序串存储方式(生产不常见)

缺点: 只能存 255 个字符.

首元素存储长度, 末尾没有\0.

1
2
3

// 伪代码
char s = {MAXSIZE, 1, 2, 3, 4, ...};

直接存储. 末尾有\0.

1
2
3

// 伪代码
char s = {1, 2, 3, 4, ...};

串操作(栈/堆串)


// 复制
void copy(char *dest, char *src)
{
    while ((*dest++ = *src++))
        ;
}

// 判空
int isEmpty(char *str)
{
    return str[0] == '\0'
               ? TRUE
               : FALSE;
}

// 比较
int compare(char *str1, char *str2)
{
    while (*str1 && (*str1 == *str2)) // 当
    {
        str1++;
        str2++;
    }
    return *str1 - *str2; // 返回相应的差值
}

// 求长
int length_SS(char *str)
{
    int i = 0;
    while (str[i])
    {
        i++;
    }
    return i;
}

// 求子串
void substring(char *sub, char *str, int pos, int len) // 直接要求用户传入一个sub[len+1]
{
    for (int i = 0; i < len; i++)
    {
        sub[i] = str[pos + i]; // 末尾之前的元素
    }
    sub[len] = '\0'; // 末尾为\0
}

// 连接
void concatenate(char *dest, char *src)
{
    while (*dest)
        dest++; // 找到 dest 的末尾
    while ((*dest++ = *src++))
        ;
}

// 定位子串起始位置
int indexOf(char *str, char *sub)
{
    char *p1 = str;
    char *p2 = sub;
    int index = 0;
    while (*p1)
    {
        char *start = p1, *temp = p2;
        int tempIndex = index;
        while (*p1 && *temp && (*p1 == *temp))
        {
            p1++;
            temp++;
            tempIndex++;
        }
        if (!*temp)
            return index; // 找到字串，返回起始位置
        p1 = start + 1;   // 否则从下一个字符开始
        index++;
    }
    return -1; // 未找到
}

// 清空
void clear(char *str)
{
    str[0] = '\0'; // 反正下次可以直接覆盖写
}

// 销毁
void destory(char *str)
{
    free(str);
}

块链存储串(堆)


typedef struct StringNode
{
    char ch[BLOCK_SIZE];
    struct StringNode *next;
} StringNode, *String;