Mirrors_Framework/Data-Structure
1
0
Fork 0
mirror of https://github.com/kangjianwei/Data-Structure.git synced 2026-09-28 15:48:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

💡 <04 串>习题代码

Browse Source
This commit is contained in:
康建伟
2019-11-12 23:47:30 +08:00
parent f127e5cc2e
commit d2818b244f
244 changed files with 31894 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Dev-C++/ExerciseBook/04.10/04.10.cpp
+35
View File
@@ -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
+82
View File
@@ -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
+151
View File
@@ -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
+43
View File
@@ -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
+69
View File
@@ -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
+82
View File
@@ -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
+151
View File
@@ -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
+43
View File
@@ -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
+56
View File
@@ -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
+82
View File
@@ -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
+151
View File
@@ -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
+43
View File
@@ -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
+41
View File
@@ -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
+82
View File
@@ -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
+151
View File
@@ -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
+43
View File
@@ -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
+92
View File
@@ -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
+102
View File
@@ -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
+89
View File
@@ -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
+61
View File
@@ -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
+151
View File
@@ -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
+43
View File
@@ -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
+92
View File
@@ -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
+82
View File
@@ -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.cpp
+406
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.15-04.17/SString.h
+179
View File
@@ -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
+62
View File
@@ -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
+82
View File
@@ -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.cpp
+406
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.18/SString.h
+179
View File
@@ -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
+77
View File
@@ -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
+82
View File
@@ -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=
Dev-C++/ExerciseBook/04.19/SString.cpp
+406
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.19/SString.h
+179
View File
@@ -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.20/04.20.cpp
+47
View File
@@ -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;
}
Dev-C++/ExerciseBook/04.20/04.20.dev
+82
View File
@@ -0,0 +1,82 @@
[Project]
FileName=04.20.dev
Name=04.20
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.20.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.20/SString.cpp
+406
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.20/SString.h
+179
View File
@@ -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.21/04.21.cpp
+336
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.21/04.21.dev
+62
View File
@@ -0,0 +1,62 @@
[Project]
FileName=04.21.dev
Name=04.21
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=1
[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.21.cpp
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
Dev-C++/ExerciseBook/04.22/04.22.cpp
+59
View File
@@ -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);
}
}
Dev-C++/ExerciseBook/04.22/04.22.dev
+82
View File
@@ -0,0 +1,82 @@
[Project]
FileName=04.22.dev
Name=04.22
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=LString.cpp
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
[Unit1]
FileName=04.22.cpp
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
[Unit3]
FileName=LString.h
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
Dev-C++/ExerciseBook/04.22/LString.cpp
+747
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.22/LString.h
+169
View File
@@ -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
Dev-C++/ExerciseBook/04.23/04.23.cpp
+107
View File
@@ -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;
}
}
Dev-C++/ExerciseBook/04.23/04.23.dev
+82
View File
@@ -0,0 +1,82 @@
[Project]
FileName=04.23.dev
Name=04.23
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=LString.cpp
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
[Unit1]
FileName=04.23.cpp
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
[Unit3]
FileName=LString.h
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
Dev-C++/ExerciseBook/04.23/LString.cpp
+748
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.23/LString.h
+169
View File
@@ -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
Dev-C++/ExerciseBook/04.24-04.26/04.24-04.26.cpp
+101
View File
@@ -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);
}
Dev-C++/ExerciseBook/04.24-04.26/04.24-04.26.dev
+82
View File
@@ -0,0 +1,82 @@
[Project]
FileName=04.24-04.26.dev
Name=04.24-04.26
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.24-04.26.cpp
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
[Unit2]
FileName=HString.cpp
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
[Unit3]
FileName=HString.h
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
Dev-C++/ExerciseBook/04.24-04.26/HString.cpp
+381
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.24-04.26/HString.h
+159
View File
@@ -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
Dev-C++/ExerciseBook/04.27/04.27.cpp
+81
View File
@@ -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;
}
Dev-C++/ExerciseBook/04.27/04.27.dev
+82
View File
@@ -0,0 +1,82 @@
[Project]
FileName=04.27.dev
Name=04.27
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.27.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.27/SString.cpp
+406
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.27/SString.h
+179
View File
@@ -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.28-04.29/04.28-04.29.cpp
+211
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.28-04.29/04.28-04.29.dev
+62
View File
@@ -0,0 +1,62 @@
[Project]
FileName=04.28-04.29.dev
Name=04.28-04.29
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=1
[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.28-04.29.cpp
CompileCpp=0
Folder=
Compile=1
Link=1
Priority=1000
OverrideBuildCmd=0
BuildCmd=
Dev-C++/ExerciseBook/04.30/04.30.cpp
+116
View File
@@ -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;
}
Dev-C++/ExerciseBook/04.30/04.30.dev
+82
View File
@@ -0,0 +1,82 @@
[Project]
FileName=04.30.dev
Name=04.30
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.30.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.30/SString.cpp
+406
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.30/SString.h
+179
View File
@@ -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.31/04.31.cpp
+248
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.31/04.31.dev
+82
View File
@@ -0,0 +1,82 @@
[Project]
FileName=04.31.dev
Name=04.31
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.31.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.31/SString.cpp
+406
View File
File diff suppressed because it is too large Load Diff
Dev-C++/ExerciseBook/04.31/SString.h
+179
View File
@@ -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