当前位置： 首页 > article >正文

数据结构-串-顺序结构实现

article 2024/12/25 6:05:46

完整代码：

/*
ADT 串（string）
Data
	串中元素仅由一个字符组成，相邻元素具有前驱和后继关系。
Operation
	StrAssign(T, *chars)：生成一个其值等于字符串字符串常量chars的串T。
	StrCopy(T, S)：串S存在，由串S复制得串T。
	ClearString(S)：串S存在，将串清空。
	StringEmpty(S)：若串S为空，返回true，否则返回false。
	StrLength(S)：返回S的元素个数，即串的长度。
	StrCompare(S, T)：若S>T，返回值>0，若S=T，返回值0，若S>T，返回值<0.
	Concat(T, S1, S2)：用T返回由S1和S2联接而成的新串。
	SubString(Sub, S, pos, len)：串S存在，1<=pos<=StrLength(S)，且0<=len<=StrLength(S)-pos+1，用Sub返回串S的第pos个字符起长度为len的子串。
	Index(S, T, pos)：串S和T存在，T是非空字符串，1<=pos<=StrLength(S)。若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置，否则返回0。
	Replace(S, T, V)：串S、T和V存在，T是非空串。用V替换主串S中出现的所有与相等的不重叠的子串。
	StrInsert(S, pos, T)：串S和T存在，1<=pos<=StrLength(S) + 1。在串S的第pos个字符之间插入串T。
	StrDelete(S, pos, len)：串S存在，1<=pos<=StrLength(S) - len + 1。从串S中删除第pos个字符起长度为len的子串。
endADT
*/
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:6013)

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

#define MAXSIZE 20 
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

typedef char String[MAXSIZE + 1];	/* 0号单元存放串的长度 */

/* 生成一个其值等于chars的串T */
Status StrAssign(String T, char* chars) {
	int i;
	if (strlen(chars) > MAXSIZE)
		return ERROR;
	else {
		T[0] = strlen(chars);
		for (i = 1; i <= T[0]; i++)
			T[i] = *(chars + i - 1);
		return OK;
	}
}

/* 由串S复制得串T。*/
Status StrCopy(String T, String S) {
	int i;
	for (i = 0; i <= S[0]; i++)
		T[i] = S[i];
	return OK;
}

/* 串S存在，将串清空 */
Status ClearString(String S) {
	S[0] = 0;
	return OK;
}

/* 若串S为空，返回true，否则返回false */
Status StringEmpty(String S) {
	if (S[0] == 0)
		return TRUE;
	return FALSE;
}

/* 返回S的元素个数，即串的长度 */
int StrLength(String S) {
	return S[0];
}

/* 若S>T，返回值>0，若S=T，返回值0，若S>T，返回值<0 */
int StrCompare(String S, String T) {
	int i;
	for (i = 1; i <= S[0] && i <= T[0]; i++)
		if (S[i] != T[i])
			return S[i] - T[i];
	return S[0] - T[0];
}

/* 用T返回由S1和S2联接而成的新串 */
Status Concat(String T, String S1, String S2) {
	T[0] = S1[0] + S2[0];
	for (int i = 1; i <= T[0]; i++) {
		if (i == MAXSIZE) {
			T[0] = MAXSIZE;
			return ERROR;
		}
		if (i > S1[0])
			T[i] = S2[i - S1[0]];
		else
			T[i] = S1[i];
	}
	return OK;
}

/*串S存在，1<=pos<=StrLength(S)，且0<=len<=StrLength(S)-pos+1，
用Sub返回串S的第pos个字符起长度为len的子串。 */
Status SubString(String Sub, String S, int pos, int len) {
	Sub[0] = len;
	for (int j = 1, i = pos; i <= len; i++, j++)
		Sub[j] = S[i];
	return OK;
}

Status Sindex(String A, String B, int i, int j) {
	// 获取主串A从当前位置i开始剩余的长度
	int remainLenA = A[0] - i + 1;
	if (remainLenA < B[0])
		return 0;
	if (i <= A[0] && j <= B[0]) {
		if (A[i] == B[j])
			return Sindex(A, B, i + 1, j + 1);
		else
			return Sindex(A, B, i - j + 2, 1);
	}
	else
		if (j > B[0])
			return i - B[0];
}

/* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0。 */
/* 其中,T非空,1≤pos≤StrLength(S)。 */
int Index(String S, String T, int pos) { //普通的模式匹配
	int i = pos;
	int j = 1;
	while (i <= S[0] && j <= T[0]) {
		if (S[i] == T[j]) {
			i++;
			j++;
		}
		else {
			i = i - j + 2; // 退回到上次匹配首位的下一位
			j = 1;
		}
	}
	if (j > T[0])
		return i - T[0];
	return 0;
}

/*  初始条件: 串S和T存在,1≤pos≤StrLength(S)+1 */
/*  操作结果: 在串S的第pos个字符之前插入串T。完全插入返回TRUE,部分插入返回FALSE */
Status StrInsert(String S, int pos, String T) {
	int i;
	if (pos<1 || pos>S[0] + 1)
		return ERROR;
	if (S[0] + T[0] <= MAXSIZE) {
		/* 完全插入 */
		for (i = S[0]; i >= pos; i--)
			S[i + T[0]] = S[i];
		for (i = pos; i < pos + T[0]; i++)
			S[i] = T[i - pos + 1];
		S[0] = S[0] + T[0];
		return TRUE;
	}
	else {
		/* 部分插入 */
		for (i = 0; i < S[0] - pos + 1; i++)
			S[MAXSIZE - i] = S[S[0] - i];
		for (i = pos; i < pos + (MAXSIZE - S[0]); i++)
			S[i] = T[i - pos + 1];
		S[0] = MAXSIZE;
		return FALSE;
	}
}

/*  初始条件: 串S存在,1≤pos≤StrLength(S)-len+1 */
/*  操作结果: 从串S中删除第pos个字符起长度为len的子串 */
Status StrDelete(String S, int pos, int len) {
	if (S[0] - pos < len)
		return ERROR;
	int i;
	for (i = pos; i <= S[0]-len; i++)
		S[i] = S[i + len];
	S[0] -= len;
	return OK;
}

/* 串S、T和V存在，T是非空串。
用V替换主串S中出现的所有T与相等的不重叠的子串。 */
Status Replace(String S, String T, String  V) {
	if (StringEmpty(T))
		return ERROR;
	int pos;
	int len = StrLength(T);
	while (pos = Index(S,T,1)) {
		StrDelete(S, pos, len);
		StrInsert(S, pos, V);
	}
	return OK;
}

/*  输出字符串T */
void StrPrint(String T){
	int i;
	for (i = 1; i <= T[0]; i++)
		printf("%c", T[i]);
	printf("\n");
}

void test(String A,String B,String C){
	printf("[0]\t%d\t%d\t%d\n", A[0],B[0],C[0]);
    for (int i = 1; i <= MAXSIZE; i++) {
        printf("[%d]\t%c\t%c\t%c\n", i, A[i], B[i], C[i]);
    }
}

// 打印菜单函数
void printMenu() {
    printf("===================菜单-顺序存储串===============================\n");
    printf("(1)生成串\t\t\t(2)复制串\t\t\t|\n");
    printf("(3)清空串\t\t\t(4)判断串是否为空\t\t|\n");
    printf("(5)获取串长度\t\t\t(6)比较串大小\t\t\t|\n");
    printf("(7)连接串\t\t\t(8)获取子串\t\t\t|\n");
    printf("(9)查找子串位置\t\t\t(10)替换子串\t\t\t|\n");
    printf("(11)插入子串\t\t\t(12)删除子串\t\t\t|\n");
    printf("(13)打印串内容\t\t\t(14)查看串存储情况（调试用）\t|\n");
    printf("(15)菜单\t\t\t(0)退出\t\t\t\t|\n");
    printf("=================================================================\n");
}

// 菜单函数
void menu() {
    String str1, str2, str3;  // 定义几个串用于操作
    char inputChars[MAXSIZE + 1];
    char inputChars_[MAXSIZE + 1];
    int choice, pos, len;
    printMenu();
    while (1) {
        printf("请输入你的选择: ");
        scanf("%d", &choice);

        switch (choice) {
        case 15:
            printMenu();
            break;
        case 99:
            StrAssign(str1, "ABCDEFGH");
            StrAssign(str2, "DE");
            StrAssign(str3, "ggb");
            break;
        case 1:
            // 可选择生成str1、str2或者str3
            printf("请选择生成串（1表示str1，2表示str2，3表示str3）: ");
            int target;
            scanf("%d", &target);
            printf("请输入要生成的串内容: ");
            scanf("%s", inputChars);
            if (target == 1) {
                if (StrAssign(str1, inputChars) == OK) {
                    printf("str1生成成功\n");
                }
                else {
                    printf("输入串过长，生成str1失败\n");
                }
            }
            else if (target == 2) {
                if (StrAssign(str2, inputChars) == OK) {
                    printf("str2生成成功\n");
                }
                else {
                    printf("输入串过长，生成str2失败\n");
                }
            }
            else if (target == 3) {
                if (StrAssign(str3, inputChars) == OK) {
                    printf("str3生成成功\n");
                }
                else {
                    printf("输入串过长，生成str3失败\n");
                }
            }
            else {
                printf("选择无效，请重新输入\n");
            }
            break;
        case 2:
            // 可选择将str2或str3复制到str1
            printf("请选择要复制的源串（2表示str2，3表示str3）: ");
            int source;
            scanf("%d", &source);
            if (source == 2 && StrLength(str2) > 0) {
                StrCopy(str1, str2);
                printf("str2复制到str1成功\n");
            }
            else if (source == 3 && StrLength(str3) > 0) {
                StrCopy(str1, str3);
                printf("str3复制到str1成功\n");
            }
            else {
                printf("选择的源串为空，无法复制到str1\n");
            }
            break;
        case 3:
            ClearString(str1);
            printf("str1已清空\n");
            break;
        case 4:
            // 判断str1、str2、str3是否为空并输出相应提示
            printf("str1");
            if (StringEmpty(str1)) {
                printf("为空\n");
            }
            else {
                printf("不为空\n");
            }
            printf("str2");
            if (StringEmpty(str2)) {
                printf("为空\n");
            }
            else {
                printf("不为空\n");
            }
            printf("str3");
            if (StringEmpty(str3)) {
                printf("为空\n");
            }
            else {
                printf("不为空\n");
            }
            break;
        case 5:
            // 输出str1、str2、str3的长度
            printf("str1的长度为: %d\n", StrLength(str1));
            printf("str2的长度为: %d\n", StrLength(str2));
            printf("str3的长度为: %d\n", StrLength(str3));
            break;
        case 6:
            if (StrLength(str1) > 0 && StrLength(str2) > 0) {
                int result = StrCompare(str1, str2);
                if (result > 0) {
                    printf("str1大于str2\n");
                }
                else if (result < 0) {
                    printf("str1小于str2\n");
                }
                else {
                    printf("str1等于str2\n");
                }
            }
            else {
                printf("参与比较的串长度不符合要求\n");
            }
            break;
        case 7:
            if (StrLength(str1) > 0 && StrLength(str2) > 0) {
                if (Concat(str1, str2, str3) == OK) {
                    printf("串连接成功，结果存于str1中\n");
                }
                else {
                    printf("连接后串长度超出限制，连接失败\n");
                }
            }
            else {
                printf("参与连接的串长度不符合要求\n");
            }
            break;
        case 8:
            if (StrLength(str1) > 0) {
                printf("请输入在str1中获取子串的起始位置和长度（空格隔开）: ");
                scanf("%d %d", &pos, &len);
                if (1 <= pos && pos <= StrLength(str1) && 0 <= len && len <= StrLength(str1) - pos + 1) {
                    Status subStatus = SubString(str2, str1, pos, len);
                    if (subStatus == OK) {
                        printf("从str1获取子串成功\n");
                        StrPrint(str2);
                    }
                    else {
                        printf("获取子串操作出现未知错误\n");
                    }
                }
                else {
                    printf("输入的位置或长度不符合要求\n");
                }
            }
            else {
                printf("str1为空，无法获取子串\n");
            }
            break;
        case 9:
            if (StrLength(str1) > 0 && StrLength(str2) > 0) {
                printf("请输入查找子串str2在str1中的起始位置: ");
                scanf("%d", &pos);
                int index = Index(str1, str2, pos);
                if (index > 0) {
                    printf("子串在str1中位置为: %d\n", index);
                }
                else {
                    printf("str1中不存在该子串\n");
                }
            }
            else {
                printf("参与查找的串长度不符合要求\n");
            }
            break;
        case 10:
            if (StrLength(str1) > 0 && StrLength(str2) > 0 && StrLength(str3) > 0) {
                Status replaceStatus = Replace(str1, str2, str3);
                if (replaceStatus == OK) {
                    printf("用str3替换str1中str2子串成功\n");
                }
                else {
                    printf("替换操作出现错误，可能原串或替换串不符合要求\n");
                }
            }
            else {
                printf("参与替换的串长度不符合要求\n");
            }
            break;
        case 11:
            if (StrLength(str1) > 0 && StrLength(str2) > 0) {
                printf("请输入在str1中插入str2的位置: ");
                scanf("%d", &pos);
                Status insertStatus = StrInsert(str1, pos, str2);
                if (insertStatus == TRUE) {
                    printf("str2插入str1成功\n");
                }
                else {
                    printf("插入操作出现错误，可能位置或串长度超出限制\n");
                }
            }
            else {
                printf("参与插入的串长度不符合要求\n");
            }
            break;
        case 12:
            if (StrLength(str1) > 0 && StrLength(str2) > 0) {
                printf("请输入在str1中删除字串的起始位置和长度（空格隔开）: ");
                scanf("%d %d", &pos, &len);
                Status deleteStatus = StrDelete(str1, pos, len);
                if (deleteStatus == OK) {
                    printf("删除成功\n");
                }
                else {
                    printf("删除操作出现错误，可能位置或长度不符合要求\n");
                }
            }
            else {
                printf("主串或要删除的子串不符合要求，无法删除\n");
            }
            break;
        case 13:
            // 输出str1、str2、str3的内容
            printf("str1: ");
            StrPrint(str1);
            printf("str2: ");
            StrPrint(str2);
            printf("str3: ");
            StrPrint(str3);
            break;
        case 14:
            test(str1, str2, str3);
            break;
        case 0:
            printf("程序已退出\n");
            exit(0);
        default:
            printf("输入的选择无效，请重新输入\n");
            break;
        }
    }
}

int main() {
    menu();
    return 0;
}

效果图：

在这里插入图片描述

一、顺序存储串是什么？

顺序存储串是将串中的元素按照顺序依次存储在一块连续的存储空间中的数据结构。其中，串里的元素仅由一个字符组成，并且相邻元素之间具有前驱和后继关系。这种存储方式便于我们对串进行各种操作，通过数组来实现顺序存储，利用数组的下标可以快速定位到串中的各个字符元素。

二、功能函数详解

（一）生成串函数 - StrAssign(T, *chars)

Status StrAssign(String T, char* chars) {
    int i;
    if (strlen(chars) > MAXSIZE)
        return ERROR;
    else {
        T[0] = strlen(chars);
        for (i = 1; i <= T[0]; i++)
            T[i] = *(chars + i - 1);
        return OK;
    }
}

作用：它的功能是生成一个其值等于给定字符串常量 chars 的串 T。首先会判断输入的字符串长度是否超过了预先设定的最大长度 MAXSIZE，如果超过则返回错误标识 ERROR。若未超过，就将字符串长度存放在 T 的 0 号单元（这是一种巧妙的设计，便于后续操作快速获取串长度），然后逐个字符将 chars 的内容复制到 T 中，最后返回表示操作成功的 OK 标识。

实现细节：重点在于对长度的判断以及字符的复制操作。通过 strlen 函数获取输入字符串的实际长度并与 MAXSIZE 对比，确保不会出现越界存储的情况。复制字符时，利用指针运算和循环依次将字符赋值到对应的位置。

（二）复制串函数 - StrCopy(T, S)

Status StrCopy(String T, String S) {
    int i;
    for (i = 0; i <= S[0]; i++)
        T[i] = S[i];
    return OK;
}

作用：当串 S 存在时，此函数可以依据串 S 的内容复制得到串 T，简单来说就是把 S 的所有元素（包括表示长度的 0 号单元内容）原样复制到 T 中，最后返回操作成功的标识。

实现细节：通过一个循环，从 0 号单元开始，依次将 S 中每个位置的元素赋值给 T 对应的位置，循环的结束条件是遍历完 S 的所有元素，即达到 S 的长度（存储在 S[0] 中）为止。

（三）清空串函数 - ClearString(S)

Status ClearString(String S) {
    S[0] = 0;
    return OK;
}

作用：针对已经存在的串 S，将其清空。这里的清空操作其实就是把表示串长度的 0 号单元的值设为 0，从逻辑上表示这个串不再包含任何有效字符了，同时返回操作成功的提示。

实现细节：仅仅只需将 S 的 0 号单元赋值为 0，因为后续基于串长度来操作的其他函数，看到长度为 0 就会认为这个串是空的，从而达到清空的效果。

（四）判断串是否为空函数 - StringEmpty(S)

Status StringEmpty(String S) {
    if (S[0] == 0)
        return TRUE;
    return FALSE;
}

作用：用于判断给定的串 S 是否为空。如果 S 的 0 号单元（存储长度的位置）的值为 0，那就意味着这个串没有实际的字符元素，返回 TRUE 表示为空；否则返回 FALSE，表示串不为空。

实现细节：只需简单地检查 S[0] 的值，依据其是否为 0 来做出相应的返回，是一个很简洁的判断逻辑。

（五）获取串长度函数 - StrLength(S)

int StrLength(String S) {
    return S[0];
}

作用：能够返回串 S 的元素个数，也就是串的长度。由于我们把串长度存储在了 S 的 0 号单元，所以直接返回这个位置的值即可获取到串的长度信息。

实现细节：利用了之前存储串长度的设计，通过返回 S[0] 就能轻松得到串 S 的长度，无需复杂的计算或者遍历操作。

（六）比较串大小函数 - StrCompare(S, T)

int StrCompare(String S, String T) {
    int i;
    for (i = 1; i <= S[0] && i <= T[0]; i++)
        if (S[i]!= T[i])
            return S[i] - T[i];
    return S[0] - T[0];
}

作用：用于比较两个串 S 和 T 的大小关系。按照字典序（字符的 ASCII 码值顺序）依次比较对应位置的字符，如果在某个位置发现不同的字符，就根据这两个不同字符的 ASCII 码差值来返回结果（大于返回值大于 0，等于返回 0，小于返回值小于 0）。若前面部分字符都相同，则依据两个串的长度差值来确定大小关系。

实现细节：通过一个循环从两个串的第一个字符（下标为 1，因为 0 号单元存储长度）开始比较，只要两个串都还有字符且对应位置字符相同就继续比较下一个位置。一旦发现不同字符，直接返回它们的 ASCII 码差值。如果循环结束都没发现不同字符，那就返回两个串长度的差值来确定大小。

（七）连接串函数 - Concat(T, S1, S2)

Status Concat(String T, String S1, String S2) {
    T[0] = S1[0] + S2[0];
    for (int i = 1; i <= T[0]; i++) {
        if (i == MAXSIZE) {
            T[0] = MAXSIZE;
            return ERROR;
        }
        if (i > S1[0])
            T[i] = S2[i - S1[0]];
        else
            T[i] = S1[i];
    }
    return OK;
}

作用：用 T 返回由 S1 和 S2 联接而成的新串。先计算出连接后串的预计长度并存储在 T 的 0 号单元，然后按照顺序将 S1 和 S2 的字符依次复制到 T 中。不过要注意，如果连接后的长度超过了 MAXSIZE，就会进行相应处理并返回错误标识。

实现细节：首先计算长度并赋值给 T[0]，接着在循环中，通过判断当前位置 i 与 S1 长度的关系来决定是从 S1 还是 S2 中取字符复制到 T 中。如果长度超出限制，及时调整 T[0] 的值并返回错误，确保不会出现越界存储的情况。

（八）获取子串函数 - SubString(Sub, S, pos, len)

Status SubString(String Sub, String S, int pos, int len) {
    Sub[0] = len;
    for (int j = 1, i = pos; i <= len; i++, j++)
        Sub[j] = S[i];
    return OK;
}

作用：在串 S 存在的前提下，按照给定的起始位置 pos 和长度 len（需满足相应条件），用 Sub 返回串 S 的第 pos 个字符起长度为 len 的子串。

实现细节：先将子串的长度 len 存储到 Sub 的 0 号单元，然后通过循环，从 S 的指定起始位置 pos 开始，逐个字符复制到 Sub 中，直到复制了 len 个字符为止，最后返回操作成功的标识。

（九）查找子串位置函数 - Index(S, T, pos)

int Index(String S, String T, int pos) { //普通的模式匹配
    int i = pos;
    int j = 1;
    while (i <= S[0] && j <= T[0]) {
        if (S[i] == T[j]) {
            i++;
            j++;
        }
        else {
            i = i - j + 2; // 退回到上次匹配首位的下一位
            j = 1;
        }
    }
    if (j > T[0])
        return i - T[0];
    return 0;
}

作用：对于存在的串 S 和非空串 T，在从 S 的第 pos 个字符开始往后查找，若主串 S 中存在和串 T 值相同的子串，则返回它在主串 S 中第 pos 个字符之后第一次出现的位置；若不存在这样的子串，则返回 0。

实现细节：采用了一种简单的模式匹配算法，通过两个指针 i（遍历主串 S）和 j（遍历子串 T）来逐个比较字符。如果匹配成功就继续往后比较，一旦不匹配，就将 i 回溯到合适的位置（上次匹配首位的下一位），然后 j 重新从 1 开始比较。当 j 超出子串 T 的长度时，说明找到了匹配的子串，返回相应位置；若遍历完主串 S 都没找到匹配，则返回 0。

（十）替换子串函数 - Replace(S, T, V)

Status Replace(String S, String T, String V) {
    if (StringEmpty(T))
        return ERROR;
    int pos;
    int len = StrLength(T);
    while (pos = Index(S, T, 1)) {
        StrDelete(S, pos, len);
        StrInsert(S, pos, V);
    }
    return OK;
}

作用：在串 S、T 和 V 都存在且 T 是非空串的情况下，用 V 替换主串 S 中出现的所有与 T 相等的不重叠的子串。

实现细节：首先判断替换的子串 T 是否为空，为空则直接返回错误。然后通过循环，不断查找 T 在 S 中的位置（从起始位置 1 开始查找），每次找到后，先删除 S 中对应的子串 T，再在相同位置插入替换串 V，直到 S 中不存在 T 为止，最后返回操作成功的标识。

（十一）插入子串函数 - StrInsert(S, pos, T)

Status StrInsert(String S, int pos, String T) {
    int i;
    if (pos < 1 || pos > S[0] + 1)
        return ERROR;
    if (S[0] + T[0] <= MAXSIZE) {
        /* 完全插入 */
        for (i = S[0]; i >= pos; i--)
            S[i + T[0]] = S[i];
        for (i = pos; i < pos + T[0]; i++)
            S[i] = T[i - pos + 1];
        S[0] = S[0] + T[0];
        return TRUE;
    }
    else {
        /* 部分插入 */
        for (i = 0; i < S[0] - pos + 1; i++)
            S[MAXSIZE - i] = S[S[0] - i];
        for (i = pos; i < pos + (MAXSIZE - S[0]); i++)
            S[i] = T[i - pos + 1];
        S[0] = MAXSIZE;
        return FALSE;
    }
}

作用：当串 S 和 T 都存在，且给定的插入位置 pos 满足条件时，在串 S 的第 pos 个字符之前插入串 T。如果插入后串长度未超过 MAXSIZE 则完全插入并返回 TRUE；若超过了则进行部分插入处理并返回 FALSE。

实现细节：先对插入位置 pos 进行合法性判断，不符合要求则返回错误。然后根据能否完全插入分为两种情况处理，完全插入时，先将 S 中插入位置及之后的元素往后移动合适的距离，再把 T 的元素依次插入到对应位置，并更新 S 的长度；部分插入时，对 S 的末尾部分元素进行调整，尽量插入 T 的部分元素，并将 S 的长度设为 MAXSIZE，最后返回相应的操作结果标识。

（十二）删除子串函数 - StrDelete(S, pos, len)

Status StrDelete(String S, int pos, int len) {
    if (S[0] - pos < len)
        return ERROR;
    int i;
    for (i = pos; i <= S[0] - len; i++)
        S[i] = S[i + len];
    S[0] -= len;
    return OK;
}

作用：在串 S 存在且给定的起始位置 pos 和长度 len 满足条件时，从串 S 中删除第 pos 个字符起长度为 len 的子串，并返回操作成功的标识。

实现细节：首先判断要删除的子串是否超出了 S 的范围，如果超出则返回错误。然后通过循环，将删除位置之后的元素往前移动 len 个位置，覆盖掉要删除的子串部分，最后更新 S 的长度（减去删除的子串长度）来体现删除操作后的结果。

（十三）打印串内容函数 - StrPrint(T)

void StrPrint(String T) {
    int i;
    for (i = 1; i <= T[0]; i++)
        printf("%c", T[i]);
    printf("\n");
}

作用：用于输出字符串 T 的内容，将 T 中从 1 号单元开始到长度为 T[0] 的所有字符依次打印出来，方便查看串的实际字符组成情况，并且最后会换行，使输出更加清晰美观。

实现细节：通过一个简单的循环，按照顺序逐个字符输出，循环的范围由 T 的长度（T[0]）决定，这样就能完整地展示出整个串的内容了。

（十四）查看串存储情况函数 - test(A, B, C)

void test(String A, String B, String C) {
    printf("[0]\t%d\t%d\t%d\n", A[0], B[0], C[0]);
    for (int i = 1; i <= MAXSIZE; i++) {
        printf("[%d]\t%c\t%c\t%c\n", i, A[i], B[i], C[i]);
    }
}

作用：主要用于调试等目的，可以查看串 A、B、C 的内部存储情况，包括每个位置存储的字符以及它们的长度（通过 0 号单元体现），方便在调试过程中排查问题，了解串在内存中的实际状态。

实现细节：先输出三个串的长度信息，然后通过一个循环遍历每个串从 1 号单元到 MAXSIZE 的所有位置，输出每个位置存储的字符，以一种清晰的表格形式展示了串的存储细节，有助于发现存储异常或者数据错误等问题。


http://www.kler.cn/a/450334.html

相关文章：

  • 快速部署一套Kubernetes集群
  • JAVA HTTP压缩数据
  • 面试基础篇---迭代器，yield, tcp, 等
  • 软件测试之测试用例
  • java 对ElasticSearch数据库操作封装工具类（对你是否适用嘞）
  • WPF+MVVM案例实战与特效（四十五）- 打造优雅交互：ListBox 的高级定制与行为触发（侧边菜单交互面板）
  • 如何使用vscode解决git冲突
  • 【微信小程序】微信小程序中的异步函数是如何实现同步功能的
  • C# 异步编程与多线程简析
  • 【python】装饰器
  • 云端地球模型标注如何添加？
  • Rasa框架的优点和缺点
  • EasyExcel 模板+公式填充
  • opencv中的常用的100个API
  • Maven 环境变量 MAVEN_HOME 和 M2_HOME 区别以及 IDEA 修改 Maven repository 路径全局
  • 矩阵：Input-Output Interpretation of Matrices （中英双语）
  • VMware Workstation虚拟机网络模式
  • 32 - Java 8 函数式接口
  • Light | 单点光场多维信息重构
  • 力扣-数据结构-1【算法学习day.72】
  • 【微信小程序】3|首页搜索框 | 我的咖啡店-综合实训
  • Linux——字符设备驱动控制LED
  • 高性能Web网关：OpenResty 基础讲解
  • 汽车IVI中控开发入门及进阶（46）：FFmpeg
  • 常用网络协议
  • STM32高级物联网通信之以太网通讯