串---顺序串实现

顺序串详解

本文档将详细介绍顺序串的基本概念、实现原理及其在 C 语言中的具体应用。通过本指南，读者将了解如何使用顺序串进行各种字符串操作。

1. 什么是顺序串？

顺序串是一种用于存储字符串的数据结构，它使用一组连续的内存空间来保存字符串中的字符序列。顺序串通常由两部分组成：

• 一个字符数组 data[]，用于存储实际的字符数据。
• 一个整数 length，用于记录字符串的实际长度。

在本程序中，我们定义了一个名为 SequentialString 的结构体来表示顺序串。

typedef struct SequentialString {
    char data[MaxSize]; // 实际字符
    int length;         // 字符串长度
} SequentialString;

其中 MaxSize 是一个预定义的最大字符串长度常量。

2. 基本操作

2.1 生成串 (StrAssign)

此函数用于将一个 C 语言字符串转换为顺序串。

void StrAssign(SequentialString &s, const char str[]);

参数:

• s: 目标顺序串。
• str: 源 C 语言字符串。

功能:

• 复制 str 中的所有字符到 s.data[]，并设置 s.length 为实际复制的字符数量。

2.2 复制串 (StrCopy)

此函数用于将一个顺序串复制到另一个顺序串。

void StrCopy(SequentialString &s, SequentialString t);

参数:

• s: 目标顺序串。
• t: 源顺序串。

功能:

• 复制 t 的所有字符到 s.data[]，并设置 s.length 与 t.length 相同。

2.3 判断是否为空串 (StrEmpty)

此函数用于检查一个顺序串是否为空。

bool StrEmpty(SequentialString &s);

参数:

• s: 要检查的顺序串。

返回值:

• 如果 s.length 为 0，则返回 true；否则返回 false。

2.4 判断两个串是否相等 (StrEqual)

此函数用于检查两个顺序串是否相等。

bool StrEqual(SequentialString s, SequentialString t);

参数:

• s: 第一个顺序串。
• t: 第二个顺序串。

返回值:

• 如果两个串的长度相同且所有字符都相等，则返回 true；否则返回 false。

2.5 获取串的长度 (StrLength)

此函数用于获取一个顺序串的长度。

int StrLength(SequentialString s);

参数:

• s: 要获取长度的顺序串。

返回值:

• 返回 s.length。

2.6 串的连接 (Concat)

此函数用于将两个顺序串连接成一个新的顺序串。

SequentialString Concat(SequentialString s, SequentialString t);

参数:

• s: 第一个顺序串。
• t: 第二个顺序串。

返回值:

• 返回一个新的顺序串，该串包含 s 和 t 的所有字符。

2.7 获取子串 (SubStr)

此函数用于从一个顺序串中获取指定位置的子串。

SequentialString SubStr(SequentialString s, int i, int j);

参数:

• s: 原始顺序串。
• i: 子串的起始位置（1-indexed）。
• j: 子串的长度。

返回值:

• 返回一个新的顺序串，该串包含 s 从位置 i 开始的长度为 j 的子串。

2.8 子串插入 (InsertStr)

此函数用于在一个顺序串的指定位置插入另一个顺序串。

SequentialString InsertStr(SequentialString s1, SequentialString s2, int i);

参数:

• s1: 原始顺序串。
• s2: 要插入的顺序串。
• i: 插入位置（1-indexed）。

返回值:

• 返回一个新的顺序串，该串包含 s1 和在位置 i 插入的 s2。

2.9 子串删除 (DelStr)

此函数用于从一个顺序串中删除指定位置的子串。

SequentialString DelStr(SequentialString s, int i, int j);

参数:

• s: 原始顺序串。
• i: 子串的起始位置（1-indexed）。
• j: 子串的长度。

返回值:

• 返回一个新的顺序串，该串包含 s 除位置 i 开始的长度为 j 的子串外的所有字符。

2.10 子串替换 (RepStr)

此函数用于在一个顺序串的指定位置替换一个子串。

SequentialString RepStr(SequentialString s, int i, int j, SequentialString t);

参数:

• s: 原始顺序串。
• i: 要替换子串的起始位置（1-indexed）。
• j: 要替换子串的长度。
• t: 新的子串。

返回值:

• 返回一个新的顺序串，该串包含 s 除位置 i 开始的长度为 j 的子串被 t 替换外的所有字符。

2.11 输出串 (displayStr)

此函数用于显示一个顺序串的内容。

void displayStr(SequentialString s);

参数:

• s: 要显示的顺序串。

2.12 串的比较 (StrCompare)

此函数用于比较两个顺序串。

int StrCompare(SequentialString s, SequentialString t);

参数:

• s: 第一个顺序串。
• t: 第二个顺序串。

返回值:

• 如果 s 和 t 相等，返回 0；
• 如果 s 小于 t，返回负数；
• 如果 s 大于 t，返回正数。

3. 示例程序

下面是一个示例程序，演示了如何使用上述定义的功能。

#include <stdio.h>
#include <stdlib.h>

#define MaxSize 100

// 定义顺序串的结构体
typedef struct SequentialString {
    char data[MaxSize]; // 实际字符
    int length;         // 字符串长度
} SequentialString;

// 生成串
void StrAssign(SequentialString &s, const char str[]) {
    int i;
    for (i = 0; str[i] != '\0'; i++) { // 复制字符直到遇到空字符
        s.data[i] = str[i];
    }
    s.length = i; // 设置字符串长度
}

// 复制串
void StrCopy(SequentialString &s, SequentialString t) {
    int i;
    for (i = 0; i < t.length; i++) { // 复制字符
        s.data[i] = t.data[i];
    }
    s.length = t.length; // 设置字符串长度
}

// 判断是否为空串
bool StrEmpty(SequentialString &s) {
    return s.length == 0;
}

// 判断两个串是否相等
bool StrEqual(SequentialString s, SequentialString t) {
    bool same = true;
    int i;
    if (s.length != t.length) { // 检查长度是否相同
        same = false;
    } else {
        for (i = 0; i < s.length; i++) { // 逐个字符比较
            if (s.data[i] != t.data[i]) {
                same = false;
                break;
            }
        }
    }
    return same;
}

// 获取串的长度
int StrLength(SequentialString s) {
    return s.length;
}

// 串的连接
SequentialString Concat(SequentialString s, SequentialString t) {
    SequentialString str;
    int i;
    str.length = s.length + t.length; // 计算新字符串长度
    for (i = 0; i < s.length; i++) { // 复制第一个串
        str.data[i] = s.data[i];
    }
    for (i = 0; i < t.length; i++) { // 连接第二个串
        str.data[s.length + i] = t.data[i];
    }
    return str;
}

// 获取子串
SequentialString SubStr(SequentialString s, int i, int j) {
    int k;
    SequentialString str;
    str.length = 0;
    if (i <= 0 || j > s.length || j < 0 || i + j - 1 > s.length) { // 检查边界条件
        return str;
    }
    for (k = i - 1; k < i + j - 1; k++) { // 复制子串
        str.data[k - i + 1] = s.data[k];
    }
    str.length = j; // 设置子串长度
    return str;
}

// 子串插入
SequentialString InsertStr(SequentialString s1, SequentialString s2, int i) {
    int j;
    SequentialString str;
    str.length = 0;
    if (i <= 0 || i > s1.length + 1) { // 检查边界条件
        return str;
    }
    for (j = 0; j < i - 1; j++) { // 复制前缀
        str.data[j] = s1.data[j];
    }
    for (j = 0; j < s2.length; j++) { // 插入子串
        str.data[j + i - 1] = s2.data[j];
    }
    for (j = i - 1; j < s1.length; j++) { // 连接剩余部分
        str.data[j + s2.length] = s1.data[j];
    }
    str.length = s1.length + s2.length; // 更新长度
    return str;
}

// 子串删除
SequentialString DelStr(SequentialString s, int i, int j) {
    int k;
    SequentialString str;
    str.length = 0;
    if (i <= 0 || j > s.length || i + j > s.length + 1) { // 检查边界条件
        return str;
    }
    for (k = 0; k < i - 1; k++) { // 复制前缀
        str.data[k] = s.data[k];
    }
    for (k = i + j - 1; k < s.length; k++) { // 复制后缀
        str.data[k - j] = s.data[k];
    }
    str.length = s.length - j; // 更新长度
    return str;
}

// 子串替换
SequentialString RepStr(SequentialString s, int i, int j, SequentialString t) {
    int k;
    SequentialString str;
    str.length = 0;
    if (i <= 0 || j > s.length || i + j - 1 > s.length + 1) { // 检查边界条件
        return str;
    }
    for (k = 0; k < i - 1; k++) { // 复制前缀
        str.data[k] = s.data[k];
    }
    for (k = 0; k < t.length; k++) { // 替换子串
        str.data[i + k - 1] = t.data[k];
    }
    for (k = i + j - 1; k < s.length; k++) { // 连接剩余部分
        str.data[t.length + k - j] = s.data[k];
    }
    str.length = s.length - j + t.length; // 更新长度
    return str;
}

// 输出串
void displayStr(SequentialString s) {
    int i;
    for (i = 0; i < s.length; i++) { // 输出每个字符
        printf("%c", s.data[i]);
    }
    printf("\n");
}

// 串的比较
int StrCompare(SequentialString s, SequentialString t) {
    int i;
    int commonLength;
    if (s.length < t.length) {
        commonLength = s.length;
    } else {
        commonLength = t.length;
    }
    for (i = 0; i < commonLength; i++) { // 逐个字符比较
        if (s.data[i] > t.data[i]) {
            return 1;
        } else if (s.data[i] < t.data[i]) {
            return -1;
        }
    }
    if (s.length == t.length) {
        return 0;
    } else if (s.length > t.length) {
        return 1;
    } else {
        return -1;
    }
}

int main() {
    SequentialString s, t;
    char input[MaxSize];
    
    // 用户输入第一个串
    printf("请输入第一个字符串: ");
    scanf("%s", input);
    StrAssign(s, input);
    
    // 用户输入第二个串
    printf("请输入第二个字符串: ");
    scanf("%s", input);
    StrAssign(t, input);

    // 显示两个串
    printf("第一个字符串: ");
    displayStr(s);
    printf("第二个字符串: ");
    displayStr(t);

    // 检查是否为空串
    if (StrEmpty(s)) {
        printf("第一个串为空串。\n");
    } else {
        printf("第一个串不为空串。\n");
    }

    if (StrEmpty(t)) {
        printf("第二个串为空串。\n");
    } else {
        printf("第二个串不为空串。\n");
    }

    // 比较两个串
    int result = StrCompare(s, t);
    if (result == 0) {
        printf("两个串相等。\n");
    } else if (result < 0) {
        printf("第一个串小于第二个串。\n");
    } else {
        printf("第一个串大于第二个串。\n");
    }

    // 计算两个串的长度
    printf("第一个串的长度为: %d\n", StrLength(s));
    printf("第二个串的长度为: %d\n", StrLength(t));

    // 连接两个串
    SequentialString concatenated = Concat(s, t);
    printf("连接后的字符串: ");
    displayStr(concatenated);

    // 获取子串
    int start, length;
    printf("请输入子串起始位置 (1-%d): ", s.length);
    scanf("%d", &start);
    printf("请输入子串长度: ");
    scanf("%d", &length);
    SequentialString substring = SubStr(s, start, length);
    printf("子串为: ");
    displayStr(substring);

    // 插入子串
    printf("请输入插入位置 (1-%d): ", StrLength(s) + 1);
    scanf("%d", &start);
    SequentialString inserted = InsertStr(s, t, start);
    printf("插入后的字符串: ");
    displayStr(inserted);

    // 删除子串
    printf("请输入删除起始位置 (1-%d): ", s.length);
    scanf("%d", &start);
    printf("请输入删除长度: ");
    scanf("%d", &length);
    SequentialString deleted = DelStr(s, start, length);
    printf("删除后的字符串: ");
    displayStr(deleted);

    // 替换子串
    printf("请输入替换起始位置 (1-%d): ", s.length);
    scanf("%d", &start);
    printf("请输入替换长度: ");
    scanf("%d", &length);
    SequentialString replaced = RepStr(s, start, length, t);
    printf("替换后的字符串: ");
    displayStr(replaced);

    return 0;
}

4. 使用说明

1. 编译并运行上述示例程序。
2. 根据提示输入两个字符串。
3. 观察并理解各个操作的结果。

5. 总结

通过本文档，您可以了解到顺序串的基本概念和常用操作。使用这些操作，您可以轻松地处理字符串数据，进行各种字符串相关的任务。希望这份指南能够帮助您更好地理解和使用顺序串。