💡 <04 串>习题代码

CLion/ExerciseBook/04.10/04.10.c

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include "String.h"    //**字符串**//
+
+/*
+ * 字符串逆置：将T逆置为R。
+ */
+StringType Algo_4_10(StringType T) {
+    int i;
+    StringType R = "", Sub;
+    
+    // 从后向前截取字符
+    for(i = StrLength(T); i >= 1; i--) {
+        Sub = SubString(T, i, 1);
+        R = Concat(R, Sub);
+    }
+    
+    return R;
+}
+
+
+int main(int argc, char* argv[]) {
+    char* s = "0123456789";
+    StringType T, R;
+    
+    printf("逆置前，T = ");
+    StrAssign(&T, s);
+    StrPrint(T);
+    
+    printf("逆置后，R = ");
+    R = Algo_4_10(T);
+    StrPrint(R);
+    
+    return 0;
+}
+

CLion/ExerciseBook/04.10/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.10 String.h String.c 04.10.c)
+# 链接公共库
+target_link_libraries(04.10 Scanf_lib)

CLion/ExerciseBook/04.10/String.c

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

CLion/ExerciseBook/04.10/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

CLion/ExerciseBook/04.11/04.11.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "String.h"    //**字符串**//
+
+/*
+ * R=S-S∩T，数组a存储R中每个字符在S中第一次出现的位置
+ *
+ * 注：数组a的0号单元存储的是a中元素的个数
+ */
+void Algo_4_11(StringType* R, StringType S, StringType T, int** a) {
+    int i, p;
+    StringType ch;
+    
+    *a = (int*) malloc((StrLength(S) + 1) * sizeof(int));
+    
+    StrAssign(R, "");
+    
+    for(i = 1, (*a)[0] = 0; i <= StrLength(S); i++) {
+        // 取出字符进行判断
+        ch = SubString(S, i, 1);
+        
+        // 获取S[i]在T中的位置
+        p = Index(T, ch, 1);
+        
+        // 如果S[i]不在T中
+        if(p == 0) {
+            // 获取S[i]在R中的位置
+            p = Index(*R, ch, 1);
+        }
+        
+        // 如果S[i]既不在T中，又没在R中出现过
+        if(p == 0) {
+            (*a)[0]++;
+            (*a)[(*a)[0]] = i;
+            
+            // 向R中添加S[i]
+            StrInsert(R, (*a)[0], ch);
+        }
+    }
+}
+
+
+int main(int argc, char* argv[]) {
+    char* s = "amdhcjgfdlpinbefcopgkqikeb";
+    char* t = "mhjlpinopkqik";
+    int* a;
+    StringType T, S, R;
+    int i;
+    
+    printf("初始化S和T...\n");
+    StrAssign(&S, s);
+    StrAssign(&T, t);
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    
+    Algo_4_11(&R, S, T, &a);
+    printf("R = ");
+    StrPrint(R);
+    
+    printf("a = ");
+    for(i = 1; i <= a[0]; i++) {
+        printf("%d ", a[i]);
+    }
+    printf("\n");
+    
+    return 0;
+}

CLion/ExerciseBook/04.11/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.11 String.h String.c 04.11.c)
+# 链接公共库
+target_link_libraries(04.11 Scanf_lib)

CLion/ExerciseBook/04.11/String.c

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

CLion/ExerciseBook/04.11/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

CLion/ExerciseBook/04.12/04.12.c

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include "Status.h"    //**▲01 绪论**//
+#include "String.h"    //**字符串**//
+
+/*
+ * 替换：Replace
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串
+ */
+Status Algo_4_12(StringType* S, StringType T, StringType V) {
+    int i;
+    
+    if(StrLength(*S) == 0 || StrLength(T) == 0) {
+        return ERROR;
+    }
+    
+    i = 1;
+    
+    // 在主串S中寻找模式串T第一次出现的位置
+    while((i = Index(*S, T, i)) != 0) {
+        StrDelete(S, i, StrLength(T));  // 从S中删除T
+        StrInsert(S, i, V);             // 向S中插入V
+        
+        i += StrLength(V);  // i切换到下一个位置
+    }
+    
+    return OK;
+}
+
+
+int main(int argc, char* argv[]) {
+    char* s = "----***--*-**-****-*****-----";
+    char* t = "**";
+    char* v = "^^";
+    StringType T, S, V;
+    
+    printf("替换前...\n");
+    
+    StrAssign(&S, s);
+    StrAssign(&T, t);
+    StrAssign(&V, v);
+    
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    printf("V = ");
+    StrPrint(V);
+    
+    printf("替换后...\n");
+    printf("S = ");
+    Algo_4_12(&S, T, V);
+    StrPrint(S);
+    
+    return 0;
+}

CLion/ExerciseBook/04.12/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.12 String.h String.c 04.12.c)
+# 链接公共库
+target_link_libraries(04.12 Scanf_lib)

CLion/ExerciseBook/04.12/String.c

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

CLion/ExerciseBook/04.12/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

CLion/ExerciseBook/04.13/04.13.c

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include "String.h"    //**字符串**//
+
+/*
+ * 删除S中包含的T
+ */
+Status Algo_4_13(StringType* S, StringType T) {
+    int i;
+    
+    // 在S中查找T，如果找到就删除
+    while((i = Index(*S, T, 1)) != 0) {
+        if(StrDelete(S, i, StrLength(T)) == ERROR) {
+            return ERROR;
+        }
+    }
+    
+    return OK;
+}
+
+
+int main(int argc, char* argv[]) {
+    char* s = "----***--*-**-****-*****-----";
+    char* t = "**";
+    StringType T, S;
+    
+    printf("删除前...\n");
+    StrAssign(&S, s);
+    StrAssign(&T, t);
+    
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    
+    printf("删除后...\n");
+    printf("S = ");
+    Algo_4_13(&S, T);
+    StrPrint(S);
+    
+    return 0;
+}

CLion/ExerciseBook/04.13/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.13 String.h String.c 04.13.c)
+# 链接公共库
+target_link_libraries(04.13 Scanf_lib)

CLion/ExerciseBook/04.13/String.c

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

CLion/ExerciseBook/04.13/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

CLion/ExerciseBook/04.14/04.14.c

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <string.h>
+#include "SqStack.h"    //**▲03 栈和队列**//
+#include "String.h"     //**字符串**//
+
+/*
+ * 将前缀表达式prefix转换为后缀表达式
+ *
+ *【注】
+ * 未对前缀表达式的正确性进行验证
+ */
+Status Algo_4_14(const char* prefix, char** suffix) {
+    StringType P, S;
+    StringType Operator;    // 运算符
+    SqStack stack;          // 表达式栈
+    StringType e;           // 栈顶元素
+    StringType o;           // 靠近栈顶的运算符
+    int i, len;
+    int readStr;    // 是否需要读取字符串
+    
+    len = (int) strlen(prefix);
+    
+    if(len == 0) {
+        *suffix = NULL;
+        return ERROR;
+    }
+    
+    // 运算符和操作数
+    StrAssign(&Operator, "+-*/");
+    
+    // 前缀表达式
+    StrAssign(&P, prefix);
+    
+    // 后缀表达式栈
+    InitStack(&stack);
+    
+    readStr = 1;
+    i = 1;
+    
+    // 遍历前缀表达式，逐个获取元素
+    while(TRUE) {
+        if(readStr == 1) {
+            S = SubString(P, i++, 1);
+        }
+        
+        // 如果遇到了运算符，则直接入栈
+        if(Index(Operator, S, 1) != 0) {
+            Push(&stack, S);
+            readStr = 1;
+            
+            // 如果遇到了操作数
+        } else {
+            // 获取栈顶元素，如果栈已经为空，则S中存储了后缀表达式
+            if(GetTop(stack, &e) == ERROR) {
+                break;
+            }
+            
+            // 如果栈顶元素是运算符，则将操作数直接入栈
+            if(Index(Operator, e, 1) != 0) {
+                Push(&stack, S);
+                readStr = 1;
+                
+                // 否则栈顶也是操作数，需要进行简单运算
+            } else {
+                Pop(&stack, &e);    // 弹出栈顶操作数
+                Pop(&stack, &o);    // 弹出靠近栈顶的运算符
+                
+                S = Concat(e, S);
+                S = Concat(S, o);
+                
+                // 此种情形下不需要读取字符串，而需要判断刚刚计算出的Sub
+                readStr = 0;
+            }
+        }
+    }
+    
+    // 获取后缀表达式
+    *suffix = S;
+    
+    return OK;
+}
+
+
+int main(int argc, char* argv[]) {
+    char* prefix = "-+a*bc/de";  // 其后缀表达式为：abc*+de/-
+    char* suffix;
+    
+    Algo_4_14(prefix, &suffix);
+    
+    printf("前缀表达式：%s\n", prefix);
+    printf("后缀表达式：%s\n", suffix);
+}

CLion/ExerciseBook/04.14/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.14 SqStack.h SqStack.c String.h String.c 04.14.c)
+# 链接公共库
+target_link_libraries(04.14 Scanf_lib)

CLion/ExerciseBook/04.14/SqStack.c

@@ -0,0 +1,89 @@
+/*=========================
+ * 栈的顺序存储结构（顺序栈）
+ ==========================*/
+
+#include "SqStack.h"    //**▲03 栈和队列**//
+
+/*
+ * 初始化
+ *
+ * 构造一个空栈。初始化成功则返回OK，否则返回ERROR。
+ */
+Status InitStack(SqStack* S) {
+    if(S == NULL) {
+        return ERROR;
+    }
+    
+    (*S).base = (SElemType*) malloc(STACK_INIT_SIZE * sizeof(SElemType));
+    if((*S).base == NULL) {
+        exit(OVERFLOW);
+    }
+    
+    (*S).top = (*S).base;
+    (*S).stacksize = STACK_INIT_SIZE;
+    
+    return OK;
+}
+
+/*
+ * 取值
+ *
+ * 返回栈顶元素，并用e接收。
+ */
+Status GetTop(SqStack S, SElemType* e) {
+    if(S.base == NULL || S.top == S.base) {
+        return ERROR;
+    }
+    
+    // 不会改变栈中元素
+    *e = *(S.top - 1);
+    
+    return OK;
+}
+
+/*
+ * 入栈
+ *
+ * 将元素e压入到栈顶。
+ */
+Status Push(SqStack* S, SElemType e) {
+    if(S == NULL || (*S).base == NULL) {
+        return ERROR;
+    }
+    
+    // 栈满时，追加存储空间
+    if((*S).top - (*S).base >= (*S).stacksize) {
+        (*S).base = (SElemType*) realloc((*S).base, ((*S).stacksize + STACKINCREMENT) * sizeof(SElemType));
+        if((*S).base == NULL) {
+            exit(OVERFLOW);     // 存储分配失败
+        }
+        
+        (*S).top = (*S).base + (*S).stacksize;
+        (*S).stacksize += STACKINCREMENT;
+    }
+    
+    // 进栈先赋值，栈顶指针再自增
+    *(S->top++) = e;
+    
+    return OK;
+}
+
+/*
+ * 出栈
+ *
+ * 将栈顶元素弹出，并用e接收。
+ */
+Status Pop(SqStack* S, SElemType* e) {
+    if(S == NULL || (*S).base == NULL) {
+        return ERROR;
+    }
+    
+    if((*S).top == (*S).base) {
+        return ERROR;
+    }
+    
+    // 出栈栈顶指针先递减，再赋值
+    *e = *(--(*S).top);
+    
+    return OK;
+}

CLion/ExerciseBook/04.14/SqStack.h

@@ -0,0 +1,61 @@
+/*=========================
+ * 栈的顺序存储结构（顺序栈）
+ ==========================*/
+
+#ifndef SQSTACK_H
+#define SQSTACK_H
+
+#include <stdio.h>
+#include <stdlib.h>     // 提供malloc、realloc、free、exit原型
+#include "Status.h"     //**▲01 绪论**//
+#include "String.h"    //**▲04 串**//
+
+/* 宏定义 */
+#define STACK_INIT_SIZE 100     // 顺序栈存储空间的初始分配量
+#define STACKINCREMENT  10      // 顺序栈存储空间的分配增量
+
+/*
+ * 顺序栈元素类型定义
+ *
+ *【注】
+ * 这里的元素类型为字符串
+ */
+typedef StringType SElemType;
+
+// 顺序栈元素结构
+typedef struct {
+    SElemType* base;               // 栈底指针
+    SElemType* top;                // 栈顶指针
+    int stacksize;                 // 当前已分配的存储空间，以元素为单位
+} SqStack;
+
+
+/*
+ * 初始化
+ *
+ * 构造一个空栈。初始化成功则返回OK，否则返回ERROR。
+ */
+Status InitStack(SqStack* S);
+
+/*
+ * 取值
+ *
+ * 返回栈顶元素，并用e接收。
+ */
+Status GetTop(SqStack S, SElemType* e);
+
+/*
+ * 入栈
+ *
+ * 将元素e压入到栈顶。
+ */
+Status Push(SqStack* S, SElemType e);
+
+/*
+ * 出栈
+ *
+ * 将栈顶元素弹出，并用e接收。
+ */
+Status Pop(SqStack* S, SElemType* e);
+
+#endif

CLion/ExerciseBook/04.14/String.c

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

CLion/ExerciseBook/04.14/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

CLion/ExerciseBook/04.15-04.17/04.15-04.17.c

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include "Status.h"     //**▲01 绪论**//
+#include "SString.h"    //**▲04 串**//
+
+/*
+ * 初始化：StrAssign
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+Status Algo_4_15(SString T, char* chars);
+
+/*
+ * 比较：StrCompare
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+int Algo_4_16(SString S, SString T);
+
+/*
+ * 替换：Replace
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+Status Algo_4_17(SString S, SString T, SString V);
+
+
+int main(int argc, char* argv[]) {
+    char* t = "ab**c*de***fg";
+    char* s = "ab**c*de***fh";
+    SString T, S, M1, M2;
+    int i;
+    
+    printf("███题 4.15 验证...███\n");
+    Algo_4_15(T, t);
+    Algo_4_15(S, s);
+    printf("T = ");
+    StrPrint(T);
+    printf("S = ");
+    StrPrint(S);
+    
+    printf("███题 4.16 验证...███\n");
+    i = Algo_4_16(S, T);
+    if(i > 0) {
+        printf("S > T\n");
+    } else if(i < 0) {
+        printf("S < T\n");
+    } else {
+        printf("S == T\n");
+    }
+    
+    printf("███题 4.17 验证...███\n");
+    Algo_4_15(M1, "**");
+    Algo_4_15(M2, "^");
+    Algo_4_17(S, M1, M2);
+    printf("用 \"^\" 替换 \"**\" 后：\nS = ");
+    StrPrint(S);
+    
+    return 0;
+}
+
+/*
+ * 初始化：StrAssign
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+Status Algo_4_15(SString T, char* chars) {
+    return StrAssign(T, chars);
+}
+
+/*
+ * 比较：StrCompare
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+int Algo_4_16(SString S, SString T) {
+    return StrCompare(S, T);
+}
+
+/*
+ * 替换：Replace
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+Status Algo_4_17(SString S, SString T, SString V) {
+    return Replace(S, T, V);
+}

CLion/ExerciseBook/04.15-04.17/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.15-04.17 SString.h SString.c 04.15-04.17.c)
+# 链接公共库
+target_link_libraries(04.15-04.17 Scanf_lib)

CLion/ExerciseBook/04.15-04.17/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

CLion/ExerciseBook/04.18/04.18.c

@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "SString.h"    //**▲04 串**//
+
+/*
+ * 统计字符串S中不同字符总数与每种字符的个数，返回统计结果
+ */
+int* Algo_4_18(SString S);
+
+
+int main(int argc, char* argv[]) {
+    char* s = "dbasydujhge638940[gptokljrsehgadcsbnmv,c.b'ng[p098437eywdghswqdecxvghju";
+    SString S;
+    int* total;
+    int i;
+    
+    StrAssign(S, s);
+    printf("S = ");
+    StrPrint(S);
+    
+    total = Algo_4_18(S);
+    printf(" S 中不同的字符共计 %d 个：\n", total[0]);
+    for(i = 1; i <= 127; i++) {
+        if(total[i] != 0) {
+            printf("字符 \'%c\' 有 %d 个.\n", i, total[i]);
+        }
+    }
+    printf("统计完毕...\n");
+    
+    return 0;
+}
+
+
+/*
+ * 统计字符串S中不同字符总数与每种字符的个数，返回统计结果
+ */
+int* Algo_4_18(SString S) {
+    int i;
+    int* total;
+    
+    /*
+     * total长度设为128，
+     * 0号单元存储不同字符的总数，
+     * 其他单元存储各种不同字符的数量。
+     *
+     * 注：不统计空字符'\0'
+     */
+    total = (int*) malloc(128 * sizeof(int));
+    memset(total, 0, 128 * sizeof(int));
+    
+    for(i = 1; i <= S[0]; i++) {
+        // 如果遇到了新字符，则统计不同字符的数量
+        if(total[S[i]] == 0) {
+            total[0]++;
+        }
+        
+        // 统计遇到的字符数量
+        total[S[i]]++;
+    }
+    
+    return total;
+}

CLion/ExerciseBook/04.18/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.18 SString.h SString.c 04.18.c)
+# 链接公共库
+target_link_libraries(04.18 Scanf_lib)

CLion/ExerciseBook/04.18/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

CLion/ExerciseBook/04.19/04.19.c

@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "SString.h"    //**▲04 串**//
+
+/*
+ * R=S-S∩T，数组a存储R中每个字符在S中第一次出现的位置
+ *
+ * 注：数组a的0号单元存储的是a中元素的个数
+ */
+void Algo_4_19(SString R, SString S, SString T, int** a);
+
+
+int main(int argc, char* argv[]) {
+    char* s = "amdhcjgfdlpinbefcopgkqikeb";
+    char* t = "mhjlpinopkqik";
+    int* a;
+    SString T, S, R;
+    int i;
+    
+    printf("初始化S和T...\n");
+    StrAssign(S, s);
+    StrAssign(T, t);
+    
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    
+    Algo_4_19(R, S, T, &a);
+    printf("R = ");
+    StrPrint(R);
+    printf("a = ");
+    for(i = 1; i <= a[0]; i++) {
+        printf("%d ", a[i]);
+    }
+    printf("\n");
+    
+    return 0;
+}
+
+
+/*
+ * R=S-S∩T，数组a存储R中每个字符在S中第一次出现的位置
+ *
+ * 注：数组a的0号单元存储的是a中元素的个数
+ */
+void Algo_4_19(SString R, SString S, SString T, int** a) {
+    int i, p;
+    SString ch;
+    
+    *a = (int*) malloc((StrLength(S) + 1) * sizeof(int));
+    
+    StrAssign(R, "");
+    
+    for(i = 1, (*a)[0] = 0; i <= StrLength(S); i++) {
+        // 取出字符进行判断
+        SubString(ch, S, i, 1);
+        
+        // 获取S[i]在T中的位置
+        p = Index_2(T, ch, 1);
+        
+        // 如果S[i]不在T中
+        if(p == 0) {
+            // 获取S[i]在R中的位置
+            p = Index_2(R, ch, 1);
+        }
+        
+        // 如果S[i]既不在T中，又没在R中出现过
+        if(p == 0) {
+            (*a)[0]++;
+            (*a)[(*a)[0]] = i;
+            
+            // 向R中添加S[i]
+            StrInsert(R, (*a)[0], ch);
+        }
+    }
+}

CLion/ExerciseBook/04.19/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.19 SString.h SString.c 04.19.c)
+# 链接公共库
+target_link_libraries(04.19 Scanf_lib)

CLion/ExerciseBook/04.19/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

CLion/ExerciseBook/04.20/04.20.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include "Status.h"     //**▲01 绪论**//
+#include "SString.h"    //**▲04 串**//
+
+/*
+ * 删除S中包含的T
+ */
+Status Algo_4_20(SString S, SString T);
+
+
+int main(int argc, char* argv[]) {
+    char* s = "----***--*-**-****-*****-----";
+    char* t = "**";
+    SString T, S;
+    
+    printf("删除前...\n");
+    StrAssign(S, s);
+    StrAssign(T, t);
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    
+    printf("删除后...\n");
+    printf("S = ");
+    Algo_4_20(S, T);
+    StrPrint(S);
+    
+    return 0;
+}
+
+
+/*
+ * 删除S中包含的T
+ */
+Status Algo_4_20(SString S, SString T) {
+    int i;
+    
+    // 在S中查找T，如果找到就删除
+    while((i = Index_2(S, T, 1)) != 0) {
+        if(StrDelete(S, i, StrLength(T)) == ERROR) {
+            return ERROR;
+        }
+    }
+    
+    return OK;
+}

CLion/ExerciseBook/04.20/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.20 SString.h SString.c 04.20.c)
+# 链接公共库
+target_link_libraries(04.20 Scanf_lib)

CLion/ExerciseBook/04.20/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

CLion/ExerciseBook/04.21/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.21 04.21.c)
+# 链接公共库
+target_link_libraries(04.21 Scanf_lib)

CLion/ExerciseBook/04.22/04.22.c

@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include "LString.h"    //**▲04 串**//
+
+/*
+ * 将S插入到T中的字符c之后。
+ * 如果有多个c，则将S插入到从左向右遍历T时遇到的首个c之后。
+ * 如果T在不存在c，则将S插入到T的末尾。
+ */
+void Algo_4_22(LString* T, char ch, LString S);
+
+
+int main(int argc, char* argv[]) {
+    char* t = "----***--*-**-**^**-*****-----";
+    char* s = "12345";
+    char ch = '^';
+    LString T, S;
+    
+    StrAssign(&T, t);
+    StrAssign(&S, s);
+    printf("T = ");
+    StrPrint(T);
+    printf("S = ");
+    StrPrint(S);
+    
+    Algo_4_22(&T, ch, S);
+    printf("T = ");
+    StrPrint(T);
+    
+    return 0;
+}
+
+
+/*
+ * 将S插入到T中的字符c之后。
+ * 如果有多个c，则将S插入到从左向右遍历T时遇到的首个c之后。
+ * 如果T在不存在c，则将S插入到T的末尾。
+ */
+void Algo_4_22(LString* T, char c, LString S) {
+    int i;
+    char tmp[2];
+    LString Tmp;
+    
+    // 构造目标串
+    tmp[0] = c;
+    tmp[1] = '\0';
+    StrAssign(&Tmp, tmp);
+    
+    // 寻找字符c在T中的位置
+    i = Index((*T), Tmp, 1);
+    
+    // 如果找到了c，则将S插入到字符c之后
+    if(i != 0) {
+        StrInsert(T, i + 1, S);
+        
+        // 如果没找到c，则将S插入到T的末尾
+    } else {
+        StrInsert(T, (*T).curlen + 1, S);
+    }
+} 

CLion/ExerciseBook/04.22/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.22 LString.h LString.c 04.22.c)
+# 链接公共库
+target_link_libraries(04.22 Scanf_lib)

CLion/ExerciseBook/04.22/LString.h

@@ -0,0 +1,169 @@
+/*=============================
+ * 串的块链分配存储表示（块链串）
+ ==============================*/
+
+#ifndef LSTRING_H
+#define LSTRING_H
+
+#include <stdio.h>
+#include <stdlib.h>     // 提供malloc、realloc、free、exit原型
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define CHUNKSIZE 3     // 块大小（自定义）
+
+/* 串的块链存储结构 */
+typedef struct Chunk {
+    char ch[CHUNKSIZE];  // 当前块中的内容
+    struct Chunk* next;  // 指向下一个块
+} Chunk;
+
+/* 串的块链存储类型定义 */
+typedef struct {
+    Chunk* head;    //串的头指针
+    Chunk* tail;    //串的尾指针
+    int curlen;     //串的当前长度
+} LString;
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+/*
+ * ████ 注意 ████
+ *
+ * 1.教材示例中使用#作为非串值字符，而这里使用C语言中的\0作为非串值字符
+ * 2.教材中指出，块链的最后一个块中，末尾可能是用非串值字符填充的。
+ *   例如块大小为4，长度为14的块可能为：ＡＢＣＤ -> ＥＦＧＨ -> ＩＪＫＬ -> ＭＮ\0\0
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(LString* T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ */
+Status DestroyString(LString* S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(LString* S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(LString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(LString S);
+
+/*
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(LString* Sub, LString S, int pos, int len);
+
+/*
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index(LString S, LString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(LString* S, int pos, LString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(LString* S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrCompare(LString S, LString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(LString* T, LString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 1.该操作依赖最小操作子集
+ * 2.该实现比较低效
+ */
+Status Replace(LString* S, LString T, LString V);
+
+/*
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(LString* T, LString S1, LString S2);
+
+// 测试函数，打印字符串
+void StrPrint(LString S);
+
+#endif

CLion/ExerciseBook/04.23/04.23.c

@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include "LString.h"    //**▲04 串**//
+
+/*
+ * 判断给定的串是否对称。
+ * 空串或单字符的串会被认为是对称的。
+ */
+Status Algo_4_23(LString T);
+
+
+int main(int argc, char* argv[]) {
+    char* t = "abcdefgfedcba";
+    LString T;
+    
+    StrAssign(&T, t);
+    printf("T = ");
+    StrPrint(T);
+    
+    Algo_4_23(T) ? printf("T是对称串！\n") : printf("T是非对称串！！\n");
+    
+    return 0;
+}
+
+
+/*
+ * 判断给定的串是否对称。
+ * 空串或单字符的串会被认为是对称的。
+ */
+Status Algo_4_23(LString T) {
+    int len;    // T的长度
+    
+    int a1, b1; // T的前半部分边界
+    int a2, b2; // T的后半部分边界
+    int k;      // 限制遍历T时需要经过的元素数量
+    int i;      // 遍历T时的游标
+    Chunk* t;
+    
+    char* stack;    // 模拟栈
+    int top;        // 栈游标
+    
+    char c;         // 从T中取出的字符
+    
+    len = StrLength(T);
+    
+    // 空串被认为是对称的
+    if(len == 0) {
+        return OK;
+    }
+    
+    // 如果串的长度是偶数
+    if(len % 2 == 0) {
+        a1 = 0;
+        b1 = len / 2 - 1;
+        a2 = len / 2;
+        b2 = len - 1;
+        // 如果串的长度是奇数
+    } else {
+        a1 = 0;
+        b1 = len / 2 - 1;
+        a2 = len / 2 + 1;
+        b2 = len - 1;
+    }
+    
+    stack = (char*) malloc(len * sizeof(char));
+    top = -1;
+    
+    i = 0;
+    t = T.head;
+    
+    // 对于串的前半部分，将其入栈
+    for(k = a1; k <= b1; k++) {
+        c = t->ch[i];
+        i = (i + 1) % CHUNKSIZE;
+        if(i == 0) {
+            t = t->next;
+        }
+        
+        stack[++top] = c;
+    }
+    
+    // 如果串长为奇数，需要跨过一个字符
+    if(len % 2 == 1) {
+        i = (i + 1) % CHUNKSIZE;
+        if(i == 0) {
+            t = t->next;
+        }
+    }
+    
+    for(k = a2; k <= b2; k++) {
+        c = t->ch[i];
+        i = (i + 1) % CHUNKSIZE;
+        if(i == 0) {
+            t = t->next;
+        }
+        
+        // 遇到了不对称的字符
+        if(stack[top--] != c) {
+            return ERROR;
+        }
+    }
+    
+    if(top == -1) {
+        return OK;
+    } else {
+        return ERROR;
+    }
+}

CLion/ExerciseBook/04.23/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.23 LString.h LString.c 04.23.c)
+# 链接公共库
+target_link_libraries(04.23 Scanf_lib)

CLion/ExerciseBook/04.23/LString.h

@@ -0,0 +1,169 @@
+/*=============================
+ * 串的块链分配存储表示（块链串）
+ ==============================*/
+
+#ifndef LSTRING_H
+#define LSTRING_H
+
+#include <stdio.h>
+#include <stdlib.h>     // 提供malloc、realloc、free、exit原型
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define CHUNKSIZE 3     // 块大小（自定义）
+
+/* 串的块链存储结构 */
+typedef struct Chunk {
+    char ch[CHUNKSIZE];  // 当前块中的内容
+    struct Chunk* next;  // 指向下一个块
+} Chunk;
+
+/* 串的块链存储类型定义 */
+typedef struct {
+    Chunk* head;    //串的头指针
+    Chunk* tail;    //串的尾指针
+    int curlen;     //串的当前长度
+} LString;
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+/*
+ * ████ 注意 ████
+ *
+ * 1.教材示例中使用#作为非串值字符，而这里使用C语言中的\0作为非串值字符
+ * 2.教材中指出，块链的最后一个块中，末尾可能是用非串值字符填充的。
+ *   例如块大小为4，长度为14的块可能为：ＡＢＣＤ -> ＥＦＧＨ -> ＩＪＫＬ -> ＭＮ\0\0
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(LString* T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ */
+Status DestroyString(LString* S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(LString* S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(LString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(LString S);
+
+/*
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(LString* Sub, LString S, int pos, int len);
+
+/*
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index(LString S, LString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(LString* S, int pos, LString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(LString* S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrCompare(LString S, LString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(LString* T, LString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 1.该操作依赖最小操作子集
+ * 2.该实现比较低效
+ */
+Status Replace(LString* S, LString T, LString V);
+
+/*
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(LString* T, LString S1, LString S2);
+
+// 测试函数，打印字符串
+void StrPrint(LString S);
+
+#endif

CLion/ExerciseBook/04.24-04.26/04.24-04.26.c

@@ -0,0 +1,101 @@
+#include <stdio.h>
+#include "Status.h"     //**▲01 绪论**//
+#include "HString.h"    //**▲04 串**//
+
+/*
+ * 联接：Concat
+ *
+ *【注】
+ * 该函数已在HString相关文件中定义
+ */
+Status Algo_4_24(HString* T, HString S1, HString S2);
+
+/*
+ * 替换：Replace
+ *
+ *【注】
+ * 该函数已在HString相关文件中定义
+ */
+Status Algo_4_25(HString* S, HString T, HString V);
+
+/*
+ * 插入：StrInsert
+ *
+ *【注】
+ * 该函数已在HString相关文件中定义
+ */
+Status Algo_4_26(HString* S, int pos, HString T);
+
+
+int main(int argc, char* argv[]) {
+    char* s = "---*^***^*^*^*---";
+    char* s1 = "*";
+    char* s2 = "^*";
+    char* v = "*_*";
+    HString S1, S2, T, V, S;
+    
+    StrAssign(&S1, s1);
+    StrAssign(&S2, s2);
+    StrAssign(&V, v);
+    StrAssign(&S, s);
+    
+    printf("S1 = ");
+    StrPrint(S1);
+    printf("S2 = ");
+    StrPrint(S2);
+    printf("V = ");
+    StrPrint(V);
+    printf("S = ");
+    StrPrint(S);
+    
+    printf("███题 4.24 验证...███\n");
+    printf("连接S1和S2为T...\n");
+    Algo_4_24(&T, S1, S2);
+    printf("T = ");
+    StrPrint(T);
+    
+    printf("███题 4.25 验证...███\n");
+    printf("用 V 替换 S 中的 T...\n");
+    Algo_4_25(&S, T, V);
+    printf("S = ");
+    StrPrint(S);
+    
+    printf("███题 4.26 验证...███\n");
+    printf("将 T 插入到 S 的第 2 个位置...\n");
+    Algo_4_26(&S, 2, T);
+    printf("S = ");
+    StrPrint(S);
+    
+    return 0;
+}
+
+
+/*
+ * 联接：Concat
+ *
+ *【注】
+ * 该函数已在HString相关文件中定义
+ */
+Status Algo_4_24(HString* T, HString S1, HString S2) {
+    return Concat(T, S1, S2);
+}
+
+/*
+ * 替换：Replace
+ *
+ *【注】
+ * 该函数已在HString相关文件中定义
+ */
+Status Algo_4_25(HString* S, HString T, HString V) {
+    return Replace(S, T, V);
+}
+
+/*
+ * 插入：StrInsert
+ *
+ *【注】
+ * 该函数已在HString相关文件中定义
+ */
+Status Algo_4_26(HString* S, int pos, HString T) {
+    return StrInsert(S, pos, T);
+}

CLion/ExerciseBook/04.24-04.26/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.24-04.26 HString.h HString.c 04.24-04.26.c)
+# 链接公共库
+target_link_libraries(04.24-04.26 Scanf_lib)

CLion/ExerciseBook/04.24-04.26/HString.h

@@ -0,0 +1,159 @@
+/*=========================
+ * 串的堆分配存储表示（堆串）
+ *
+ * 包含算法: 4.4
+ ==========================*/
+
+#ifndef HSTRING
+#define HSTRING
+
+#include <stdio.h>
+#include <stdlib.h>     // 提供malloc、realloc、free、exit原型
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/*
+ * 串的堆存储表示
+ *
+ * 注：有效元素从ch的0号单元开始存储
+ */
+typedef struct {
+    char* ch;           // 若是非空串，则按串长分配存储区，否则ch为NULL
+    int length;
+} HString;
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(HString* T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ */
+Status DestroyString(HString* S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(HString* S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(HString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(HString S);
+
+/*
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(HString* Sub, HString S, int pos, int len);
+
+/*
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index(HString S, HString T, int pos);
+
+/*
+ * ████████ 算法4.4 ████████
+ *
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(HString* S, int pos, HString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(HString* S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrCompare(HString S, HString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(HString* T, HString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 1.该操作依赖最小操作子集
+ * 2.该实现比较低效
+ */
+Status Replace(HString* S, HString T, HString V);
+
+/*
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(HString* T, HString S1, HString S2);
+
+// 输出：打印字符串
+void StrPrint(HString S);
+
+#endif

CLion/ExerciseBook/04.27/04.27.c

@@ -0,0 +1,81 @@
+#include <stdio.h>
+#include "SString.h"    //**▲04 串**//
+
+/* 函数原型 */
+int Algo_4_27(SString S, SString T, int pos);
+
+
+/*
+ * 查找：Index
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 相比与传统的Index函数，其改进之处在于会先比较首个字符与末尾字符，
+ * 当它们都匹配时，才会继续比较剩下的字符
+ */
+int main(int argc, char* argv[]) {
+    char* s = "aaaaaaaaaaaaaaab";
+    char* t = "aaaab";
+    SString S, T;
+    
+    StrAssign(S, s);
+    StrAssign(T, t);
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    
+    printf("T在S中首次出现的位置为：");
+    printf("%d\n", Algo_4_27(S, T, 1));
+    
+    return 0;
+}
+
+
+/*
+ * 查找：Index
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 相比与传统的Index函数，其改进之处在于会先比较首个字符与末尾字符，
+ * 当它们都匹配时，才会继续比较剩下的字符
+ */
+int Algo_4_27(SString S, SString T, int pos) {
+    int i, j;
+    
+    if(pos < 1 || pos > S[0] || T[0] == 0) {
+        return 0;
+    }
+    
+    i = pos;
+    j = 1;
+    
+    while(i <= S[0] - T[0] + 1) {
+        // 先尝试比较首个字符与末尾字符
+        if(S[i] != T[j] || S[i + T[0] - 1] != T[T[0]]) {
+            i++;
+            continue;
+        }
+        
+        // 这里的j不需要等于T[0]，因为T[0]这种情形已经验证了
+        for(i++,j++; j<T[0] && S[i]==T[j]; i++,j++) {
+            // 查找失配位置
+        }
+    
+        // 找到了匹配的字符串
+        if(j==T[0]) {
+            return i-j+1;
+            
+            // 如果没找到，游标回退，重新比较
+        } else {
+            i = i-j+2;
+            j = 1;
+        }
+    }
+    
+    return 0;
+}

CLion/ExerciseBook/04.27/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.27 SString.h SString.c 04.27.c)
+# 链接公共库
+target_link_libraries(04.27 Scanf_lib)

CLion/ExerciseBook/04.27/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

CLion/ExerciseBook/04.28-04.29/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.28-04.29 04.28-04.29.c)
+# 链接公共库
+target_link_libraries(04.28-04.29 Scanf_lib)

CLion/ExerciseBook/04.30/04.30.c

@@ -0,0 +1,116 @@
+#include <stdio.h>
+#include "SString.h"    //**▲04 串**//
+
+/*
+ * 在串S中查找首次出现的最长重复子串及其位置
+ * Sub用来记录重复子串
+ * pos用来记录其在S中出现的位置
+ *
+ * 此处的最长重复子串有以下含义：
+ * 1.子串必须连续
+ * 2.此子串在所有重复子串中是首个出现且最长的；
+ * 3.子串间可以重叠，比如求取abcabca的结果为abca；
+ * 4.子串内可以重复，如求取aaaa的结果为aaa。
+ */
+Status Algo_4_30(SString S, SString Sub, int* pos);
+
+
+int main(int argc, char* argv[]) {
+    char* s = "abcdeabcabcbcdefbcdefefghefgh";
+    SString Sub, S;
+    int pos;
+    
+    StrAssign(S, s);
+    printf("主串...\n");
+    printf("S   = ");
+    StrPrint(S);
+    
+    printf("计算首个最长不重复子串...\n");
+    printf("Sub = ");
+    Algo_4_30(S, Sub, &pos);
+    StrPrint(Sub);
+    printf("Sub 在 S 中首次出现的位置为 %d\n", pos);
+    
+    return 0;
+}
+
+
+/*
+ * 在串S中查找首次出现的最长重复子串及其位置
+ * Sub用来记录重复子串
+ * pos用来记录其在S中出现的位置
+ *
+ * 此处的最长重复子串有以下含义：
+ * 1.子串必须连续
+ * 2.此子串在所有重复子串中是首个出现且最长的；
+ * 3.子串间可以重叠，比如求取abcabca的结果为abca；
+ * 4.子串内可以重复，如求取aaaa的结果为aaa。
+ */
+Status Algo_4_30(SString S, SString Sub, int* pos) {
+    int i, j, is, js;
+    int k, start;
+    int len, maxLen;
+    
+    // 主串长度不能少于2
+    if(S[0] < 2) {
+        return ERROR;
+    }
+    
+    start = 0;
+    maxLen = 0;
+    
+    // 遍历主串上所有可能的起点
+    for(k = 1; k < S[0]; k++) {
+        is = k;     // 主串起点
+        js = k + 1;   // 子串起点
+        
+        // 如果剩余的字符数量不比已知的最长重复字符串更长，则无需再遍历下去
+        if(S[0] - js + 1 <= maxLen) {
+            break;
+        }
+        
+        // 查找与is为起点的串重复的串
+        while(TRUE) {
+            // 寻找潜在的重复子串起点
+            while(js <= S[0] && S[is] != S[js]) {
+                js++;
+            }
+            
+            // 说明主串起点处的字符串唯一
+            if(js > S[0]) {
+                break;
+            }
+            
+            // 如果剩余的字符数量不比已知的最长重复字符串更长，则无需再遍历下去
+            if(S[0] - js + 1 <= maxLen) {
+                break;
+            }
+            
+            len = 0;
+            i = is;
+            j = js;
+            
+            // 计算重复串的长度
+            while(j <= S[0] && S[i] == S[j]) {
+                i++;
+                j++;
+                len++;
+            }
+            
+            if(len > maxLen) {
+                start = k;
+                maxLen = len;
+            }
+            
+            // 查看后面有没有更长的重复串
+            if(j < S[0]) {
+                js++;
+            }
+        }
+    }
+    
+    *pos = start;
+    SubString(Sub, S, start, maxLen);
+    
+    return OK;
+}

CLion/ExerciseBook/04.30/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.30 SString.h SString.c 04.30.c)
+# 链接公共库
+target_link_libraries(04.30 Scanf_lib)

CLion/ExerciseBook/04.30/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

CLion/ExerciseBook/04.31/CMakeLists.txt

@@ -0,0 +1,7 @@
+# 包含公共库
+include_directories(${CMAKE_SOURCE_DIR}/Status)
+
+# 生成可执行文件
+add_executable(04.31 SString.h SString.c 04.31.c)
+# 链接公共库
+target_link_libraries(04.31 Scanf_lib)

CLion/ExerciseBook/04.31/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

CLion/ExerciseBook/CMakeLists.txt

@@ -49,3 +49,21 @@ add_subdirectory(03.30+03.32)
 add_subdirectory(03.31)
 add_subdirectory(03.33)
 add_subdirectory(03.34)
+
+add_subdirectory(04.10)
+add_subdirectory(04.11)
+add_subdirectory(04.12)
+add_subdirectory(04.13)
+add_subdirectory(04.14)
+add_subdirectory(04.15-04.17)
+add_subdirectory(04.18)
+add_subdirectory(04.19)
+add_subdirectory(04.20)
+add_subdirectory(04.21)
+add_subdirectory(04.22)
+add_subdirectory(04.23)
+add_subdirectory(04.24-04.26)
+add_subdirectory(04.27)
+add_subdirectory(04.28-04.29)
+add_subdirectory(04.30)
+add_subdirectory(04.31)

Dev-C++/ExerciseBook/04.10/04.10.cpp

@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include "String.h"    //**字符串**//
+
+/*
+ * 字符串逆置：将T逆置为R。
+ */
+StringType Algo_4_10(StringType T) {
+    int i;
+    StringType R = "", Sub;
+    
+    // 从后向前截取字符
+    for(i = StrLength(T); i >= 1; i--) {
+        Sub = SubString(T, i, 1);
+        R = Concat(R, Sub);
+    }
+    
+    return R;
+}
+
+
+int main(int argc, char* argv[]) {
+    char* s = "0123456789";
+    StringType T, R;
+    
+    printf("逆置前，T = ");
+    StrAssign(&T, s);
+    StrPrint(T);
+    
+    printf("逆置后，R = ");
+    R = Algo_4_10(T);
+    StrPrint(R);
+    
+    return 0;
+}
+

Dev-C++/ExerciseBook/04.10/04.10.dev

@@ -0,0 +1,82 @@
+[Project]
+FileName=04.10.dev
+Name=04.10
+Type=1
+Ver=2
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=0
+Icon=
+ExeOutput=
+ObjectOutput=
+LogOutput=
+LogOutputEnabled=0
+OverrideOutput=0
+OverrideOutputName=
+HostApplication=
+UseCustomMakefile=0
+CustomMakefile=
+CommandLine=
+Folders=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=1
+CompilerSettings=0000000000000000001000000
+UnitCount=3
+
+[VersionInfo]
+Major=1
+Minor=0
+Release=0
+Build=0
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+SyncProduct=1
+
+[Unit1]
+FileName=04.10.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit2]
+FileName=String.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit3]
+FileName=String.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+

Dev-C++/ExerciseBook/04.10/String.cpp

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

Dev-C++/ExerciseBook/04.10/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

Dev-C++/ExerciseBook/04.11/04.11.cpp

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "String.h"    //**字符串**//
+
+/*
+ * R=S-S∩T，数组a存储R中每个字符在S中第一次出现的位置
+ *
+ * 注：数组a的0号单元存储的是a中元素的个数
+ */
+void Algo_4_11(StringType* R, StringType S, StringType T, int** a) {
+    int i, p;
+    StringType ch;
+    
+    *a = (int*) malloc((StrLength(S) + 1) * sizeof(int));
+    
+    StrAssign(R, "");
+    
+    for(i = 1, (*a)[0] = 0; i <= StrLength(S); i++) {
+        // 取出字符进行判断
+        ch = SubString(S, i, 1);
+        
+        // 获取S[i]在T中的位置
+        p = Index(T, ch, 1);
+        
+        // 如果S[i]不在T中
+        if(p == 0) {
+            // 获取S[i]在R中的位置
+            p = Index(*R, ch, 1);
+        }
+        
+        // 如果S[i]既不在T中，又没在R中出现过
+        if(p == 0) {
+            (*a)[0]++;
+            (*a)[(*a)[0]] = i;
+            
+            // 向R中添加S[i]
+            StrInsert(R, (*a)[0], ch);
+        }
+    }
+}
+
+
+int main(int argc, char* argv[]) {
+    char* s = "amdhcjgfdlpinbefcopgkqikeb";
+    char* t = "mhjlpinopkqik";
+    int* a;
+    StringType T, S, R;
+    int i;
+    
+    printf("初始化S和T...\n");
+    StrAssign(&S, s);
+    StrAssign(&T, t);
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    
+    Algo_4_11(&R, S, T, &a);
+    printf("R = ");
+    StrPrint(R);
+    
+    printf("a = ");
+    for(i = 1; i <= a[0]; i++) {
+        printf("%d ", a[i]);
+    }
+	printf("\n");
+    
+    return 0;
+}

Dev-C++/ExerciseBook/04.11/04.11.dev

@@ -0,0 +1,82 @@
+[Project]
+FileName=04.11.dev
+Name=04.11
+Type=1
+Ver=2
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=0
+Icon=
+ExeOutput=
+ObjectOutput=
+LogOutput=
+LogOutputEnabled=0
+OverrideOutput=0
+OverrideOutputName=
+HostApplication=
+UseCustomMakefile=0
+CustomMakefile=
+CommandLine=
+Folders=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=1
+CompilerSettings=0000000000000000001000000
+UnitCount=3
+
+[VersionInfo]
+Major=1
+Minor=0
+Release=0
+Build=0
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+SyncProduct=1
+
+[Unit1]
+FileName=04.11.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit2]
+FileName=String.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit3]
+FileName=String.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+

Dev-C++/ExerciseBook/04.11/String.cpp

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

Dev-C++/ExerciseBook/04.11/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

Dev-C++/ExerciseBook/04.12/04.12.cpp

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include "Status.h"    //**▲01 绪论**//
+#include "String.h"    //**字符串**//
+
+/*
+ * 替换：Replace
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串
+ */
+Status Algo_4_12(StringType* S, StringType T, StringType V) {
+    int i;
+    
+    if(StrLength(*S) == 0 || StrLength(T) == 0) {
+        return ERROR;
+    }
+    
+    i = 1;
+    
+    // 在主串S中寻找模式串T第一次出现的位置
+    while((i = Index(*S, T, i)) != 0) {
+        StrDelete(S, i, StrLength(T));  // 从S中删除T
+        StrInsert(S, i, V);             // 向S中插入V
+        
+        i += StrLength(V);  // i切换到下一个位置
+    }
+    
+    return OK;
+}
+
+
+int main(int argc, char* argv[]) {
+    char* s = "----***--*-**-****-*****-----";
+    char* t = "**";
+    char* v = "^^";
+    StringType T, S, V;
+    
+    printf("替换前...\n");
+    
+    StrAssign(&S, s);
+    StrAssign(&T, t);
+    StrAssign(&V, v);
+    
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    printf("V = ");
+    StrPrint(V);
+    
+    printf("替换后...\n");
+    printf("S = ");
+    Algo_4_12(&S, T, V);
+    StrPrint(S);
+    
+    return 0;
+}

Dev-C++/ExerciseBook/04.12/04.12.dev

@@ -0,0 +1,82 @@
+[Project]
+FileName=04.12.dev
+Name=04.12
+Type=1
+Ver=2
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=0
+Icon=
+ExeOutput=
+ObjectOutput=
+LogOutput=
+LogOutputEnabled=0
+OverrideOutput=0
+OverrideOutputName=
+HostApplication=
+UseCustomMakefile=0
+CustomMakefile=
+CommandLine=
+Folders=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=1
+CompilerSettings=0000000000000000001000000
+UnitCount=3
+
+[VersionInfo]
+Major=1
+Minor=0
+Release=0
+Build=0
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+SyncProduct=1
+
+[Unit1]
+FileName=04.12.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit2]
+FileName=String.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit3]
+FileName=String.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+

Dev-C++/ExerciseBook/04.12/String.cpp

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

Dev-C++/ExerciseBook/04.12/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

Dev-C++/ExerciseBook/04.13/04.13.cpp

@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include "String.h"    //**字符串**//
+
+/*
+ * 删除S中包含的T
+ */
+Status Algo_4_13(StringType* S, StringType T) {
+    int i;
+    
+    // 在S中查找T，如果找到就删除
+    while((i = Index(*S, T, 1)) != 0) {
+        if(StrDelete(S, i, StrLength(T)) == ERROR) {
+            return ERROR;
+        }
+    }
+    
+    return OK;
+}
+
+
+int main(int argc, char* argv[]) {
+    char* s = "----***--*-**-****-*****-----";
+    char* t = "**";
+    StringType T, S;
+    
+    printf("删除前...\n");
+    StrAssign(&S, s);
+    StrAssign(&T, t);
+    
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    
+    printf("删除后...\n");
+    printf("S = ");
+    Algo_4_13(&S, T);
+    StrPrint(S);
+    
+    return 0;
+}

Dev-C++/ExerciseBook/04.13/04.13.dev

@@ -0,0 +1,82 @@
+[Project]
+FileName=04.13.dev
+Name=04.13
+Type=1
+Ver=2
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=0
+Icon=
+ExeOutput=
+ObjectOutput=
+LogOutput=
+LogOutputEnabled=0
+OverrideOutput=0
+OverrideOutputName=
+HostApplication=
+UseCustomMakefile=0
+CustomMakefile=
+CommandLine=
+Folders=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=1
+CompilerSettings=0000000000000000001000000
+UnitCount=3
+
+[VersionInfo]
+Major=1
+Minor=0
+Release=0
+Build=0
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+SyncProduct=1
+
+[Unit1]
+FileName=04.13.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit2]
+FileName=String.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit3]
+FileName=String.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+

Dev-C++/ExerciseBook/04.13/String.cpp

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

Dev-C++/ExerciseBook/04.13/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

Dev-C++/ExerciseBook/04.14/04.14.cpp

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <string.h>
+#include "SqStack.h"    //**▲03 栈和队列**//
+#include "String.h"     //**字符串**//
+
+/*
+ * 将前缀表达式prefix转换为后缀表达式
+ *
+ *【注】
+ * 未对前缀表达式的正确性进行验证
+ */
+Status Algo_4_14(const char* prefix, char** suffix) {
+    StringType P, S;
+    StringType Operator;    // 运算符
+    SqStack stack;          // 表达式栈
+    StringType e;           // 栈顶元素
+    StringType o;           // 靠近栈顶的运算符
+    int i, len;
+    int readStr;    // 是否需要读取字符串
+    
+    len = (int) strlen(prefix);
+    
+    if(len == 0) {
+        *suffix = NULL;
+        return ERROR;
+    }
+    
+    // 运算符和操作数
+    StrAssign(&Operator, "+-*/");
+    
+    // 前缀表达式
+    StrAssign(&P, prefix);
+    
+    // 后缀表达式栈
+    InitStack(&stack);
+    
+    readStr = 1;
+    i = 1;
+    
+    // 遍历前缀表达式，逐个获取元素
+    while(TRUE) {
+        if(readStr == 1) {
+            S = SubString(P, i++, 1);
+        }
+        
+        // 如果遇到了运算符，则直接入栈
+        if(Index(Operator, S, 1) != 0) {
+            Push(&stack, S);
+            readStr = 1;
+            
+            // 如果遇到了操作数
+        } else {
+            // 获取栈顶元素，如果栈已经为空，则S中存储了后缀表达式
+            if(GetTop(stack, &e) == ERROR) {
+                break;
+            }
+            
+            // 如果栈顶元素是运算符，则将操作数直接入栈
+            if(Index(Operator, e, 1) != 0) {
+                Push(&stack, S);
+                readStr = 1;
+                
+                // 否则栈顶也是操作数，需要进行简单运算
+            } else {
+                Pop(&stack, &e);    // 弹出栈顶操作数
+                Pop(&stack, &o);    // 弹出靠近栈顶的运算符
+                
+                S = Concat(e, S);
+                S = Concat(S, o);
+                
+                // 此种情形下不需要读取字符串，而需要判断刚刚计算出的Sub
+                readStr = 0;
+            }
+        }
+    }
+    
+    // 获取后缀表达式
+    *suffix = S;
+    
+    return OK;
+}
+
+
+int main(int argc, char* argv[]) {
+    char* prefix = "-+a*bc/de";  // 其后缀表达式为：abc*+de/-
+    char* suffix;
+    
+    Algo_4_14(prefix, &suffix);
+    
+    printf("前缀表达式：%s\n", prefix);
+    printf("后缀表达式：%s\n", suffix);
+}

Dev-C++/ExerciseBook/04.14/04.14.dev

@@ -0,0 +1,102 @@
+[Project]
+FileName=04.14.dev
+Name=04.14
+Type=1
+Ver=2
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=0
+Icon=
+ExeOutput=
+ObjectOutput=
+LogOutput=
+LogOutputEnabled=0
+OverrideOutput=0
+OverrideOutputName=
+HostApplication=
+UseCustomMakefile=0
+CustomMakefile=
+CommandLine=
+Folders=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=1
+CompilerSettings=0000000000000000001000000
+UnitCount=5
+
+[VersionInfo]
+Major=1
+Minor=0
+Release=0
+Build=0
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+SyncProduct=1
+
+[Unit1]
+FileName=04.14.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit2]
+FileName=SqStack.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit4]
+FileName=String.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit3]
+FileName=SqStack.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit5]
+FileName=String.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+

Dev-C++/ExerciseBook/04.14/SqStack.cpp

@@ -0,0 +1,89 @@
+/*=========================
+ * 栈的顺序存储结构（顺序栈）
+ ==========================*/
+
+#include "SqStack.h"    //**▲03 栈和队列**//
+
+/*
+ * 初始化
+ *
+ * 构造一个空栈。初始化成功则返回OK，否则返回ERROR。
+ */
+Status InitStack(SqStack* S) {
+    if(S == NULL) {
+        return ERROR;
+    }
+    
+    (*S).base = (SElemType*) malloc(STACK_INIT_SIZE * sizeof(SElemType));
+    if((*S).base == NULL) {
+        exit(OVERFLOW);
+    }
+    
+    (*S).top = (*S).base;
+    (*S).stacksize = STACK_INIT_SIZE;
+    
+    return OK;
+}
+
+/*
+ * 取值
+ *
+ * 返回栈顶元素，并用e接收。
+ */
+Status GetTop(SqStack S, SElemType* e) {
+    if(S.base == NULL || S.top == S.base) {
+        return ERROR;
+    }
+    
+    // 不会改变栈中元素
+    *e = *(S.top - 1);
+    
+    return OK;
+}
+
+/*
+ * 入栈
+ *
+ * 将元素e压入到栈顶。
+ */
+Status Push(SqStack* S, SElemType e) {
+    if(S == NULL || (*S).base == NULL) {
+        return ERROR;
+    }
+    
+    // 栈满时，追加存储空间
+    if((*S).top - (*S).base >= (*S).stacksize) {
+        (*S).base = (SElemType*) realloc((*S).base, ((*S).stacksize + STACKINCREMENT) * sizeof(SElemType));
+        if((*S).base == NULL) {
+            exit(OVERFLOW);     // 存储分配失败
+        }
+        
+        (*S).top = (*S).base + (*S).stacksize;
+        (*S).stacksize += STACKINCREMENT;
+    }
+    
+    // 进栈先赋值，栈顶指针再自增
+    *(S->top++) = e;
+    
+    return OK;
+}
+
+/*
+ * 出栈
+ *
+ * 将栈顶元素弹出，并用e接收。
+ */
+Status Pop(SqStack* S, SElemType* e) {
+    if(S == NULL || (*S).base == NULL) {
+        return ERROR;
+    }
+    
+    if((*S).top == (*S).base) {
+        return ERROR;
+    }
+    
+    // 出栈栈顶指针先递减，再赋值
+    *e = *(--(*S).top);
+    
+    return OK;
+}

Dev-C++/ExerciseBook/04.14/SqStack.h

@@ -0,0 +1,61 @@
+/*=========================
+ * 栈的顺序存储结构（顺序栈）
+ ==========================*/
+
+#ifndef SQSTACK_H
+#define SQSTACK_H
+
+#include <stdio.h>
+#include <stdlib.h>     // 提供malloc、realloc、free、exit原型
+#include "Status.h"     //**▲01 绪论**//
+#include "String.h"    //**▲04 串**//
+
+/* 宏定义 */
+#define STACK_INIT_SIZE 100     // 顺序栈存储空间的初始分配量
+#define STACKINCREMENT  10      // 顺序栈存储空间的分配增量
+
+/*
+ * 顺序栈元素类型定义
+ *
+ *【注】
+ * 这里的元素类型为字符串
+ */
+typedef StringType SElemType;
+
+// 顺序栈元素结构
+typedef struct {
+    SElemType* base;               // 栈底指针
+    SElemType* top;                // 栈顶指针
+    int stacksize;                 // 当前已分配的存储空间，以元素为单位
+} SqStack;
+
+
+/*
+ * 初始化
+ *
+ * 构造一个空栈。初始化成功则返回OK，否则返回ERROR。
+ */
+Status InitStack(SqStack* S);
+
+/*
+ * 取值
+ *
+ * 返回栈顶元素，并用e接收。
+ */
+Status GetTop(SqStack S, SElemType* e);
+
+/*
+ * 入栈
+ *
+ * 将元素e压入到栈顶。
+ */
+Status Push(SqStack* S, SElemType e);
+
+/*
+ * 出栈
+ *
+ * 将栈顶元素弹出，并用e接收。
+ */
+Status Pop(SqStack* S, SElemType* e);
+
+#endif

Dev-C++/ExerciseBook/04.14/String.cpp

@@ -0,0 +1,151 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#include "String.h"
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char* s) {
+    if(s == NULL) {
+        *t = "";
+    }
+    
+    *t = (char*) malloc((strlen(s) + 1) * sizeof(char));
+    
+    strcpy(*t, s);
+}
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t) {
+    return strcmp(s, t);
+}
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s) {
+    return (int) strlen(s);
+}
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t) {
+    StringType r;
+    
+    if(s == NULL) {
+        s = "";
+    }
+    
+    if(t == NULL) {
+        t = "";
+    }
+    
+    r = (char*) malloc((strlen(s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    strcat(r, s);
+    strcat(r, t);
+    
+    return r;
+}
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len) {
+    int n;
+    char* sub;
+    
+    n = (int) strlen(s);
+    
+    if(start < 1 || start > n || start + len - 1 > n || len < 0) {
+        return "";
+    }
+    
+    sub = (char*) malloc((len + 1) * sizeof(char));
+    strncpy(sub, s + start - 1, len);
+    sub[len] = '\0';
+    
+    return sub;
+}
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos) {
+    int m, n, i;
+    StringType sub;
+    
+    // 失败情形提前处理
+    if(pos < 1 || pos > StrLength(s) || StrLength(t) == 0) {
+        return 0;
+    }
+    
+    n = StrLength(s);
+    m = StrLength(t);
+    i = pos;
+    
+    // 保证长度不越界
+    while(i <= n - m + 1) {
+        // 获取S[i, i+m-1]
+        sub = SubString(s, i, m);
+        
+        // 如果子串与模式串不匹配，则需要继续推进
+        if(StrCompare(sub, t) != 0) {
+            ++i;
+        } else {
+            return i;
+        }
+    }
+    
+    return 0;
+}
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t) {
+    StringType r;
+    StringType s1, s2;
+    
+    if(pos < 1 || pos > StrLength(*s) + 1) {
+        return ERROR;
+    }
+    
+    r = (StringType) malloc((strlen(*s) + strlen(t) + 1) * sizeof(char));
+    r[0] = '\0';
+    
+    // 如果待插入的串为空，则提前返回
+    if(StrLength(t) == 0) {
+        return OK;
+    }
+    
+    s1 = SubString(*s, 1, pos - 1);
+    s2 = SubString(*s, pos, (int) strlen(*s) - pos + 1);
+    
+    strcat(r, s1);
+    strcat(r, t);
+    strcat(r, s2);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len) {
+    StringType r;
+    
+    if(pos < 1 || pos + len - 1 > StrLength(*s) || len < 0) {
+        return ERROR;
+    }
+    
+    // 如果待删除的长度为0，则提前返回
+    if(len == 0) {
+        return OK;
+    }
+    
+    r = (StringType) malloc((StrLength(*s) - len + 1) * sizeof(char));
+    strncpy(r, *s, pos - 1);
+    strcpy(r + pos - 1, *s + pos + len - 1);
+    
+    *s = r;
+    
+    return OK;
+}
+
+// 输出字符串
+void StrPrint(StringType s) {
+    printf("%s\n", s);
+}

Dev-C++/ExerciseBook/04.14/String.h

@@ -0,0 +1,43 @@
+/*===========================
+ * 习题4.10~4.14中使用的字符串
+ ============================*/
+
+#ifndef STRING_H
+#define STRING_H
+
+#include <stdlib.h>
+#include <string.h>     // 提供 strlen 原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 字符串类型 */
+typedef char* StringType;
+
+
+// 初始化：构造一个值为s的串t
+void StrAssign(StringType* t, const char*  s);
+
+// 比较：返回s与t的大小，如果大小一致，返回0
+int StrCompare(StringType s, StringType t);
+
+// 计数：返回字符串s的长度
+int StrLength(StringType s);
+
+// 联接：返回由s与t联接后的串
+StringType Concat(StringType s, StringType t);
+
+// 求子串：从s的start位置起，截取len个字符后返回
+StringType SubString(StringType s, int start, int len);
+
+// 查找：从s的pos位置起查找t，如果找到，返回其位置
+int Index(StringType s, StringType t, int pos);
+
+// 插入：在s的pos处插入t
+Status StrInsert(StringType* s, int pos, StringType t);
+
+// 删除：从s的pos位置起，删除len个字符
+Status StrDelete(StringType* s, int pos, int len);
+
+// 输出字符串
+void StrPrint(StringType s);
+
+#endif

Dev-C++/ExerciseBook/04.15-04.17/04.15-04.17.cpp

@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include "Status.h"     //**▲01 绪论**//
+#include "SString.h"    //**▲04 串**//
+
+/*
+ * 初始化：StrAssign
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+Status Algo_4_15(SString T, char* chars);
+
+/*
+ * 比较：StrCompare
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+int Algo_4_16(SString S, SString T);
+
+/*
+ * 替换：Replace
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+Status Algo_4_17(SString S, SString T, SString V);
+
+
+int main(int argc, char* argv[]) {
+    char* t = "ab**c*de***fg";
+    char* s = "ab**c*de***fh";
+    SString T, S, M1, M2;
+    int i;
+    
+    printf("███题 4.15 验证...███\n");
+    Algo_4_15(T, t);
+    Algo_4_15(S, s);
+    printf("T = ");
+    StrPrint(T);
+    printf("S = ");
+    StrPrint(S);
+    
+    printf("███题 4.16 验证...███\n");
+    i = Algo_4_16(S, T);
+    if(i > 0) {
+        printf("S > T\n");
+    } else if(i < 0) {
+        printf("S < T\n");
+    } else {
+        printf("S == T\n");
+    }
+    
+    printf("███题 4.17 验证...███\n");
+    Algo_4_15(M1, "**");
+    Algo_4_15(M2, "^");
+    Algo_4_17(S, M1, M2);
+    printf("用 \"^\" 替换 \"**\" 后：\nS = ");
+    StrPrint(S);
+    
+    return 0;
+}
+
+/*
+ * 初始化：StrAssign
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+Status Algo_4_15(SString T, char* chars) {
+    return StrAssign(T, chars);
+}
+
+/*
+ * 比较：StrCompare
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+int Algo_4_16(SString S, SString T) {
+    return StrCompare(S, T);
+}
+
+/*
+ * 替换：Replace
+ *
+ *【注】
+ * 该函数已在SString相关文件中定义
+ */
+Status Algo_4_17(SString S, SString T, SString V) {
+    return Replace(S, T, V);
+}

Dev-C++/ExerciseBook/04.15-04.17/04.15-04.17.dev

@@ -0,0 +1,82 @@
+[Project]
+FileName=04.15-04.17.dev
+Name=04.15-04.17
+Type=1
+Ver=2
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=0
+Icon=
+ExeOutput=
+ObjectOutput=
+LogOutput=
+LogOutputEnabled=0
+OverrideOutput=0
+OverrideOutputName=
+HostApplication=
+UseCustomMakefile=0
+CustomMakefile=
+CommandLine=
+Folders=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=1
+CompilerSettings=0000000000000000001000000
+UnitCount=3
+
+[VersionInfo]
+Major=1
+Minor=0
+Release=0
+Build=0
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+SyncProduct=1
+
+[Unit1]
+FileName=04.15-04.17.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit2]
+FileName=SString.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit3]
+FileName=SString.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+

Dev-C++/ExerciseBook/04.15-04.17/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

Dev-C++/ExerciseBook/04.18/04.18.cpp

@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "SString.h"    //**▲04 串**//
+
+/*
+ * 统计字符串S中不同字符总数与每种字符的个数，返回统计结果
+ */
+int* Algo_4_18(SString S);
+
+
+int main(int argc, char* argv[]) {
+    char* s = "dbasydujhge638940[gptokljrsehgadcsbnmv,c.b'ng[p098437eywdghswqdecxvghju";
+    SString S;
+    int* total;
+    int i;
+    
+    StrAssign(S, s);
+    printf("S = ");
+    StrPrint(S);
+    
+    total = Algo_4_18(S);
+    printf(" S 中不同的字符共计 %d 个：\n", total[0]);
+    for(i = 1; i <= 127; i++) {
+        if(total[i] != 0) {
+            printf("字符 \'%c\' 有 %d 个.\n", i, total[i]);
+        }
+    }
+    printf("统计完毕...\n");
+    
+    return 0;
+}
+
+
+/*
+ * 统计字符串S中不同字符总数与每种字符的个数，返回统计结果
+ */
+int* Algo_4_18(SString S) {
+    int i;
+    int* total;
+    
+    /*
+     * total长度设为128，
+     * 0号单元存储不同字符的总数，
+     * 其他单元存储各种不同字符的数量。
+     *
+     * 注：不统计空字符'\0'
+     */
+    total = (int*) malloc(128 * sizeof(int));
+    memset(total, 0, 128 * sizeof(int));
+    
+    for(i = 1; i <= S[0]; i++) {
+        // 如果遇到了新字符，则统计不同字符的数量
+        if(total[S[i]] == 0) {
+            total[0]++;
+        }
+        
+        // 统计遇到的字符数量
+        total[S[i]]++;
+    }
+    
+    return total;
+}

Dev-C++/ExerciseBook/04.18/04.18.dev

@@ -0,0 +1,82 @@
+[Project]
+FileName=04.18.dev
+Name=04.18
+Type=1
+Ver=2
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=0
+Icon=
+ExeOutput=
+ObjectOutput=
+LogOutput=
+LogOutputEnabled=0
+OverrideOutput=0
+OverrideOutputName=
+HostApplication=
+UseCustomMakefile=0
+CustomMakefile=
+CommandLine=
+Folders=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=1
+CompilerSettings=0000000000000000001000000
+UnitCount=3
+
+[VersionInfo]
+Major=1
+Minor=0
+Release=0
+Build=0
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+SyncProduct=1
+
+[Unit2]
+FileName=SString.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit1]
+FileName=04.18.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit3]
+FileName=SString.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+

Dev-C++/ExerciseBook/04.18/SString.h

@@ -0,0 +1,179 @@
+/*=============================
+ * 串的定长顺序存储表示（顺序串）
+ *
+ * 包含算法: 4.1、4.2、4.3、4.5
+ ==============================*/
+
+#ifndef SSTRING_H
+#define SSTRING_H
+
+#include <stdio.h>
+#include <string.h>     // 提供strlen原型
+#include "Status.h"     //**▲01 绪论**//
+
+/* 宏定义 */
+#define MAXSTRLEN 255       // 顺序串的最大串长
+
+/*
+ * 串的顺序存储类型定义
+ *
+ * 注：有效元素从SString的1号单元开始存储
+ *     SString的0号单元用来存储其长度
+ */
+typedef unsigned char SString[MAXSTRLEN + 1];       // 0号单元存放串的长度
+
+
+/*
+ * ████ 提示 ████
+ *
+ * 遵循教材的书写习惯，pos指示字符的位序(不是索引)，从1开始计数
+ */
+
+
+/*
+ * 初始化
+ *
+ * 构造一个值为chars的串T。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status StrAssign(SString T, const char* chars);
+
+/*
+ * 销毁
+ *
+ * 将串S销毁。
+ *
+ *【注】
+ * 顺序串的结构无法销毁
+ */
+Status DestroyString(SString S);
+
+/*
+ * 清空
+ *
+ * 将串S清空。
+ */
+Status ClearString(SString S);
+
+/*
+ * 判空
+ *
+ * 判断串S中是否包含有效数据。
+ *
+ * 返回值：
+ * TRUE : 串S为空
+ * FALSE: 串S不为空
+ */
+Status StrEmpty(SString S);
+
+/*
+ * 计数
+ *
+ * 返回串S中元素的个数。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrLength(SString S);
+
+/*
+ * ████████ 算法4.3 ████████
+ *
+ * 求子串
+ *
+ * 用Sub返回S[pos, pos+len-1]。
+ * 返回值指示是否截取成功。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status SubString(SString Sub, SString S, int pos, int len);
+
+/*
+ * ████████ 算法4.1 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现需要依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_1(SString S, SString T, int pos);
+
+/*
+ * ████████ 算法4.5 ████████
+ *
+ * 查找
+ *
+ * 从pos处开始搜索模式串T在主串S中首次出现的位置，如果不存在，则返回0。
+ * 如果查找成功，返回匹配的位置。
+ *
+ *【注】
+ * 1.此实现不依赖串的最小操作子集
+ * 2.该实现比较低效
+ */
+int Index_2(SString S, SString T, int pos);
+
+/*
+ * 插入
+ *
+ * 将串T插入到主串S的pos位置处。
+ */
+Status StrInsert(SString S, int pos, SString T);
+
+/*
+ * 删除
+ *
+ * 删除S[pos, pos+len-1]。
+ */
+Status StrDelete(SString S, int pos, int len);
+
+/*
+ * 比较
+ *
+ * 比较串S和串T，返回比较结果。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+int StrCompare(SString S, SString T);
+
+/*
+ * 复制
+ *
+ * 将串S复制到串T。
+ */
+Status StrCopy(SString T, SString S);
+
+/*
+ * 替换
+ *
+ * 用V替换主串S中出现的所有与T相等的且不重叠的子串。
+ *
+ *【注】
+ * 该操作依赖最小操作子集，效率较低。
+ */
+Status Replace(SString S, SString T, SString V);
+
+/*
+ * ████████ 算法4.2 ████████
+ *
+ * 串联接
+ *
+ * 联接S1和S2，并存储到T中返回。如果联接后的长度溢出，则只保留未溢出的部分。
+ * 返回值表示联接后的串是否完整。
+ *
+ *【注】
+ * 该操作属于最小操作子集
+ */
+Status Concat(SString T, SString S1, SString S2);
+
+// 输出：打印字符串
+void StrPrint(SString S);
+
+#endif

Dev-C++/ExerciseBook/04.19/04.19.cpp

@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "SString.h"    //**▲04 串**//
+
+/*
+ * R=S-S∩T，数组a存储R中每个字符在S中第一次出现的位置
+ *
+ * 注：数组a的0号单元存储的是a中元素的个数
+ */
+void Algo_4_19(SString R, SString S, SString T, int** a);
+
+
+int main(int argc, char* argv[]) {
+    char* s = "amdhcjgfdlpinbefcopgkqikeb";
+    char* t = "mhjlpinopkqik";
+    int* a;
+    SString T, S, R;
+    int i;
+    
+    printf("初始化S和T...\n");
+    StrAssign(S, s);
+    StrAssign(T, t);
+    
+    printf("S = ");
+    StrPrint(S);
+    printf("T = ");
+    StrPrint(T);
+    
+    Algo_4_19(R, S, T, &a);
+    printf("R = ");
+    StrPrint(R);
+    printf("a = ");
+    for(i = 1; i <= a[0]; i++) {
+        printf("%d ", a[i]);
+    }
+	printf("\n");
+    
+    return 0;
+}
+
+
+/*
+ * R=S-S∩T，数组a存储R中每个字符在S中第一次出现的位置
+ *
+ * 注：数组a的0号单元存储的是a中元素的个数
+ */
+void Algo_4_19(SString R, SString S, SString T, int** a) {
+    int i, p;
+    SString ch;
+    
+    *a = (int*) malloc((StrLength(S) + 1) * sizeof(int));
+    
+    StrAssign(R, "");
+    
+    for(i = 1, (*a)[0] = 0; i <= StrLength(S); i++) {
+        // 取出字符进行判断
+        SubString(ch, S, i, 1);
+        
+        // 获取S[i]在T中的位置
+        p = Index_2(T, ch, 1);
+        
+        // 如果S[i]不在T中
+        if(p == 0) {
+            // 获取S[i]在R中的位置
+            p = Index_2(R, ch, 1);
+        }
+        
+        // 如果S[i]既不在T中，又没在R中出现过
+        if(p == 0) {
+            (*a)[0]++;
+            (*a)[(*a)[0]] = i;
+            
+            // 向R中添加S[i]
+            StrInsert(R, (*a)[0], ch);
+        }
+    }
+}

Dev-C++/ExerciseBook/04.19/04.19.dev

@@ -0,0 +1,82 @@
+[Project]
+FileName=04.19.dev
+Name=04.19
+Type=1
+Ver=2
+ObjFiles=
+Includes=
+Libs=
+PrivateResource=
+ResourceIncludes=
+MakeIncludes=
+Compiler=
+CppCompiler=
+Linker=
+IsCpp=0
+Icon=
+ExeOutput=
+ObjectOutput=
+LogOutput=
+LogOutputEnabled=0
+OverrideOutput=0
+OverrideOutputName=
+HostApplication=
+UseCustomMakefile=0
+CustomMakefile=
+CommandLine=
+Folders=
+IncludeVersionInfo=0
+SupportXPThemes=0
+CompilerSet=1
+CompilerSettings=0000000000000000001000000
+UnitCount=3
+
+[VersionInfo]
+Major=1
+Minor=0
+Release=0
+Build=0
+LanguageID=1033
+CharsetID=1252
+CompanyName=
+FileVersion=
+FileDescription=Developed using the Dev-C++ IDE
+InternalName=
+LegalCopyright=
+LegalTrademarks=
+OriginalFilename=
+ProductName=
+ProductVersion=
+AutoIncBuildNr=0
+SyncProduct=1
+
+[Unit2]
+FileName=SString.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit1]
+FileName=04.19.cpp
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+
+[Unit3]
+FileName=SString.h
+CompileCpp=0
+Folder=
+Compile=1
+Link=1
+Priority=1000
+OverrideBuildCmd=0
+BuildCmd=
+