顺序存储

#define MAXLEN 255 //预定义最大串长为255
typedef struct{
  char ch[MAXLEN];
  int length;
}SSting

typedef struct{
	char *ch;  //按串的长度分配储存区，ch指向串的基地址
	int length;  //串的长度
}HString;
HString S;
S.ch =(char *) malloc(MAXLEN * sizeof(char));
S.length=0;

顺序存储的几种方案：

1. 数组+变量Length
2. 数组且ch[0]充当Length
3. 数组，但是没有Length变量，以字符'\0'表示结尾(对应ASCII码的0)
4. 数组，ch[0]废弃不要，有属性Length

顺序存储

#define MAXLEN 255 //预定义最大串长为255
typedef struct{
  char ch[MAXLEN];
  int length;
}SSting

typedef struct{
	char *ch;  //按串的长度分配储存区，ch指向串的基地址
	int length;  //串的长度
}HString;
HString S;
S.ch =(char *) malloc(MAXLEN * sizeof(char));
S.length=0;

顺序存储的几种方案：

1. 数组+变量Length
2. 数组且ch[0]充当Length
3. 数组，但是没有Length变量，以字符'\0'表示结尾(对应ASCII码的0)
4. 数组，ch[0]废弃不要，有属性Length

链式存储

一个结点对应一个字符

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

一个结点对应多个字符

typedef struct StringNode{
  char ch[4]; //每个结点存多个字符
  struct StringNode *next;
} StringNode,* String;

基本操作【基于顺序存储】

/**
 * @author five-five
 * @created 2022/5/26
 *
 */

#include "stdio.h"
#include "stdlib.h"
#include "stdbool.h"

#define MAXSIZE 255
typedef struct SString {
    char ch[MAXSIZE];
    int length;
} SString;

/**
 * 初始化字符串
 * @param pSString 字符串的指针的指针
 * @return true?空间分配成功:空间分配失败
 */
bool initString(SString **pSString) {
    (*pSString) = (SString *) malloc(sizeof(SString));
    if (NULL == (*pSString)) {
        return false;
    }
    (*pSString)->length = 0;
    return true;
}

/**
 * 添加元素
 * @param string 原字符串
 * @param c 要添加char集合
 * @param cLength char集合长度
 * @return true?添加成功:添加失败
 */
bool addString(SString *string, const char *c, const int cLength) {
    if (NULL == string) {
        return false;
    }
    for (int i = 0; i < cLength; ++i) {
        string->ch[i] = c[i];
    }
    string->length += cLength;
    return true;
}

/**
 * 根据起始位和长度求子串
 * @param string 原串指针
 * @param subString 子串指针
 * @param pos 起始位
 * @param len 长度
 * @return true?成功:失败
 */
bool subString(SString *string, SString *subString, int pos, int len) {
    if (string == NULL || pos + len > string->length) {
        return false;
    }
    for (int i = pos; i < (pos + len); ++i) {
        subString->ch[i - pos] = string->ch[i];
    }
    subString->length = len;
    return true;
}

/**
 * 比较左串和右串的大小(不是长度比较，是比较字符在ASCII的位置)
 * @param left 左串
 * @param right 右串
 * @return 0:相等,>0:left>right,<0:left<right
 */
int strCompare(SString *left, SString *right) {
    for (int i = 0; i < left->length && i < right->length; ++i) {
        if (left->ch[i] != right->ch[i]) {
            return left->ch[i] - right->ch[i];
        }
    }
    return left->length - right->length;
}

/**
 * 定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为-1。
 * @param left 左串
 * @param right 右串
 * @return 若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为-1。
 */
int indexOfString(SString *left, SString *right) {
    int i = 0;
    int lLength = left->length;
    int rLength = right->length;
    //暂存
    SString *sub = NULL;
    initString(&sub);
    while (i < lLength - rLength + 1) {
        subString(left, sub, i, rLength);
        if (strCompare(sub, right) == 0) {
            return i;
        }
        i++;
    }
    return -1;
}

int main() {
    SString *string1;
    SString *string2;
    initString(&string1);
    initString(&string2);
    string1->ch[0] = '1';
    string1->ch[1] = '1';
    string1->ch[2] = '2';
    string1->ch[3] = '3';
    string1->ch[4] = '4';
    string1->length = 5;
    subString(string1, string2, 0, string1->length);
    string2->ch[0] = '2';
    string2->ch[1] = '3';
    string2->ch[2] = '4';
    string2->length = 3;
    int index = indexOfString(string1, string2);
    printf("%d\n", index);
    return 1;
}