考研数据结构-串(串的基本操作)

串就是字符串(String)的简称。串是在计算机领域中一个非常常见且重要的数据结构。

---

串的定义与存储结构

串的定义

char str[] = "123";

串中的任意连续字符组成的子序列为原始字符串的--子串，包含子串的串称为--主串。由许多空格组成的串称为--空格串。

串的存储结构

定长顺序存储表示

#define maxSize 10

typedef struct Str1
{
    char str[maxSize+1]; // 因为 \0 会占用一个位置 所以+1
    int length;
}Str1;

这里注意，因为str会用‘\0’结尾，会导致占用一个位置，所以需要maxSize+1。

变长分配存储表示

变长分配存储表示又称为动态分配存储表示，可以根据需要，在执行过程中动态分配。

typedef struct Str1
{
    char *ch; // 指向动态分配存储区首地址的字符指针
    int length;
}Str1;

与链表一样，使用这种存储方式需要使用malloc()来分配存储空间（考研数据结构-线性表），分配空间可以使用free()函数进行释放。

可以看出，变长分配存储十分灵活，可以根据需要来设定，所以在串的处理中更为常用。

---

串的基本操作

赋值操作

int strassign(Str *str, char *ch){

    if (str->ch)   // 释放原串空间
    {
        /* code */
        free(str->ch);
    }

    int len = 0;
    char *c = ch;

    while (*c)  // 求ch串的长度
    {
        /* code */
        ++len;
        ++c;
    }

    if(len == 0)
    {   // 如果为空串。则直接返回空串
        str->ch = NULL;
        str->length = 0;
        return 1;
    }else{
        str->ch = (char*)malloc(sizeof(char) * (len+1));
        // len+1 分配空间需要多加一个 ’\0' 字符
        if (str->ch==NULL)
        {
            /* code */
            return 0;
        }else{
            c = ch;
            for (int i = 0; i <= len; ++i,++c)
            {
                /* code */
                str->ch[i] = *c;
            }
            str->length = len;
            return 1;
            
        }
        
    }
    
}

stressing(str,"123");

取串长度的操作

int strlength(Str str)
{
    return str.length;
}

串比较操作

int strcompare(Str2 s1,Str2 s2)
{
    for (int i = 0; i < s1.length && i < s2.length; ++i)
    {
        /* code */
        if (s1.ch[i] != s2.ch[i])
        {
            /* code */
            return s1.ch[i] - s2.ch[i];
        }
     
    }
     return s1.length - s2.length;

}

串连接操作

int concat(Str2 *str,Str2 str1,Str2 str2)
{
    if (str->ch)
    {
        /* code */
        free(str->ch); // 释放原串的空间
        str->ch = NULL;
    }

    str->ch = (char*)malloc(sizeof(char) * (str1.length+str2.length+1));

    if (str->ch == NULL)
    {
        /* code */
        return 0;
    }

    int i = 0;
    
    while (i < str1.length)
    {
        /* code */
        str->ch[i] = str1.ch[i];
        ++i;
    }
    
    int j = 0;

    while (j <= str2.length) // <= 需要将‘\0’一起复制
    {
        /* code */
        str->ch[i+j] = str2.ch[j];
        ++j;
    }
    
    str->length = str1.length + str2.length;
    return 1;
    
}

求子串操作

int substring(Str2 *substr, Str2 str,int pos,int len) // str串 pos开始 长度len 
{

    if (pos<0 || pos >= str.length || len<0 || len>str.length-pos)
    {
        /* code */
        return 0;
    }

    if (substr->ch)
    {
        /* code */
        free(substr->ch);
        substr->ch = NULL;
    }
    
    if (len == 0)
    {
        /* code */
        substr->ch = NULL;
        substr->length = 0;
        return 1;
    }else{

        substr->ch = (char*)malloc(sizeof(char)*(len+1));
        int i = pos;
        int j = 0;

        while (i < pos+len)
        {
            /* code */
            substr->ch[j] = str.ch[i];
            ++i;
            ++j;
        }

        substr->ch[j] = '\0';
        substr->length = len;
        return 1;
        
    }

}

串清空操作

int clearstring(Str *str)
{
    if (str->ch)
    {
        /* code */
        free(str->ch);
        str->ch = NULL;
    }
    str->length = 0;
    return 1;
    
}