• 第 4 章 串（串的块链存储实现)

    1. 背景说明

    该实现和链表的实现极为相似，只是将链接的内存拆分为具体的大小的块。

    2.  示例代码

    1). status.h

    1. /* DataStructure 预定义常量和类型头文件 */
    2.  
    3. #ifndef STATUS_H
    4. #define STATUS_H
    5.  
    6. #define CHECK_NULL(pointer) if (!(pointer)) { \
    7. 	printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_NULL_PTR); \
    8. 	return NULL; \
    9. }
    10.  
    11. #define CHECK_RET(ret) if (ret != RET_OK) { \
    12. 	printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ret); \
    13. 	return ret; \
    14. }
    15.  
    16. #define CHECK_VALUE(value, ERR_CODE) if (value) { \
    17. 	printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_CODE); \
    18. 	return ERR_CODE; \
    19. }
    20.  
    21. #define CHECK_FALSE(value, ERR_CODE) if (!(value)) { \
    22. 	printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n", __func__, __LINE__, ERR_CODE); \
    23. 	return FALSE; \
    24. } 
    25.  
    26. /* 函数结果状态码 */
    27. #define TRUE 					1			/* 返回值为真 */
    28. #define FALSE 					0			/* 返回值为假 */
    29. #define RET_OK 					0			/* 返回值正确 */
    30. #define INFEASIABLE    		   	2			/* 返回值未知 */
    31. #define ERR_MEMORY     		   	3			/* 访问内存错 */
    32. #define ERR_NULL_PTR   			4			/* 空指针错误 */
    33. #define ERR_MEMORY_ALLOCATE		5			/* 内存分配错 */
    34. #define ERR_NULL_STACK			6			/* 栈元素为空 */
    35. #define ERR_PARA				7			/* 函数参数错 */
    36. #define ERR_OPEN_FILE			8			/* 打开文件错 */
    37. #define ERR_NULL_QUEUE			9			/* 队列为空错 */
    38. #define ERR_FULL_QUEUE			10			/* 队列为满错 */
    39. #define ERR_NOT_FOUND			11			/* 表项不存在 */
    40. typedef int Status;							/* Status 是函数的类型,其值是函数结果状态代码，如 RET_OK 等 */
    41. typedef int Bollean;						/* Boolean 是布尔类型,其值是 TRUE 或 FALSE */
    42.  
    43. #endif // !STATUS_H

    2) lString.h

    1. /* 串的块链存储实现头文件 */
    2.  
    3. #ifndef LSTRING_H
    4. #define LSTRING_H
    5.  
    6. #include "status.h"
    7.  
    8. #define CHUNK_SIZE 4
    9. #define BLANK '#'
    10.  
    11. typedef struct Chunk {
    12. 	char str[CHUNK_SIZE];
    13. 	struct Chunk *next;
    14. } Chunk;
    15.  
    16. typedef struct {
    17. 	Chunk *head, *tail;
    18. 	int curLen;				/* 字符个数 */
    19. } LString;
    20.  
    21. /* 初始化(产生空串)字符串 T */
    22. Status InitString(LString *T);
    23.  
    24. /* 生成一个其值等于 chars 的串 T (要求 chars 中不包含填补空余的字符)
    25.    成功返回 OK，否则返回 ERROR */
    26. Status StrAssign(const char *chars, LString *T);
    27.  
    28. /* 初始条件: 串 S 存在
    29.    操作结果: 由串 S 复制得串 T(连填补空余的字符一块拷贝) */
    30. Status StrCopy(const LString *S, LString *T);
    31.  
    32. /* 初始条件:串 S 存在
    33.    操作结果:若 S 为空串,则返回 TRUE,否则返回 FALSE */
    34. Bollean StrEmpty(const LString *S);
    35.  
    36. /* 若 S > T,则返回值 > 0;若 S = T,则返回值 = 0;若 S < T, 则返回值 < 0 */
    37. int StrCompare(const LString *S, const LString *T);
    38.  
    39. /* 返回 S 的元素个数,称为串的长度 */
    40. int StrLength(const LString *S);
    41.  
    42. /* 初始条件: 串 S 存在
    43.    操作结果: 将 S 清为空串 */
    44. Status ClearString(LString *S);
    45.  
    46. /* 用 T 返回由 S1 和 S2 联接而成的新串 */
    47. Status Concat(const LString *S1, const LString *S2, LString *T);
    48.  
    49. /* 用 Sub 返回串 S 的第 pos 个字符起长度为 len 的子串
    50.    其中, 1≤ pos ≤ StrLength(S) 且 0 ≤ len ≤ StrLength(S) - pos + 1 */
    51. Status SubString(const LString *S, int pos, int len, LString *Sub);
    52.  
    53. /* T 为非空串。若主串 S 中第 pos 个字符之后存在与 T 相等的子串
    54.    则返回第一个这样的子串在 S 中的位置,否则返回 0 */
    55. int Index(const LString *S, const LString *T, int pos);
    56.  
    57. /* 压缩串(清除块中不必要的填补空余的字符) */
    58. Status Zip(LString *S);
    59.  
    60. /* 1 ≤ pos ≤ StrLength(S) + 1。在串 S 的第 pos 个字符之前插入串 T */
    61. Status StrInsert(const LString *T, int pos, LString *S);
    62.  
    63. /* 从串 S 中删除第 pos 个字符起长度为 len 的子串 */
    64. Status StrDelete(int pos, int len, LString *S);
    65.  
    66. /* 初始条件: 串 S, T 和 V 存在,T 是非空串（此函数与串的存储结构无关）
    67.    操作结果: 用 V 替换主串 S 中出现的所有与 T 相等的不重叠的子串 */
    68. Status Replace(const LString *T, const LString *V, LString *S);
    69.  
    70. /*  输出字符串 T */
    71. void StrPrint(const LString *T);
    72.  
    73. #endif // !LSTRING_H

    3) lString.c

    1. /* 串的块链存储实现源文件 */
    2.  
    3. #include "lString.h"
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. /* 初始化(产生空串)字符串 T */
    9. Status InitString(LString *T)
    10. {
    11. 	CHECK_VALUE(!T, ERR_NULL_PTR);
    12. 	T->curLen = 0;
    13. 	T->head = NULL;
    14. 	T->tail = NULL;
    15.  
    16. 	return RET_OK;
    17. }
    18.  
    19. /* 生成一个其值等于 chars 的串 T (要求 chars 中不包含填补空余的字符)
    20.    成功返回 OK，否则返回 ERROR */
    21. Status StrAssign(const char *chars, LString *T)
    22. {
    23. 	CHECK_VALUE(!chars || !T, ERR_NULL_PTR);
    24. 	int length = (int)strlen(chars);
    25. 	CHECK_VALUE((length == 0) || strchr(chars, BLANK), ERR_PARA);
    26. 	T->curLen = length;
    27. 	int nodes = length / CHUNK_SIZE;
    28. 	if (length % CHUNK_SIZE) {
    29. 		nodes += 1;
    30. 	}
    31.  
    32. 	Chunk *tail = NULL, *newNode = NULL;
    33. 	for (int i = 0; i < nodes; ++i) {
    34. 		newNode = (Chunk *)malloc(sizeof(Chunk));
    35. 		CHECK_VALUE(!newNode, ERR_NULL_PTR);
    36. 		if (i == 0) {
    37. 			T->head = tail = newNode;
    38. 		} else {
    39. 			tail->next = newNode;
    40. 			tail = newNode;
    41. 		}
    42.  
    43. 		int j;
    44. 		for (j = 0; (j < CHUNK_SIZE) && (*chars); ++j) {
    45. 			*(tail->str + j) = *chars++;
    46. 		}
    47.  
    48. 		if (!(*chars)) {
    49. 			T->tail = tail;
    50. 			tail->next = NULL;
    51. 			while (j < CHUNK_SIZE) {
    52. 				*(tail->str + j++) = BLANK;
    53. 			}
    54. 		}
    55. 	}
    56.  
    57. 	return RET_OK;
    58. }
    59.  
    60. /* 初始条件: 串 S 存在
    61.    操作结果: 由串 S 复制得串 T(连填补空余的字符一块拷贝) */
    62. Status StrCopy(const LString *S, LString *T)
    63. {
    64. 	CHECK_VALUE(!S || !T, ERR_NULL_PTR);
    65. 	Chunk *sHead = S->head, *newNode = NULL;
    66. 	T->head = NULL;
    67. 	while (sHead) {
    68. 		newNode = (Chunk *)malloc(sizeof(Chunk));
    69. 		CHECK_VALUE(!newNode, ERR_MEMORY_ALLOCATE);
    70. 		newNode->next = NULL;
    71. 		(void)memcpy_s(newNode, sizeof(Chunk), sHead, sizeof(Chunk));
    72. 		if (T->head == NULL) {
    73. 			T->head = T->tail = newNode;
    74. 		} else {
    75. 			T->tail->next = newNode;
    76. 			T->tail = newNode;
    77. 		}
    78.  
    79. 		sHead = sHead->next;
    80. 	}
    81.  
    82. 	T->curLen = S->curLen;
    83.  
    84. 	return RET_OK;
    85. }
    86.  
    87. /* 初始条件:串 S 存在
    88.    操作结果:若 S 为空串,则返回 TRUE,否则返回 FALSE */
    89. Bollean StrEmpty(const LString *S)
    90. {
    91. 	CHECK_VALUE(!S, ERR_NULL_PTR);
    92.  
    93. 	return (S->curLen == 0) ? TRUE : FALSE;
    94. }
    95.  
    96. static void GetNextCharPos(Chunk **node, int *order)
    97. {
    98. 	++(*order);
    99. 	if (*order == CHUNK_SIZE) {
    100. 		*node = (*node)->next;
    101. 		*order = 0;
    102. 	}
    103. }
    104.  
    105. static void GetNextLegalCharPos(Chunk **node, int *order)
    106. {
    107. 	while (*((*node)->str + *order) == BLANK) {
    108. 		GetNextCharPos(node, order);
    109. 	}
    110. }
    111.  
    112. /* 若 S > T,则返回值 > 0;若 S = T,则返回值 = 0;若 S < T, 则返回值 < 0 */
    113. int StrCompare(const LString *S, const LString *T)
    114. {
    115. 	CHECK_VALUE(!S || !T, ERR_NULL_PTR);
    116. 	Chunk *ps = S->head, *pt = T->head;
    117. 	for (int i = 0, js = 0, jt = 0; (i < S->curLen) && (i < T->curLen); ++i) {
    118. 		GetNextLegalCharPos(&ps, &js);
    119. 		GetNextLegalCharPos(&pt, &jt);
    120. 		if (*(ps->str + js) != *(pt->str + jt)) {
    121. 			return *(ps->str + js) - *(pt->str + jt);
    122. 		}
    123.  
    124. 		GetNextCharPos(&ps, &js);
    125. 		GetNextCharPos(&pt, &jt);
    126. 	}
    127.  
    128. 	return S->curLen - T->curLen;
    129. }
    130.  
    131. /* 返回 S 的元素个数,称为串的长度 */
    132. int StrLength(const LString *S)
    133. {
    134. 	CHECK_VALUE(!S, ERR_NULL_PTR);
    135.  
    136. 	return S->curLen;
    137. }
    138.  
    139. /* 初始条件: 串 S 存在
    140.    操作结果: 将 S 清为空串 */
    141. Status ClearString(LString *S)
    142. {
    143. 	CHECK_VALUE(!S, ERR_NULL_PTR);
    144. 	Chunk *p = S->head, *q = NULL;
    145. 	while (p) {
    146. 		q = p->next;
    147. 		free(p);
    148. 		p = q;
    149. 	}
    150.  
    151. 	S->head = S->tail = NULL;
    152. 	S->curLen = 0;
    153.  
    154. 	return RET_OK;
    155. }
    156.  
    157. /* 用 T 返回由 S1 和 S2 联接而成的新串 */
    158. Status Concat(const LString *S1, const LString *S2, LString *T)
    159. {
    160. 	CHECK_VALUE(!S1 || !S2 || !T, ERR_NULL_PTR);
    161. 	LString str1, str2;
    162. 	InitString(&str1);
    163. 	InitString(&str2);
    164. 	StrCopy(S1, &str1);
    165. 	StrCopy(S2, &str2);
    166. 	T->head = str1.head;
    167. 	str1.tail->next = str2.head;
    168. 	T->tail = str2.tail;
    169. 	T->curLen = str1.curLen + str2.curLen;
    170.  
    171. 	return RET_OK;
    172. }
    173.  
    174. /* 用 Sub 返回串 S 的第 pos 个字符起长度为 len 的子串
    175.    其中, 1≤ pos ≤ StrLength(S) 且 0 ≤ len ≤ StrLength(S) - pos + 1 */
    176. Status SubString(const LString *S, int pos, int len, LString *Sub)
    177. {
    178. 	CHECK_VALUE(!S || !Sub, ERR_NULL_PTR);
    179. 	CHECK_VALUE((pos < 1) || (pos > S->curLen) || (len < 0) || (len > (S->curLen - pos + 1)), ERR_PARA);
    180. 	int subLength = len / CHUNK_SIZE;
    181. 	if (len % CHUNK_SIZE) {
    182. 		subLength += 1;
    183. 	}
    184.  
    185. 	Chunk *newNode = (Chunk *)malloc(sizeof(Chunk));
    186. 	Sub->head = newNode;
    187. 	Chunk *tail = Sub->head;
    188. 	for (int i = 0; i < subLength - 1; ++i) {
    189. 		newNode = (Chunk *)malloc(sizeof(Chunk));
    190. 		tail->next = newNode;
    191. 		tail = newNode;
    192. 	}
    193.  
    194. 	tail->next = NULL;
    195. 	Sub->tail = tail;
    196. 	Sub->curLen = len;
    197. 	int lastPos = len % CHUNK_SIZE;
    198. 	if (lastPos) {
    199. 		for (int i = lastPos; i < CHUNK_SIZE; ++i) {
    200. 			*(newNode->str + i) = BLANK;
    201. 		}
    202. 	}
    203.  
    204. 	Chunk *subHead = Sub->head, *sHead = S->head;
    205. 	int subPos = 0, count = 0;
    206. 	Bollean isEnd = FALSE;
    207. 	while (!isEnd) {
    208. 		for (int i = 0; i < CHUNK_SIZE; ++i) {
    209. 			if (*(sHead->str + i) == BLANK) {
    210. 				continue;
    211. 			}
    212.  
    213. 			++count;
    214. 			if ((count >= pos) && (count <= pos + len - 1)) {
    215. 				if (subPos == CHUNK_SIZE) {
    216. 					subHead = subHead->next;
    217. 					subPos = 0;
    218. 				}
    219.  
    220. 				*(subHead->str + subPos) = *(sHead->str + i);
    221. 				++subPos;
    222. 				if (count == pos + len - 1) {
    223. 					isEnd = TRUE;
    224. 					break;
    225. 				}
    226. 			}
    227. 		}
    228.  
    229. 		sHead = sHead->next;
    230. 	}
    231.  
    232. 	return RET_OK;
    233. }
    234.  
    235. /* T 为非空串。若主串 S 中第 pos 个字符之后存在与 T 相等的子串
    236.    则返回第一个这样的子串在 S 中的位置,否则返回 0 */
    237. int Index(const LString *S, const LString *T, int pos)
    238. {
    239. 	CHECK_VALUE(!S || !T, ERR_NULL_PTR);
    240. 	int maxRange = StrLength(S) - StrLength(T) + 1;
    241. 	CHECK_VALUE((pos < 1) || (pos > maxRange), 0);
    242. 	LString sub;
    243. 	InitString(&sub);
    244. 	while (pos <= maxRange) {
    245. 		SubString(S, pos, StrLength(T), &sub);
    246. 		if (StrCompare(T, &sub) == 0) {
    247. 			return pos;
    248. 		}
    249.  
    250. 		++pos;
    251. 	}
    252.  
    253. 	return 0;
    254. }
    255.  
    256.  
    257. /* 压缩串(清除块中不必要的填补空余的字符) */
    258. Status Zip(LString *S)
    259. {
    260. 	CHECK_VALUE(!S, ERR_NULL_PTR);
    261. 	char *newStr = (char *)malloc(sizeof(char) * (unsigned int)(S->curLen + 1));
    262. 	CHECK_VALUE(!newStr, ERR_NULL_PTR);
    263. 	Chunk *sHead = S->head;
    264. 	int count = 0;
    265. 	while (sHead) {
    266. 		for (int i = 0; i < CHUNK_SIZE; ++i) {
    267. 			if (*(sHead->str + i) != BLANK) {
    268. 				*(newStr + count) = *(sHead->str + i);
    269. 				++count;
    270. 			}
    271. 		}
    272.  
    273. 		sHead = sHead->next;
    274. 	}
    275.  
    276. 	*(newStr + count) = '\0';
    277. 	ClearString(S);
    278. 	StrAssign(newStr, S);
    279.  
    280. 	return RET_OK;
    281. }
    282.  
    283. /* 1 ≤ pos ≤ StrLength(S) + 1。在串 S 的第 pos 个字符之前插入串 T */
    284. Status StrInsert(const LString *T, int pos, LString *S)
    285. {
    286. 	CHECK_VALUE(!T || !S, ERR_MEMORY_ALLOCATE);
    287. 	CHECK_VALUE((pos < 1) || (pos > StrLength(S) + 1), ERR_PARA);
    288. 	LString t;
    289. 	StrCopy(T, &t);
    290. 	Zip(S);
    291. 	int moveBlock = (pos - 1) / CHUNK_SIZE;
    292. 	int insertPos = (pos - 1) % CHUNK_SIZE;
    293. 	Chunk *sHead = S->head;
    294. 	if (pos == 1) {
    295. 		t.tail->next = S->head;
    296. 		S->head = t.head;
    297. 	} else if (insertPos == 0) {
    298. 		for (int i = 0; i < moveBlock - 1; ++i) {
    299. 			sHead = sHead->next;
    300. 		}
    301.  
    302. 		Chunk *insertNext = sHead->next;
    303. 		sHead->next = t.head;
    304. 		t.tail->next = insertNext;
    305. 		if (insertNext == NULL) {
    306. 			S->tail = t.tail;
    307. 		}
    308. 	} else {
    309. 		for (int i = 0; i < moveBlock; ++i) {
    310. 			sHead = sHead->next;
    311. 		}
    312.  
    313. 		Chunk *newBlock = (Chunk *)malloc(sizeof(Chunk));
    314. 		CHECK_VALUE(!newBlock, ERR_NULL_PTR);
    315. 		for (int i = 0; i < insertPos; ++i) {
    316. 			*(newBlock->str + i) = BLANK;
    317. 		}
    318.  
    319. 		for (int i = insertPos; i < CHUNK_SIZE; ++i) {
    320. 			*(newBlock->str + i) = *(sHead->str + i);
    321. 			*(sHead->str + i) = BLANK;
    322. 		}
    323.  
    324. 		newBlock->next = sHead->next;
    325. 		sHead->next = t.head;
    326. 		t.tail->next = newBlock;
    327. 	}
    328.  
    329. 	S->curLen += t.curLen;
    330. 	Zip(S);
    331.  
    332. 	return RET_OK;
    333. }
    334.  
    335. /* 从串 S 中删除第 pos 个字符起长度为 len 的子串 */
    336. Status StrDelete(int pos, int len, LString *S)
    337. {
    338. 	CHECK_VALUE(!S, ERR_NULL_PTR);
    339. 	CHECK_VALUE((pos < 1) || (pos > S->curLen - len + 1) || (len < 0), ERR_PARA);
    340. 	int count = 0;
    341. 	int currOrder = 0;
    342. 	Chunk *sHead = S->head;
    343. 	while (count < pos - 1) {
    344. 		GetNextLegalCharPos(&sHead, &currOrder);
    345. 		++count;
    346. 		GetNextCharPos(&sHead, &currOrder);
    347. 	}
    348.  
    349. 	++count;
    350. 	if (*(sHead->str + currOrder) == BLANK) {
    351. 		GetNextLegalCharPos(&sHead, &currOrder);
    352. 	}
    353.  
    354. 	while (count < pos + len) {
    355. 		GetNextLegalCharPos(&sHead, &currOrder);
    356. 		*(sHead->str + currOrder) = BLANK;
    357. 		++count;
    358. 		GetNextCharPos(&sHead, &currOrder);
    359. 	}
    360.  
    361. 	S->curLen -= len;
    362.  
    363. 	return RET_OK;
    364. }
    365.  
    366. /* 初始条件: 串 S, T 和 V 存在,T 是非空串（此函数与串的存储结构无关）
    367.    操作结果: 用 V 替换主串 S 中出现的所有与 T 相等的不重叠的子串 */
    368. Status Replace(const LString *T, const LString *V, LString *S)
    369. {
    370. 	CHECK_VALUE(!T || !V || !S, ERR_NULL_PTR);
    371. 	CHECK_VALUE(StrEmpty(T), ERR_PARA);
    372. 	int pos = 1;
    373. 	do {
    374. 		pos = Index(S, T, pos);
    375. 		if (pos) {
    376. 			StrDelete(pos, StrLength(T), S);
    377. 			StrInsert(V, pos, S);
    378. 			pos += StrLength(V);
    379. 		}
    380. 	} while (pos);
    381.  
    382. 	return RET_OK;
    383. }
    384.  
    385. /*  输出字符串 T */
    386. void StrPrint(const LString *T)
    387. {
    388. 	int count = 0;
    389. 	Chunk *tHead = T->head;
    390. 	while (count < T->curLen) {
    391. 		for (int i = 0; i < CHUNK_SIZE; ++i) {
    392. 			if (*(tHead->str + i) != BLANK) {
    393. 				printf("%c", *(tHead->str + i));
    394. 				++count;
    395. 			}
    396. 		}
    397.  
    398. 		tHead = tHead->next;
    399. 	}
    400. }

    4) main.c

    1. /* 入口程序源文件 */
    2.  
    3. #include "lString.h"
    4. #include 
    5.  
    6. void ShowStr(const LString *S, const char *stringName);
    7.  
    8. int main(void)
    9. {
    10. 	LString t1, t2, t3, t4;
    11. 	InitString(&t1);
    12. 	InitString(&t2);
    13. 	InitString(&t3);
    14. 	InitString(&t4);
    15. 	printf("After initialize the string t1, the string t1 is %s,"
    16. 		"the length of string t1 is %d\n", (StrEmpty(&t1) == TRUE) ? "empty" : "not empty",
    17. 		StrLength(&t1));
    18. 	char *s1 = "ABCDEFGHI", *s2 = "12345", *s3 = "", *s4 = "asd#tr", *s5 = "ABCD";
    19. 	Status ret = StrAssign(s3, &t1);
    20. 	if (ret == RET_OK) {
    21. 		ShowStr(&t1, "t1");
    22. 	}
    23.  
    24. 	ret = StrAssign(s4, &t1);
    25. 	if (ret == RET_OK) {
    26. 		ShowStr(&t1, "t1");
    27. 	}
    28.  
    29. 	ret = StrAssign(s1, &t1);
    30. 	if (ret == RET_OK) {
    31. 		ShowStr(&t1, "t1");
    32. 	}
    33.  
    34. 	printf("After assign s1 to the string t1, the string t1 is %s,"
    35. 		"the length of string t1 is %d\n", (StrEmpty(&t1) == TRUE) ? "empty" : "not empty",
    36. 		StrLength(&t1));
    37. 	ret = StrAssign(s2, &t2);
    38. 	if (ret == RET_OK) {
    39. 		ShowStr(&t2, "t2");
    40. 	}
    41.  
    42. 	StrCopy(&t1, &t3);
    43. 	ShowStr(&t3, "t3");
    44. 	ret = StrAssign(s5, &t4);
    45. 	if (ret == RET_OK) {
    46. 		ShowStr(&t4, "t4");
    47. 	}
    48.  
    49. 	Replace(&t4, &t2, &t3);
    50. 	ShowStr(&t3, "t3");
    51. 	ClearString(&t1);
    52. 	printf("After clear string t1, the string t1 is %s,"
    53. 		"the length of string t1 is %d\n", (StrEmpty(&t1) == TRUE) ? "empty" : "not empty",
    54. 		StrLength(&t1));
    55. 	Concat(&t2, &t3, &t1);
    56. 	ShowStr(&t1, "t1");
    57. 	Zip(&t1);
    58. 	ShowStr(&t1, "t1");
    59. 	int pos = Index(&t1, &t3, 1);
    60. 	printf("pos = %d\n", pos);
    61. 	printf("To insert the string t2 before the posTh character of the string t1, enter pos: ");
    62. 	scanf_s("%d", &pos);
    63. 	StrInsert(&t2, pos, &t1);
    64. 	ShowStr(&t1, "t1");
    65. 	int len;
    66. 	printf("Please input the position and length of the subString of t1: ");
    67. 	scanf_s("%d%d", &pos, &len);
    68. 	ClearString(&t2);
    69. 	SubString(&t1, pos, len, &t2);
    70. 	ShowStr(&t2, "t2");
    71. 	printf("StrCompare(&t1, &t2) = %d\n", StrCompare(&t1, &t2));
    72. 	printf("Please input the position and length of the string t1 to be delete: ");
    73. 	scanf_s("%d%d", &pos, &len);
    74. 	StrDelete(pos, len, &t1);
    75. 	ShowStr(&t1, "t1");
    76.  
    77. 	t1.head->str[0] = BLANK;
    78. 	t1.curLen--;
    79. 	printf("t1.head->str[0] = %c\n", t1.head->str[0]);
    80. 	ShowStr(&t1, "t1");
    81. 	Zip(&t1);
    82. 	printf("t1.head->str[0] = %c\n", t1.head->str[0]);
    83. 	ShowStr(&t1, "t1");
    84.  
    85. 	ClearString(&t1);
    86. 	ClearString(&t2);
    87. 	ClearString(&t3);
    88. 	ClearString(&t4);
    89.  
    90. 	return 0;
    91. }
    92.  
    93. void ShowStr(const LString *S, const char *stringName)
    94. {
    95. 	printf("The string %s is: ", stringName);
    96. 	StrPrint(S);
    97. 	printf("\n");
    98. }

    3. 运行示例

  • 相关阅读:
    React v6（仅支持函数组件，不支持类组件）与v5版本路由使用详情和区别（详细版）
    [附源码]Python计算机毕业设计Django居家养老服务系统小程序
    【100天精通Python】Day72：Python可视化_一文掌握Seaborn库的使用《二》_分类数据可视化，线性模型和参数拟合的可视化，示例+代码
    ＜HarmonyOS第一课＞ArkTS开发语言介绍——闯关习题及答案
    vuejs - - - - - 递归组件的实现
    C++Qt开发——音视频播放
    开发过程中常见数据库。
    Geoserver的WFS服务实现要素的增删改
    Java基础- 浅谈javac和javap
    java毕业设计电子病历系统mybatis+源码+调试部署+系统+数据库+lw
  • 原文地址：https://blog.csdn.net/qq_40613544/article/details/133103566