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

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

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

2. 堆分配存储串(末尾有\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 个字符.

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

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

2. 直接存储. 末尾有\0.

   // 伪代码
   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);
}