diff --git a/CLion/CMakeLists.txt b/CLion/CMakeLists.txt new file mode 100644 index 0000000..c13f801 --- /dev/null +++ b/CLion/CMakeLists.txt @@ -0,0 +1,8 @@ +cmake_minimum_required(VERSION 3.14) +project(CLion C) + +set(CMAKE_C_STANDARD 90) + +add_subdirectory(Status) +add_subdirectory(CourseBook) +add_subdirectory(ExerciseBook) diff --git a/CLion/CourseBook/0201_SqList/CMakeLists.txt b/CLion/CourseBook/0201_SqList/CMakeLists.txt new file mode 100644 index 0000000..33ea50a --- /dev/null +++ b/CLion/CourseBook/0201_SqList/CMakeLists.txt @@ -0,0 +1,7 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(SqList SqList.h SqList.c SqList-main.c) +# 链接公共库 +target_link_libraries(SqList Scanf_lib) diff --git a/CLion/CourseBook/0201_SqList/SqList-main.c b/CLion/CourseBook/0201_SqList/SqList-main.c new file mode 100644 index 0000000..e61e920 --- /dev/null +++ b/CLion/CourseBook/0201_SqList/SqList-main.c @@ -0,0 +1,170 @@ +#include +#include "SqList.h" //**02 线性表**// + +// 判断data>e是否成立 +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SqList L; // 待操作的顺序表 + + int i; + ElemType e; + + printf("████████ InitList \n"); + { + printf("█ 初始化顺序表 L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf("████████ ListEmpty \n"); + { + if(ListEmpty(L) == TRUE) { + printf("█ L 为空！！\n"); + } else { + printf("█ L 不为空！\n"); + } + } + PressEnterToContinue(); + + + printf("████████ ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf("█ 作为示范，在 L 第 %d 个位置插入 \"%d\"...\n", i, 2 * i); + ListInsert(&L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf("████████ ListTraverse \n"); + { + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ ListLength \n"); + { + i = ListLength(L); + printf("█ L 的长度为 %d \n", i); + } + PressEnterToContinue(); + + + printf("████████ ListDelete \n"); + { + printf("█ 删除前的元素：L = "); + ListTraverse(L, PrintElem); + + printf("█ 尝试删除 L 中第 6 个元素...\n"); + + if(ListDelete(&L, 6, &e) == OK) { + printf("█ 删除成功，被删除元素是：\"%d\"\n", e); + } else { + printf("█ 删除失败，第 6 个元素不存在！\n"); + } + + printf("█ 删除后的元素：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ GetElem \n"); + { + GetElem(L, 4, &e); + printf("█ L 中第 4 个位置的元素为 \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf("████████ LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + printf("█ L 中第一个元素值大于 \"7\" 的元素是 \"%d\" \n", L.elem[i - 1]); + } + PressEnterToContinue(); + + + printf("████████ PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf("█ 元素 \"%d\" 的前驱为 \"%d\" \n", cur_e, e); + } else { + printf("█ 元素 \"%d\" 的前驱不存在！\n", cur_e); + } + } + PressEnterToContinue(); + + + printf("████████ NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf("█ 元素 \"%d\" 的后继为 \"%d\" \n", cur_e, e); + } else { + printf("█ 元素 \"%d\" 的后继不存在！\n", cur_e); + } + } + PressEnterToContinue(); + + + printf("████████ ClearList \n"); + { + printf("█ 清空 L 前："); + if(ListEmpty(L) == TRUE) { + printf(" L 为空！！\n"); + } else { + printf(" L 不为空！\n"); + } + + ClearList(&L); + + printf("█ 清空 L 后："); + if(ListEmpty(L) == TRUE) { + printf(" L 为空！！\n"); + } else { + printf(" L 不为空！\n"); + } + } + PressEnterToContinue(); + + + printf("████████ DestroyList \n"); + { + printf("█ 销毁 L 前："); + if(L.elem != NULL) { + printf(" L 存在！\n"); + } else { + printf(" L 不存在！！\n"); + } + + DestroyList(&L); + + printf("█ 销毁 L 后："); + if(L.elem != NULL) { + printf(" L 存在！\n"); + } else { + printf(" L 不存在！！\n"); + } + } + PressEnterToContinue(); + + + return 0; +} diff --git a/CLion/CourseBook/0201_SqList/SqList.c b/CLion/CourseBook/0201_SqList/SqList.c new file mode 100644 index 0000000..df834a4 --- /dev/null +++ b/CLion/CourseBook/0201_SqList/SqList.c @@ -0,0 +1,337 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * 销毁(结构) + * + * 释放顺序表所占内存。 + */ +Status DestroyList(SqList* L) { + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // 释放顺序表内存 + free((*L).elem); + + // 释放内存后置空指针 + (*L).elem = NULL; + + // 顺序表长度跟容量都归零 + (*L).length = 0; + (*L).listsize = 0; + + return OK; +} + +/* + * 置空(内容) + * + * 只是清理顺序表中存储的数据，不释放顺序表所占内存。 + */ +Status ClearList(SqList* L) { + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + (*L).length = 0; + + return OK; +} + +/* + * 判空 + * + * 判断顺序表中是否包含有效数据。 + * + * 返回值： + * TRUE : 顺序表为空 + * FALSE: 顺序表不为空 + */ +Status ListEmpty(SqList L) { + return L.length == 0 ? TRUE : FALSE; +} + +/* + * 计数 + * + * 返回顺序表包含的有效元素的数量。 + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * 取值 + * + * 获取顺序表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(SqList L, int i, ElemType* e) { + // 因为i的含义是位置，所以其合法范围是：[1, length] + if(i < 1 || i > L.length) { + return ERROR; //i值不合法 + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * ████████ 算法2.6 ████████ + * + * 查找 + * + * 返回顺序表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // 确保顺序表结构存在 + if(L.elem == NULL) { + return ERROR; + } + + /* + * i的初值为第1个元素的位序 + * + * 其实，更自然的写法是将i初始化为第1个元素的索引 + * 但由于教材中是按位序计数的，所以这里仍写作位序 + */ + i = 1; + + // p的初值为第1个元素的存储位置 + p = L.elem; + + // 遍历顺序表 + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * 前驱 + * + * 获取元素cur_e的前驱， + * 如果存在，将其存储到pre_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status PriorElem(SqList L, ElemType cur_e, ElemType* pre_e) { + int i; + + // 确保顺序表结构存在，且最少包含两个元素 + if(L.elem == NULL || L.length < 2) { + return ERROR; + } + + // 这里的i初始化为第1个元素的【索引】 + i = 0; + + // 从第1个元素开始，查找cur_e的位置 + while(i < L.length && L.elem[i] != cur_e) { + ++i; + } + + // 如果cur_e是首个元素(没有前驱)，或者没找到元素cur_e，返回ERROR + if(i==0 || i >= L.length) { + return ERROR; + } + + // 存储cur_e的前驱 + *pre_e = L.elem[i - 1]; + + return OK; +} + +/* + * 后继 + * + * 获取元素cur_e的后继， + * 如果存在，将其存储到next_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status NextElem(SqList L, ElemType cur_e, ElemType* next_e) { + int i; + + // 确保顺序表结构存在，且最少包含两个元素 + if(L.elem == NULL || L.length < 2) { + return ERROR; + } + + // 这里的i初始化为第1个元素的【索引】 + i = 0; + + // 从第1个元素开始，查找cur_e的位置 + while(i < L.length-1 && L.elem[i] != cur_e) { + ++i; + } + + // 如果cur_e是最后1个元素(没有前驱)，或者没找到元素cur_e，返回ERROR + if(i >= L.length-1) { + return ERROR; + } + + // 存储cur_e的前驱 + *next_e = L.elem[i + 1]; + + return OK; +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * ████████ 算法2.5 ████████ + * + * 删除 + * + * 删除顺序表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListDelete(SqList* L, int i, ElemType* e) { + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length) { + return ERROR; + } + + // p为被删除元素的位置 + p = &(*L).elem[i - 1]; + + // 1.获取被删除元素 + *e = *p; + + // 表尾元素位置 + q = (*L).elem + (*L).length - 1; + + // 2.左移元素，被删除元素的位置上会有新元素进来 + for(++p; p <= q; ++p) { + *(p - 1) = *p; + } + + // 3.表长减1 + (*L).length--; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/CourseBook/0201_SqList/SqList.h b/CLion/CourseBook/0201_SqList/SqList.h new file mode 100644 index 0000000..931ddab --- /dev/null +++ b/CLion/CourseBook/0201_SqList/SqList.h @@ -0,0 +1,149 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * 销毁(结构) + * + * 释放顺序表所占内存。 + */ +Status DestroyList(SqList* L); + +/* + * 置空(内容) + * + * 只是清理顺序表中存储的数据，不释放顺序表所占内存。 + */ +Status ClearList(SqList* L); + +/* + * 判空 + * + * 判断顺序表中是否包含有效数据。 + * + * 返回值： + * TRUE : 顺序表为空 + * FALSE: 顺序表不为空 + */ +Status ListEmpty(SqList L); + +/* + * 计数 + * + * 返回顺序表包含的有效元素的数量。 + */ +int ListLength(SqList L); + +/* + * 取值 + * + * 获取顺序表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * ████████ 算法2.6 ████████ + * + * 查找 + * + * 返回顺序表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 前驱 + * + * 获取元素cur_e的前驱， + * 如果存在，将其存储到pre_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status PriorElem(SqList L, ElemType cur_e, ElemType* pre_e); + +/* + * 后继 + * + * 获取元素cur_e的后继， + * 如果存在，将其存储到next_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status NextElem(SqList L, ElemType cur_e, ElemType* next_e); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * ████████ 算法2.5 ████████ + * + * 删除 + * + * 删除顺序表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListDelete(SqList* L, int i, ElemType* e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/CourseBook/0202_Union/CMakeLists.txt b/CLion/CourseBook/0202_Union/CMakeLists.txt new file mode 100644 index 0000000..b4fea5e --- /dev/null +++ b/CLion/CourseBook/0202_Union/CMakeLists.txt @@ -0,0 +1,7 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(Union SqList.h SqList.c Union.h Union.c Union-main.c) +# 链接公共库 +target_link_libraries(Union Scanf_lib) \ No newline at end of file diff --git a/CLion/CourseBook/0202_Union/SqList.c b/CLion/CourseBook/0202_Union/SqList.c new file mode 100644 index 0000000..c8c51f4 --- /dev/null +++ b/CLion/CourseBook/0202_Union/SqList.c @@ -0,0 +1,172 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * 计数 + * + * 返回顺序表包含的有效元素的数量。 + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * 取值 + * + * 获取顺序表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(SqList L, int i, ElemType* e) { + // 因为i的含义是位置，所以其合法范围是：[1, length] + if(i < 1 || i > L.length) { + return ERROR; //i值不合法 + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * ████████ 算法2.6 ████████ + * + * 查找 + * + * 返回顺序表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // 确保顺序表结构存在 + if(L.elem == NULL) { + return ERROR; + } + + /* + * i的初值为第1个元素的位序 + * + * 其实，更自然的写法是将i初始化为第1个元素的索引 + * 但由于教材中是按位序计数的，所以这里仍写作位序 + */ + i = 1; + + // p的初值为第1个元素的存储位置 + p = L.elem; + + // 遍历顺序表 + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/CourseBook/0202_Union/SqList.h b/CLion/CourseBook/0202_Union/SqList.h new file mode 100644 index 0000000..a640ba6 --- /dev/null +++ b/CLion/CourseBook/0202_Union/SqList.h @@ -0,0 +1,93 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * 计数 + * + * 返回顺序表包含的有效元素的数量。 + */ +int ListLength(SqList L); + +/* + * 取值 + * + * 获取顺序表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * ████████ 算法2.6 ████████ + * + * 查找 + * + * 返回顺序表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/CourseBook/0202_Union/Union-main.c b/CLion/CourseBook/0202_Union/Union-main.c new file mode 100644 index 0000000..e366224 --- /dev/null +++ b/CLion/CourseBook/0202_Union/Union-main.c @@ -0,0 +1,43 @@ +#include +#include "Union.h" //**▲02 线性表**// +#include "SqList.h" //**▲02 线性表**// + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ElemType a[5] = {5, 2, 1, 3, 9}; + ElemType b[7] = {7, 2, 6, 9, 11, 3, 10}; + SqList La, Lb; + int i; + + // 初始化La + InitList(&La); + for(i = 1; i <= 5; i++) { + ListInsert(&La, i, a[i - 1]); + } + + // 初始化Lb + InitList(&Lb); + for(i = 1; i <= 7; i++) { + ListInsert(&Lb, i, b[i - 1]); + } + + // 输出La + printf("La = "); + ListTraverse(La, PrintElem); + + // 输出Lb + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 输出新表La的内容 + printf("La = La∪Lb = "); + Union(&La, Lb); + ListTraverse(La, PrintElem); + + return 0; +} diff --git a/CLion/CourseBook/0202_Union/Union.c b/CLion/CourseBook/0202_Union/Union.c new file mode 100644 index 0000000..1e467d4 --- /dev/null +++ b/CLion/CourseBook/0202_Union/Union.c @@ -0,0 +1,45 @@ +/*============== + * 求并集 + * + * 包含算法: 2.1 + ===============*/ + +#include "Union.h" //**▲02 线性表**// + +/* + * ████████ 算法2.1 ████████ + * + * A=A∪B + * + * 计算La与Lb的并集并返回。 + * 由于生成的并集会拼接在La上，所以La的入参为指针类型。 + */ +void Union(SqList* La, SqList Lb) { + int La_len, Lb_len; + int i; + ElemType e; + + // 求顺序表长度 + La_len = ListLength(*La); + Lb_len = ListLength(Lb); + + for(i = 1; i <= Lb_len; i++) { + // 取Lb中第i个元素赋给e + GetElem(Lb, i, &e); + + // 若e不在La中则插入 + if(!LocateElem(*La, e, equal)) { + ListInsert(La, ++La_len, e); + } + } +} + +/* + * 判等 + * + * 判断两元素是否相等。 + * 如果相等，则返回TRUE，否则，返回FALSE。 + */ +Status equal(ElemType e1, ElemType e2) { + return e1 == e2 ? TRUE : FALSE; +} diff --git a/CLion/CourseBook/0202_Union/Union.h b/CLion/CourseBook/0202_Union/Union.h new file mode 100644 index 0000000..1000f6a --- /dev/null +++ b/CLion/CourseBook/0202_Union/Union.h @@ -0,0 +1,33 @@ +/*============== + * 求并集 + * + * 包含算法: 2.1 + ===============*/ + +#ifndef UNION_H +#define UNION_H + +#include +#include "Status.h" //**▲01 绪论**// +#include "SqList.h" //**▲02 线性表**// + + +/* + * ████████ 算法2.1 ████████ + * + * A=A∪B + * + * 计算La与Lb的并集并返回。 + * 由于生成的并集会拼接在La上，所以La的入参为指针类型。 + */ +void Union(SqList* La, SqList Lb); + +/* + * 判等 + * + * 判断两元素是否相等。 + * 如果相等，则返回TRUE，否则，返回FALSE。 + */ +Status equal(ElemType e1, ElemType e2); + +#endif diff --git a/CLion/CourseBook/0203_MergeSqList/CMakeLists.txt b/CLion/CourseBook/0203_MergeSqList/CMakeLists.txt new file mode 100644 index 0000000..a433255 --- /dev/null +++ b/CLion/CourseBook/0203_MergeSqList/CMakeLists.txt @@ -0,0 +1,7 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(MergeSqList SqList.h SqList.c MergeSqList.h MergeSqList.c MergeSqList-main.c) +# 链接公共库 +target_link_libraries(MergeSqList Scanf_lib) \ No newline at end of file diff --git a/CLion/CourseBook/0203_MergeSqList/MergeSqList-main.c b/CLion/CourseBook/0203_MergeSqList/MergeSqList-main.c new file mode 100644 index 0000000..ef9cb54 --- /dev/null +++ b/CLion/CourseBook/0203_MergeSqList/MergeSqList-main.c @@ -0,0 +1,49 @@ +#include +#include "SqList.h" +#include "MergeSqList.h" //**▲02 线性表**// + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ElemType a[4] = {3, 5, 8, 11}; + ElemType b[7] = {2, 6, 8, 9, 11, 15, 20}; + + SqList La, Lb, Lc1, Lc2; + int i; + + // 初始化La + InitList(&La); + for(i = 1; i <= 4; i++) { + ListInsert(&La, i, a[i - 1]); + } + + // 初始化Lb + InitList(&Lb); + for(i = 1; i <= 7; i++) { + ListInsert(&Lb, i, b[i - 1]); + } + + // 输出La + printf("La = "); + ListTraverse(La, PrintElem); + + // 输出Lb + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 归并顺序表La和Lb，算法2.2 + MergeSqList_1(La, Lb, &Lc1); + printf("归并La和Lb为Lc1 = "); + ListTraverse(Lc1, PrintElem); + + // 归并顺序表La和Lb，算法2.7 + MergeSqList_2(La, Lb, &Lc2); + printf("归并La和Lb为Lc2 = "); + ListTraverse(Lc2, PrintElem); + + return 0; +} diff --git a/CLion/CourseBook/0203_MergeSqList/MergeSqList.c b/CLion/CourseBook/0203_MergeSqList/MergeSqList.c new file mode 100644 index 0000000..62e59a7 --- /dev/null +++ b/CLion/CourseBook/0203_MergeSqList/MergeSqList.c @@ -0,0 +1,104 @@ +/*================== + * 归并非降序顺序表 + * + * 包含算法: 2.2、2.7 + ===================*/ + +#include "MergeSqList.h" //**▲02 线性表**// + + +/* + * ████████ 算法2.2 ████████ + * + * 非递减链表归并：C=A+B + * + * 归并顺序表La和Lb，生成新的顺序表Lc。 + * 其中，La、Lb、Lc均为非递减序列。 + */ +void MergeSqList_1(SqList La, SqList Lb, SqList* Lc) { + int La_len, Lb_len; + int i, j, k; + ElemType ai, bj; + + i = j = 1; + k = 0; + + // 初始化Lc + InitList(Lc); + + // 获取La、Lb的长度 + La_len = ListLength(La); + Lb_len = ListLength(Lb); + + // 如果La及Lb均未遍历完 + while(i <= La_len && j <= Lb_len) { + GetElem(La, i, &ai); + GetElem(Lb, j, &bj); + + // 比较遍历到的元素，先将比较小的元素加入顺序表Lc + if(ai <= bj) { + ListInsert(Lc, ++k, ai); + i++; + } else { + ListInsert(Lc, ++k, bj); + j++; + } + } + + // 如果Lb已遍历完，但La还未遍历完，将La中剩余元素加入Lc + while(i <= La_len) { + GetElem(La, i++, &ai); + ListInsert(Lc, ++k, ai); + } + + // 如果La已遍历完，但Lb还未遍历完，将Lb中剩余元素加入Lc + while(j <= Lb_len) { + GetElem(Lb, j++, &bj); + ListInsert(Lc, ++k, bj); + } +} + +/* + * ████████ 算法2.7 ████████ + * + * 非递减链表归并：C=A+B + * + * 归并顺序表La和Lb，生成新的顺序表Lc。 + * 其中，La、Lb、Lc均为非递减序列。 + */ +void MergeSqList_2(SqList La, SqList Lb, SqList* Lc) { + ElemType* pa, * pb, * pc; + ElemType* pa_last, * pb_last; + + pa = La.elem; // 指向La第一个元素 + pb = Lb.elem; // 指向Lb第一个元素 + + // 没有使用InitList创建Lc + (*Lc).listsize = (*Lc).length = La.length + Lb.length; + pc = (*Lc).elem = (ElemType*) malloc((*Lc).listsize * sizeof(ElemType)); + if(pc == NULL) { + exit(OVERFLOW); + } + + pa_last = La.elem + La.length - 1; // 指向La最后一个元素 + pb_last = Lb.elem + Lb.length - 1; // 指向Lb最后一个元素 + + // 如果La及Lb均未遍历完 + while(pa <= pa_last && pb <= pb_last) { + if(*pa <= *pb) { + *pc++ = *pa++; + } else { + *pc++ = *pb++; + } + } + + // 如果Lb已遍历完，但La还未遍历完，将La中剩余元素加入Lc + while(pa <= pa_last) { + *pc++ = *pa++; + } + + // 如果La已遍历完，但Lb还未遍历完，将Lb中剩余元素加入Lc + while(pb <= pb_last) { + *pc++ = *pb++; + } +} \ No newline at end of file diff --git a/CLion/CourseBook/0203_MergeSqList/MergeSqList.h b/CLion/CourseBook/0203_MergeSqList/MergeSqList.h new file mode 100644 index 0000000..2943778 --- /dev/null +++ b/CLion/CourseBook/0203_MergeSqList/MergeSqList.h @@ -0,0 +1,35 @@ +/*================== + * 归并非降序顺序表 + * + * 包含算法: 2.2、2.7 + ===================*/ + +#ifndef MERGESQLIST_H +#define MERGESQLIST_H + +#include +#include +#include "SqList.h" //**▲02 线性表**// + + +/* + * ████████ 算法2.2 ████████ + * + * 非递减链表归并：C=A+B + * + * 归并顺序表La和Lb，生成新的顺序表Lc。 + * 其中，La、Lb、Lc均为非递减序列。 + */ +void MergeSqList_1(SqList La, SqList Lb, SqList* Lc); + +/* + * ████████ 算法2.7 ████████ + * + * 非递减链表归并：C=A+B + * + * 归并顺序表La和Lb，生成新的顺序表Lc。 + * 其中，La、Lb、Lc均为非递减序列。 + */ +void MergeSqList_2(SqList La, SqList Lb, SqList* Lc); + +#endif diff --git a/CLion/CourseBook/0203_MergeSqList/SqList.c b/CLion/CourseBook/0203_MergeSqList/SqList.c new file mode 100644 index 0000000..8d465c3 --- /dev/null +++ b/CLion/CourseBook/0203_MergeSqList/SqList.c @@ -0,0 +1,129 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * 计数 + * + * 返回顺序表包含的有效元素的数量。 + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * 取值 + * + * 获取顺序表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(SqList L, int i, ElemType* e) { + // 因为i的含义是位置，所以其合法范围是：[1, length] + if(i < 1 || i > L.length) { + return ERROR; //i值不合法 + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/CourseBook/0203_MergeSqList/SqList.h b/CLion/CourseBook/0203_MergeSqList/SqList.h new file mode 100644 index 0000000..52fb14d --- /dev/null +++ b/CLion/CourseBook/0203_MergeSqList/SqList.h @@ -0,0 +1,80 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * 计数 + * + * 返回顺序表包含的有效元素的数量。 + */ +int ListLength(SqList L); + +/* + * 取值 + * + * 获取顺序表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/CourseBook/0204_LinkList/CMakeLists.txt b/CLion/CourseBook/0204_LinkList/CMakeLists.txt new file mode 100644 index 0000000..1328cfe --- /dev/null +++ b/CLion/CourseBook/0204_LinkList/CMakeLists.txt @@ -0,0 +1,12 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(LinkedList LinkList.h LinkList.c LinkList-main.c) +# 链接公共库 +target_link_libraries(LinkedList Scanf_lib) + +# 记录要拷贝到*.exe目录下的资源文件 +file(GLOB TestData TestData*.txt) +# 将资源文件拷贝到*.exe目录下，不然无法加载 +file(COPY ${TestData} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) diff --git a/CLion/CourseBook/0204_LinkList/LinkList-main.c b/CLion/CourseBook/0204_LinkList/LinkList-main.c new file mode 100644 index 0000000..c991473 --- /dev/null +++ b/CLion/CourseBook/0204_LinkList/LinkList-main.c @@ -0,0 +1,170 @@ +#include +#include "Status.h" +#include "LinkList.h" //**▲02 线性表**// + +// 判断data>e是否成立 +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + LinkList L; + int i; + ElemType e; + + printf("████████ InitList \n"); + { + printf("█ 初始化单链表 L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf("████████ ListEmpty \n"); + { + ListEmpty(L) ? printf("█ L 为空！！\n") : printf("█ L 不为空！\n"); + } + PressEnterToContinue(); + + + printf("████████ ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf("█ 在 L 第 %d 个位置插入 \"%d\" ...\n", i, 2 * i); + ListInsert(L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf("████████ ListTraverse \n"); + { + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ ListLength \n"); + { + printf("█ L 的长度为 %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf("████████ ListDelete \n"); + { + printf("█ 删除前的元素：L = "); + ListTraverse(L, PrintElem); + + printf("█ 尝试删除 L 中第 6 个元素...\n"); + + if(ListDelete(L, 6, &e) == OK) { + printf("█ 删除成功，被删除元素是：\"%d\"\n", e); + } else { + printf("█ 删除失败，第 6 个元素不存在！\n"); + } + + printf("█ 删除后的元素：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ GetElem \n"); + { + GetElem(L, 4, &e); + printf("█ L 中第 4 个位置的元素为 \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf("████████ LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + GetElem(L, i, &e); + printf("█ L 中第一个元素值大于 \"7\" 的元素是 \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf("████████ PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf("█ 元素 \"%d\" 的前驱为 \"%d\" \n", cur_e, e); + } else { + printf("█ 元素 \"%d\" 的前驱不存在！\n", cur_e); + } + } + PressEnterToContinue(); + + + printf("████████ NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf("█ 元素 \"%d\" 的后继为 \"%d\" \n", cur_e, e); + } else { + printf("█ 元素 \"%d\" 的后继不存在！\n", cur_e); + } + } + PressEnterToContinue(); + + + printf("████████ ClearList \n"); + { + printf("█ 清空 L 前："); + ListEmpty(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n"); + + ClearList(L); + + printf("█ 清空 L 后："); + ListEmpty(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n"); + } + PressEnterToContinue(); + + + printf("████████ DestroyList \n"); + { + printf("█ 销毁 L 前："); + L ? printf(" L 存在！\n") : printf(" L 不存在！！\n"); + + DestroyList(&L); + + printf("█ 销毁 L 后："); + L ? printf(" L 存在！\n") : printf(" L 不存在！！\n"); + } + PressEnterToContinue(); + + + printf("████████ CreateList_Head \n"); + { + LinkList L; + printf("█ 头插法建立单链表 L = "); + CreateList_Head("TestData_Head.txt", &L, 5); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ CreateList_Tail \n"); + { + LinkList L; + printf("█ 尾插法建立单链表 L = "); + CreateList_Tail("TestData_Tail.txt", &L, 5); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/CLion/CourseBook/0204_LinkList/LinkList.c b/CLion/CourseBook/0204_LinkList/LinkList.c new file mode 100644 index 0000000..276c17e --- /dev/null +++ b/CLion/CourseBook/0204_LinkList/LinkList.c @@ -0,0 +1,488 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 销毁(结构) + * + * 释放链表所占内存，头结点也会被清理。 + */ +Status DestroyList(LinkList* L) { + LinkList p; + + // 确保链表结构存在 + if(L == NULL || *L == NULL) { + return ERROR; + } + + p = *L; + + while(p != NULL) { + p = (*L)->next; + free(*L); + (*L) = p; + } + + *L = NULL; + + return OK; +} + +/* + * 置空(内容) + * + * 这里需要释放链表中非头结点处的空间。 + */ +Status ClearList(LinkList L) { + LinkList pre, p; + + // 确保链表存在 + if(L == NULL) { + return ERROR; + } + + p = L->next; + + // 释放链表上所有结点所占内存 + while(p != NULL) { + pre = p; + p = p->next; + free(pre); + } + + L->next = NULL; + + return OK; +} + +/* + * 判空 + * + * 判断链表中是否包含有效数据。 + * + * 返回值： + * TRUE : 链表为空 + * FALSE: 链表不为空 + */ +Status ListEmpty(LinkList L) { + // 链表只有头结点时，认为该链表为空 + if(L != NULL && L->next == NULL) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * 计数 + * + * 返回链表包含的有效元素的数量。 + */ +int ListLength(LinkList L) { + LinkList p; + int i; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 0; + p = L->next; + + // 遍历所有结点 + while(p != NULL) { + i++; + p = p->next; + } + + return i; +} + +/* + * ████████ 算法2.8 ████████ + * + * 取值 + * + * 获取链表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(LinkList L, int i, ElemType* e) { + LinkList p; + int j; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点的后继不为NULL + while(p->next != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p->next == NULL || j > i - 1) { + return ERROR; + } + + *e = p->next->data; + + return OK; +} + +/* + * 查找 + * + * 返回链表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 1; // i的初值为第1个元素的位序 + p = L->next; // p的初值为第1个元素的指针 + + while(p != NULL && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != NULL) { + return i; + } else { + return 0; + } +} + +/* + * 前驱 + * + * 获取元素cur_e的前驱， + * 如果存在，将其存储到pre_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status PriorElem(LinkList L, ElemType cur_e, ElemType* pre_e) { + LinkList pre, next; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return ERROR; + } + + // 指向第1个元素 + pre = L->next; + + // 第1个元素没有前驱 + if(pre->data == cur_e) { + return ERROR; + } + + // 指向第2个元素 + next = pre->next; + + // 从第2个元素开始，查找cur_e的位置 + while(next != NULL && next->data != cur_e) { + pre = next; + next = next->next; + } + + // 如果没找到元素cur_e，查找失败，返回ERROR + if(next == NULL) { + return ERROR; + } + + *pre_e = pre->data; + + return OK; +} + +/* + * 后继 + * + * 获取元素cur_e的后继， + * 如果存在，将其存储到next_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status NextElem(LinkList L, ElemType cur_e, ElemType* next_e) { + LinkList pre; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return ERROR; + } + + // 指向第1个元素 + pre = L->next; + + // 从第1个元素开始，查找cur_e的位置，且保证该结点的后继不为NULL + while(pre->next != NULL && pre->data != cur_e) { + pre = pre->next; + } + + // 如果没找到cur_e，或者找到了，但它没有后继，均返回ERROR + if(pre->next == NULL) { + return ERROR; + } + + *next_e = pre->next->data; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * ████████ 算法2.10 ████████ + * + * 删除 + * + * 删除链表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListDelete(LinkList L, int i, ElemType* e) { + LinkList p, q; + int j; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点的后继不为NULL + while(p->next != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p->next == NULL || j > i - 1) { + return ERROR; + } + + // 删除第i个结点 + q = p->next; + p->next = q->next; + *e = q->data; + free(q); + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * ████████ 算法2.11 ████████ + * + * 头插法创建链表 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据。 + * 另教材中的算法采用的是头插法，所以此处的实现加了后缀_Head。 + */ +Status CreateList_Head(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p; + ElemType e; + + // 建立头结点 + *L = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // 打开文件，准备读取测试数据 + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1; i <= n; ++i) { + // 如果成功读取到输入数据 + if(ReadData(fp, "%d", &e) == 1) { + // 生成新结点 + p = (LinkList) malloc(sizeof(LNode)); + if(p == NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // 填充数据，并插入到链表中 + p->data = e; + p->next = (*L)->next; + (*L)->next = p; + } else { + fclose(fp); + return ERROR; + } + } + + fclose(fp); + + return OK; +} + +/* + * 尾插法创建链表 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据。 + */ +Status CreateList_Tail(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p, q; + ElemType e; + + // 建立头结点 + *L = (LinkList) malloc(sizeof(LNode)); + if(*L==NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // 打开文件，准备读取测试数据 + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1, q = *L; i <= n; ++i) { + // 如果成功读取到输入数据 + if(ReadData(fp, "%d", &e) == 1) { + p = (LinkList) malloc(sizeof(LNode)); + if(p==NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // 填充数据，并插入到链表中 + p->data = e; + q->next = p; + q = q->next; + } else { + fclose(fp); + return ERROR; + } + } + + q->next = NULL; + + fclose(fp); + + return OK; +} diff --git a/CLion/CourseBook/0204_LinkList/LinkList.h b/CLion/CourseBook/0204_LinkList/LinkList.h new file mode 100644 index 0000000..3b54db4 --- /dev/null +++ b/CLion/CourseBook/0204_LinkList/LinkList.h @@ -0,0 +1,168 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * 销毁(结构) + * + * 释放链表所占内存。 + */ +Status DestroyList(LinkList* L); + +/* + * 置空(内容) + * + * 这里需要释放链表中非头结点处的空间。 + */ +Status ClearList(LinkList L); + +/* + * 判空 + * + * 判断链表中是否包含有效数据。 + * + * 返回值： + * TRUE : 链表为空 + * FALSE: 链表不为空 + */ +Status ListEmpty(LinkList L); + +/* + * 计数 + * + * 返回链表包含的有效元素的数量。 + */ +int ListLength(LinkList L); + +/* + * ████████ 算法2.8 ████████ + * + * 取值 + * + * 获取链表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(LinkList L, int i, ElemType* e); + +/* + * 查找 + * + * 返回链表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 前驱 + * + * 获取元素cur_e的前驱， + * 如果存在，将其存储到pre_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status PriorElem(LinkList L, ElemType cur_e, ElemType* pre_e); + +/* + * 后继 + * + * 获取元素cur_e的后继， + * 如果存在，将其存储到next_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status NextElem(LinkList L, ElemType cur_e, ElemType* next_e); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * ████████ 算法2.10 ████████ + * + * 删除 + * + * 删除链表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListDelete(LinkList L, int i, ElemType* e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +/* + * ████████ 算法2.11 ████████ + * + * 头插法创建链表 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据。 + * 另教材中的算法采用的是头插法，所以此处的实现加了后缀_Head。 + */ +Status CreateList_Head(char path[], LinkList* L, int n); + +/* + * 尾插法创建链表 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据 + */ +Status CreateList_Tail(char path[], LinkList* L, int n); + +#endif diff --git a/CLion/CourseBook/0204_LinkList/TestData_Head.txt b/CLion/CourseBook/0204_LinkList/TestData_Head.txt new file mode 100644 index 0000000..d2603c8 --- /dev/null +++ b/CLion/CourseBook/0204_LinkList/TestData_Head.txt @@ -0,0 +1 @@ +降序：9 7 5 3 1 \ No newline at end of file diff --git a/CLion/CourseBook/0204_LinkList/TestData_Tail.txt b/CLion/CourseBook/0204_LinkList/TestData_Tail.txt new file mode 100644 index 0000000..e033dd7 --- /dev/null +++ b/CLion/CourseBook/0204_LinkList/TestData_Tail.txt @@ -0,0 +1 @@ +升序：2 4 6 8 10 \ No newline at end of file diff --git a/CLion/CourseBook/0205_MergeList/CMakeLists.txt b/CLion/CourseBook/0205_MergeList/CMakeLists.txt new file mode 100644 index 0000000..4aca526 --- /dev/null +++ b/CLion/CourseBook/0205_MergeList/CMakeLists.txt @@ -0,0 +1,12 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(MergeList LinkList.h LinkList.c MergeList.h MergeList.c MergeList-main.c) +# 链接公共库 +target_link_libraries(MergeList Scanf_lib) + +# 记录要拷贝到*.exe目录下的资源文件 +file(GLOB TestData TestData*.txt) +# 将资源文件拷贝到*.exe目录下，不然无法加载 +file(COPY ${TestData} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) diff --git a/CLion/CourseBook/0205_MergeList/LinkList.c b/CLion/CourseBook/0205_MergeList/LinkList.c new file mode 100644 index 0000000..11c3c2a --- /dev/null +++ b/CLion/CourseBook/0205_MergeList/LinkList.c @@ -0,0 +1,138 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * ████████ 算法2.11 ████████ + * + * 头插法创建链表 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据。 + * 另教材中的算法采用的是头插法，所以此处的实现加了后缀_Head。 + */ +Status CreateList_Head(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p; + ElemType e; + + // 建立头结点 + *L = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // 打开文件，准备读取测试数据 + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1; i <= n; ++i) { + // 如果成功读取到输入数据 + if(ReadData(fp, "%d", &e) == 1) { + // 生成新结点 + p = (LinkList) malloc(sizeof(LNode)); + if(p == NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // 填充数据，并插入到链表中 + p->data = e; + p->next = (*L)->next; + (*L)->next = p; + } else { + fclose(fp); + return ERROR; + } + } + + fclose(fp); + + return OK; +} + +/* + * 尾插法创建链表 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据。 + */ +Status CreateList_Tail(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p, q; + ElemType e; + + // 建立头结点 + *L = (LinkList) malloc(sizeof(LNode)); + if(*L==NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // 打开文件，准备读取测试数据 + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1, q = *L; i <= n; ++i) { + // 如果成功读取到输入数据 + if(ReadData(fp, "%d", &e) == 1) { + p = (LinkList) malloc(sizeof(LNode)); + if(p==NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // 填充数据，并插入到链表中 + p->data = e; + q->next = p; + q = q->next; + } else { + fclose(fp); + return ERROR; + } + } + + q->next = NULL; + + fclose(fp); + + return OK; +} diff --git a/CLion/CourseBook/0205_MergeList/LinkList.h b/CLion/CourseBook/0205_MergeList/LinkList.h new file mode 100644 index 0000000..35ff256 --- /dev/null +++ b/CLion/CourseBook/0205_MergeList/LinkList.h @@ -0,0 +1,61 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +/* + * ████████ 算法2.11 ████████ + * + * 头插法创建链表 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据。 + * 另教材中的算法采用的是头插法，所以此处的实现加了后缀_Head。 + */ +Status CreateList_Head(char path[], LinkList* L, int n); + +/* + * 尾插法创建链表 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据 + */ +Status CreateList_Tail(char path[], LinkList* L, int n); + +#endif diff --git a/CLion/CourseBook/0205_MergeList/MergeList-main.c b/CLion/CourseBook/0205_MergeList/MergeList-main.c new file mode 100644 index 0000000..cb1a203 --- /dev/null +++ b/CLion/CourseBook/0205_MergeList/MergeList-main.c @@ -0,0 +1,31 @@ +#include +#include "MergeList.h" //**▲02 线性表**// + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + LinkList La, Lb, Lc; + + int m = 5; + + printf("作为示例，La长度设定为 %d ，Lb长度设定为 %d ，创建La和Lb...\n", m, m); + + CreateList_Head("TestData_Head.txt", &La, m); + printf("La = "); + ListTraverse(La, PrintElem); + + CreateList_Tail("TestData_Tail.txt", &Lb, m); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + printf("归并La和Lb为Lc = "); + MergeList(&La, &Lb, &Lc); + ListTraverse(Lc, PrintElem); + + return 0; +} + diff --git a/CLion/CourseBook/0205_MergeList/MergeList.c b/CLion/CourseBook/0205_MergeList/MergeList.c new file mode 100644 index 0000000..887995f --- /dev/null +++ b/CLion/CourseBook/0205_MergeList/MergeList.c @@ -0,0 +1,45 @@ +/*=============== + * 归并非降序链表 + * + * 包含算法: 2.12 + ================*/ + +#include "MergeList.h" //**▲02 线性表**// + +/* + * ████████ 算法2.12 ████████ + * + * 非递减链表归并：C=A+B + * + * 将链表A和B归并为C，且保持元素相对位置不变。 + * Lc利用La的头结点，Lb中结点均插入新链表Lc中。 + */ +void MergeList(LinkList* La, LinkList* Lb, LinkList* Lc) { + LinkList pa, pb, pc; + + pa = (*La)->next; + pb = (*Lb)->next; + pc = *Lc = *La; // 用La的头结点作为Lc的头结点 + + // 遍历La和Lb + while(pa && pb) { + if(pa->data <= pb->data) { + pc->next = pa; + pc = pa; + pa = pa->next; + } else { + pc->next = pb; + pc = pb; + pb = pb->next; + } + } + + // 插入剩余段 + pc->next = pa ? pa : pb; + + // 释放Lb的头结点所占内存 + free(*Lb); + + *La = NULL; + *Lb = NULL; +} diff --git a/CLion/CourseBook/0205_MergeList/MergeList.h b/CLion/CourseBook/0205_MergeList/MergeList.h new file mode 100644 index 0000000..1d6c876 --- /dev/null +++ b/CLion/CourseBook/0205_MergeList/MergeList.h @@ -0,0 +1,24 @@ +/*=============== + * 归并非降序链表 + * + * 包含算法: 2.12 + ================*/ + +#ifndef MERGELIST_H +#define MERGELIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "LinkList.h" //**▲02 线性表**// + +/* + * ████████ 算法2.12 ████████ + * + * 非递减链表归并：C=A+B + * + * 将链表A和B归并为C，且保持元素相对位置不变。 + * Lc利用La的头结点，Lb中结点均插入新链表Lc中。 + */ +void MergeList(LinkList* La, LinkList* Lb, LinkList* Lc); + +#endif diff --git a/CLion/CourseBook/0205_MergeList/TestData_Head.txt b/CLion/CourseBook/0205_MergeList/TestData_Head.txt new file mode 100644 index 0000000..d2603c8 --- /dev/null +++ b/CLion/CourseBook/0205_MergeList/TestData_Head.txt @@ -0,0 +1 @@ +降序：9 7 5 3 1 \ No newline at end of file diff --git a/CLion/CourseBook/0205_MergeList/TestData_Tail.txt b/CLion/CourseBook/0205_MergeList/TestData_Tail.txt new file mode 100644 index 0000000..e033dd7 --- /dev/null +++ b/CLion/CourseBook/0205_MergeList/TestData_Tail.txt @@ -0,0 +1 @@ +升序：2 4 6 8 10 \ No newline at end of file diff --git a/CLion/CourseBook/0206_SLinkList/CMakeLists.txt b/CLion/CourseBook/0206_SLinkList/CMakeLists.txt new file mode 100644 index 0000000..0c24ff2 --- /dev/null +++ b/CLion/CourseBook/0206_SLinkList/CMakeLists.txt @@ -0,0 +1,7 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(SLinkList SLinkList.h SLinkList.c SLinkList-main.c) +# 链接公共库 +target_link_libraries(SLinkList Scanf_lib) \ No newline at end of file diff --git a/CLion/CourseBook/0206_SLinkList/SLinkList-main.c b/CLion/CourseBook/0206_SLinkList/SLinkList-main.c new file mode 100644 index 0000000..5d3f74b --- /dev/null +++ b/CLion/CourseBook/0206_SLinkList/SLinkList-main.c @@ -0,0 +1,152 @@ +#include +#include "Status.h" +#include "SLinkList.h" //**▲02 线性表**// + +// 判断data>e是否成立 +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SLinkList space; // 备用空间 + int S; // 静态链表头结点索引 + + int i; + ElemType e; + + printf("████████ InitList \n"); + { + printf("█ 初始化单链表 S ...\n"); + InitList(space, &S); + } + PressEnterToContinue(); + + + printf("████████ ListEmpty \n"); + { + ListEmpty(space, S) ? printf("█ S 为空！！\n") : printf("█ S 不为空！\n"); + } + PressEnterToContinue(); + + + printf("████████ ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf("█ 在 S 第 %d 个位置插入 \"%d\" ...\n", i, 2 * i); + ListInsert(space, S, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf("████████ ListTraverse \n"); + { + printf("█ S 中的元素为：S = "); + ListTraverse(space, S, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ ListLength \n"); + { + printf("█ S 的长度为 %d \n", ListLength(space, S)); + } + PressEnterToContinue(); + + + printf("████████ ListDelete \n"); + { + printf("█ 删除前的元素：S = "); + ListTraverse(space, S, PrintElem); + + printf("█ 尝试删除 S 中第 6 个元素...\n"); + + if(ListDelete(space, S, 6, &e) == OK) { + printf("█ 删除成功，被删除元素是：\"%d\"\n", e); + } else { + printf("█ 删除失败，第 6 个元素不存在！\n"); + } + + printf("█ 删除后的元素：S = "); + ListTraverse(space, S, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ GetElem \n"); + { + GetElem(space, S, 4, &e); + printf("█ S 中第 4 个位置的元素为 \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf("████████ LocateElem \n"); + { + i = LocateElem(space, S, 7, CmpGreater); + GetElem(space, S, i, &e); + printf("█ S 中第一个元素值大于 \"7\" 的元素是 \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf("████████ PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(space, S, cur_e, &e) == OK) { + printf("█ 元素 \"%d\" 的前驱为 \"%d\" \n", cur_e, e); + } else { + printf("█ 元素 \"%d\" 的前驱不存在！\n", cur_e); + } + } + PressEnterToContinue(); + + + printf("████████ NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(space, S, cur_e, &e) == OK) { + printf("█ 元素 \"%d\" 的后继为 \"%d\" \n", cur_e, e); + } else { + printf("█ 元素 \"%d\" 的后继不存在！\n", cur_e); + } + } + PressEnterToContinue(); + + + printf("████████ ClearList \n"); + { + printf("█ 清空 S 前："); + ListEmpty(space, S) ? printf(" S 为空！！\n") : printf(" S 不为空！\n"); + + ClearList(space, S); + + printf("█ 清空 S 后："); + ListEmpty(space, S) ? printf(" S 为空！！\n") : printf(" S 不为空！\n"); + } + PressEnterToContinue(); + + + printf("████████ DestroyList \n"); + { + printf("█ 销毁 S 前："); + S!=0 ? printf(" S 存在！\n") : printf(" S 不存在！！\n"); + + DestroyList(space, &S); + + printf("█ 销毁 S 后："); + S!=0 ? printf(" S 存在！\n") : printf(" S 不存在！！\n"); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/CLion/CourseBook/0206_SLinkList/SLinkList.c b/CLion/CourseBook/0206_SLinkList/SLinkList.c new file mode 100644 index 0000000..222c15d --- /dev/null +++ b/CLion/CourseBook/0206_SLinkList/SLinkList.c @@ -0,0 +1,470 @@ +/*================================= + * 静态链表 + * + * 包含算法: 2.13、2.14、2.15、2.16 + ==================================*/ + +#include "SLinkList.h" + +/* + * ██ 提示 ██ + * + * 以下所有函数的形参中： + * space：指示备用空间 + * S ：指示静态链表头结点索引 + */ + +/*━━━━━━━━━━━━━━━━━━━━━━ 备用空间操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * ████████ 算法2.14 ████████ + * + * 初始化备用空间 + * + * 备用空间为静态链表提供可用的内存。 + */ +void InitSpace(SLinkList space) { + int i; + + for(i = 0; i < MAXSIZE - 1; ++i) { + space[i].cur = i + 1; + } + + space[MAXSIZE - 1].cur = 0; +} + +/* + * ████████ 算法2.15 ████████ + * + * 申请空间 + * + * 为静态链表从备用空间申请结点空间， + * 如果申请成功，返回可用空间的索引， + * 申请失败时，返回0。 + */ +int Malloc(SLinkList space) { + int i = space[0].cur; + + if(i != 0) { + // 将申请到的空间从备用空间中删去 + space[0].cur = space[i].cur; + } + + // 返回新申请结点下标 + return i; +} + +/* + * ████████ 算法2.16 ████████ + * + * 回收空间 + * + * 回收索引k处的结点空间以供静态链表后续复用， + * 回收方式就是将该结点空间从静态链表上移除， + * 并将其添加到备用空间的列表当中。 + */ +void Free(SLinkList space, int k) { + space[k].cur = space[0].cur; + space[0].cur = k; +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 静态链表操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 初始化 + * + * 先初始化备用空间，而后从备用空间中申请头结点的空间，进而完成静态链表的初始化。 + * 初始化成功则使用S存储头结点索引，且返回OK，否则返回ERROR。 + */ +Status InitList(SLinkList space, int* S) { + int index; + + // 初始化备用空间 + InitSpace(space); + + // 申请头结点空间 + index = Malloc(space); + + if(index == 0) { + return ERROR; + } + + space[index].cur = 0; + + *S = index; + + return OK; +} + +/* + * 销毁(结构) + * + * 释放静态链表所占内存，即将静态链表所有结点空间移入备用空间列表中。 + */ +Status DestroyList(SLinkList space, int* S) { + int cur; + + // 确保静态链表存在 + if(S == NULL || *S == 0) { + return ERROR; + } + + while(*S != 0) { + // 暂存下一个结点的索引 + cur = space[*S].cur; + // 回收当前结点所占空间 + Free(space, *S); + // 前进到下一个结点的索引处 + *S = cur; + } + + return OK; +} + +/* + * 置空(内容) + * + * 这里需要释放静态链表中非头结点处的空间。 + */ +Status ClearList(SLinkList space, int S) { + int P; + int cur; + + // 确保静态链表存在 + if(S == 0) { + return ERROR; + } + + // 获取静态链表首个结点的索引 + P = space[S].cur; + + while(P != 0) { + // 暂存下一个结点的索引 + cur = space[P].cur; + // 回收当前结点所占空间 + Free(space, P); + // 前进到下一个结点的索引处 + P = cur; + } + + space[S].cur = 0; + + return OK; +} + +/* + * 判空 + * + * 判断静态链表中是否包含有效数据。 + * + * 返回值： + * TRUE : 静态链表为空 + * FALSE: 静态链表不为空 + */ +Status ListEmpty(SLinkList space, int S) { + // 只存在头结点的静态链表被视为空表 + if(S != 0 && space[S].cur == 0) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * 计数 + * + * 返回静态链表包含的有效元素的数量。 + */ +int ListLength(SLinkList space, int S) { + int count; + + // 静态链表不存在，或静态链表为空时，返回0 + if(S == 0 || space[S].cur == 0) { + return 0; + } + + // 获取静态链表首个元素的索引 + S = space[S].cur; + count = 0; + + while(S != 0) { + count++; + S = space[S].cur; + } + + return count; +} + +/* + * 取值 + * + * 获取静态链表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(SLinkList space, int S, int i, ElemType* e) { + int count; + + // 确保静态链表存在且不为空 + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // 获取静态链表首个元素的索引 + S = space[S].cur; + count = 0; + + while(S != 0 && count < i - 1) { + count++; + S = space[S].cur; + } + + if(S == 0 || count > i - 1) { + return ERROR; + } + + *e = space[S].data; + + return OK; +} + +/* + * ████████ 算法2.13 ████████ + * + * 查找 + * + * 返回静态链表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 1.元素e是Compare函数第二个形参 + * 2.这里的实现与教材上的算法2.13不相同，原因参见顶部的“注意”信息 + */ +int LocateElem(SLinkList space, int S, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + int p; + + // 确保静态链表存在且不为空 + if(S == 0 || space[S].cur == 0) { + return 0; + } + + i = 1; // i的初值为第1个元素的位序 + p = space[S].cur; // p的初值为第1个元素的索引 + + while(p != 0 && !Compare(space[p].data, e)) { + i++; + p = space[p].cur; + } + + if(p != 0) { + return i; + } else { + return 0; + } +} + +/* + * 前驱 + * + * 获取元素cur_e的前驱， + * 如果存在，将其存储到pre_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status PriorElem(SLinkList space, int S, ElemType cur_e, ElemType* pre_e) { + int pre, next; + + // 确保静态链表存在且不为空 + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // 指向第1个元素 + pre = space[S].cur; + + // 第1个元素没有前驱 + if(space[pre].data == cur_e) { + return ERROR; + } + + // 指向第2个元素 + next = space[pre].cur; + + // 从第2个元素开始，查找cur_e的位置 + while(next != 0 && space[next].data != cur_e) { + pre = next; + next = space[next].cur; + } + + // 如果没找到元素cur_e，查找失败，返回ERROR + if(next == 0) { + return ERROR; + } + + *pre_e = space[pre].data; + + return OK; +} + +/* + * 后继 + * + * 获取元素cur_e的后继， + * 如果存在，将其存储到next_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status NextElem(SLinkList space, int S, ElemType cur_e, ElemType* next_e) { + int pre; + + // 确保静态链表存在且不为空 + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // 指向第1个元素 + pre = space[S].cur; + + // 从第1个元素开始，查找cur_e的位置，且保证该结点的后继存在 + while(space[pre].cur != 0 && space[pre].data != cur_e) { + pre = space[pre].cur; + } + + // 如果没找到cur_e，或者找到了，但它没有后继，均返回ERROR + if(space[pre].cur == 0) { + return ERROR; + } + + *next_e = space[space[pre].cur].data; + + return OK; +} + +/* + * 插入 + * + * 向静态链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SLinkList space, int S, int i, ElemType e) { + int p, s; + int j; + + // 确保静态链表存在 + if(S == 0) { + return ERROR; + } + + p = S; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身存在 + while(p != 0 && j < i - 1) { + p = space[p].cur; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == 0 || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = Malloc(space); + space[s].data = e; + space[s].cur = space[p].cur; + space[p].cur = s; + + return OK; +} + +/* + * 删除 + * + * 删除静态链表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListDelete(SLinkList space, int S, int i, ElemType* e) { + int p, q; + int j; + + // 确保静态链表存在 + if(S == 0) { + return ERROR; + } + + p = S; + j = 0; + + // 寻找第i-1个结点，且保证该结点的后继存在 + while(space[p].cur != 0 && j < i - 1) { + p = space[p].cur; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(space[p].cur == 0 || j > i - 1) { + return ERROR; + } + + // 删除第i个结点 + q = space[p].cur; + space[p].cur = space[q].cur; + *e = space[q].data; + Free(space, q); + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问静态链表S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)) { + int p; + + // 确保链表存在 + if(S == 0 || space[S].cur == 0) { + return; + } + + p = space[S].cur; + + while(p != 0) { + Visit(space[p].data); + p = space[p].cur; + } + + printf("\n"); +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 图形化输出 ━━━━━━━━━━━━━━━━━━━━━━*/ + +// 以图形化形式输出当前结构，仅限内部测试使用 +void PrintGraph(SLinkList space, int S) { + int i = 0; + + printf("==== 备用空间 ====\n"); + while(i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } + + printf("==== 静态链表 ====\n"); + i = S; + while(i>0 && i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } +} + diff --git a/CLion/CourseBook/0206_SLinkList/SLinkList.h b/CLion/CourseBook/0206_SLinkList/SLinkList.h new file mode 100644 index 0000000..d961fc8 --- /dev/null +++ b/CLion/CourseBook/0206_SLinkList/SLinkList.h @@ -0,0 +1,208 @@ +/*================================= + * 静态链表 + * + * 包含算法: 2.13、2.14、2.15、2.16 + ==================================*/ + +#ifndef SLINKLIST_H +#define SLINKLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define MAXSIZE 1000 // 备用空间最大容量，近似于静态链表的最大长度 + +/* 静态链表元素类型定义 */ +typedef int ElemType; + +/* + * 静态链表结构 + * + * 注：静态链表依托于一个数组，该数组包含了已占用空间和空闲空间 + */ +typedef struct SLinkNode { + ElemType data; + int cur; // cur是游标，做指针用，用来链接下一个结点（区别于数组下标） +} SLinkList[MAXSIZE]; // 链表空间类型 + + +/* + * ████ 提示 ████ + * + * 以下所有函数的形参中： + * space：指示备用空间 + * S ：指示静态链表头结点索引 + */ + +/* + * ████ 注意 ████ + * + * 教材中算法2.13和算法2.14~2.17中都是涉及静态链表的操作， + * 但这两处算法预设的数据结构却不同。 + * + * 算法2.13假设整个预设数组都是静态链表(操作简单)， + * 算法2.14~2.17只是将预设的数组作为备用空间， + * 静态链表所需空间是基于备用空间进行申请和释放的(操作稍难)。 + * + * 这里实现的代码中，以算法2.14~2.17处预设的数据结构为准， + * 所以，对于算法2.13，其实现会有教材有所不同。 + */ + + +/*━━━━━━━━━━━━━━━━━━━━━━ 备用空间操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * ████████ 算法2.14 ████████ + * + * 初始化备用空间 + * + * 备用空间为静态链表提供可用的内存。 + */ +void InitSpace(SLinkList space); + +/* + * ████████ 算法2.15 ████████ + * + * 申请空间 + * + * 为静态链表从备用空间申请结点空间， + * 如果申请成功，返回可用空间的索引， + * 申请失败时，返回0。 + */ +int Malloc(SLinkList space); + +/* + * ████████ 算法2.16 ████████ + * + * 回收空间 + * + * 回收索引k处的结点空间以供静态链表后续复用， + * 回收方式就是将该结点空间从静态链表上移除， + * 并将其添加到备用空间的列表当中。 + */ +void Free(SLinkList space, int k); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 静态链表操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 初始化 + * + * 先初始化备用空间，而后从备用空间中申请头结点的空间，进而完成静态链表的初始化。 + * 初始化成功则使用S存储头结点索引，且返回OK，否则返回ERROR。 + */ +Status InitList(SLinkList space, int* S); + +/* + * 销毁(结构) + * + * 释放静态链表所占内存，即将静态链表所有结点空间移入备用空间列表中。 + */ +Status DestroyList(SLinkList space, int* S); + +/* + * 置空(内容) + * + * 这里需要释放静态链表中非头结点处的空间。 + */ +Status ClearList(SLinkList space, int S); + +/* + * 判空 + * + * 判断静态链表中是否包含有效数据。 + * + * 返回值： + * TRUE : 静态链表为空 + * FALSE: 静态链表不为空 + */ +Status ListEmpty(SLinkList space, int S); + +/* + * 计数 + * + * 返回静态链表包含的有效元素的数量。 + */ +int ListLength(SLinkList space, int S); + +/* + * 取值 + * + * 获取静态链表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(SLinkList space, int S, int i, ElemType* e); + +/* + * ████████ 算法2.13 ████████ + * + * 查找 + * + * 返回静态链表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 1.元素e是Compare函数第二个形参 + * 2.这里的实现与教材上的算法2.13不相同，原因参见顶部的“注意”信息 + */ +int LocateElem(SLinkList space, int S, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 前驱 + * + * 获取元素cur_e的前驱， + * 如果存在，将其存储到pre_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status PriorElem(SLinkList space, int S, ElemType cur_e, ElemType* pre_e); + +/* + * 后继 + * + * 获取元素cur_e的后继， + * 如果存在，将其存储到next_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status NextElem(SLinkList space, int S, ElemType cur_e, ElemType* next_e); + +/* + * 插入 + * + * 向静态链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SLinkList space, int S, int i, ElemType e); + +/* + * 删除 + * + * 删除静态链表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListDelete(SLinkList space, int S, int i, ElemType* e); + +/* + * 遍历 + * + * 用visit函数访问静态链表S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 图形化输出 ━━━━━━━━━━━━━━━━━━━━━━*/ + +// 以图形化形式输出当前结构，仅限内部测试使用 +void PrintGraph(SLinkList space, int S); + +#endif diff --git a/CLion/CourseBook/0207_Difference/CMakeLists.txt b/CLion/CourseBook/0207_Difference/CMakeLists.txt new file mode 100644 index 0000000..4b3f8c1 --- /dev/null +++ b/CLion/CourseBook/0207_Difference/CMakeLists.txt @@ -0,0 +1,12 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(Difference SLinkList.h SLinkList.c Difference.h Difference.c Difference-main.c) +# 链接公共库 +target_link_libraries(Difference Scanf_lib) + +# 记录要拷贝到*.exe目录下的资源文件 +file(GLOB TestData TestData*.txt) +# 将资源文件拷贝到*.exe目录下，不然无法加载 +file(COPY ${TestData} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) diff --git a/CLion/CourseBook/0207_Difference/Difference-main.c b/CLion/CourseBook/0207_Difference/Difference-main.c new file mode 100644 index 0000000..b7909d0 --- /dev/null +++ b/CLion/CourseBook/0207_Difference/Difference-main.c @@ -0,0 +1,19 @@ +#include +#include "Difference.h" //**▲02 线性表**// + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SLinkList space; // 备用空间 + int S; // 静态链表 + + printf("S = (A-B)∪(B-A) = "); + difference("TestData.txt", space, &S); + ListTraverse(space, S, PrintElem); + + return 0; +} diff --git a/CLion/CourseBook/0207_Difference/Difference.c b/CLion/CourseBook/0207_Difference/Difference.c new file mode 100644 index 0000000..a630664 --- /dev/null +++ b/CLion/CourseBook/0207_Difference/Difference.c @@ -0,0 +1,95 @@ +/*=============== + * 静态链表去重 + * + * 包含算法: 2.17 + ================*/ + +#include "Difference.h" + +/* + * ████████ 算法2.17 ████████ + * + * S = (A-B)∪(B-A) + * + * 对集合A和集合B进行(A-B)∪(B-A)计算，计算结果存入静态链表S + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据。 + */ +void difference(char path[], SLinkList space, int* S) { + FILE* fp; + int m, n; // 集合A和集合B中元素数量 + int j; // 循环计数器 + int R; // 指向静态链表最后一个结点 + int i, k, p; + int b; // 临时存储从集合B中读到的数据 + + // 初始化备用空间 + InitSpace(space); + + // 获取静态链表头结点 + *S = Malloc(space); + + // 让R执行静态链表最后的结点 + R = *S; + + // 打开文件，准备读取测试数据 + fp = fopen(path, "r"); + if(fp == NULL) { + exit(ERROR); + } + + // 读取集合A和集合B的元素个数 + ReadData(fp, "%d%d", &m, &n); + + // 录入集合A的数据 + for(j = 1; j <= m; ++j) { + // 分配结点 + i = Malloc(space); + + // 输入集合A的元素值 + ReadData(fp, "%d", &space[i].data); + + // 将新结点插入到表尾 + space[R].cur = i; + R = i; + } + + // 尾结点的指针置空 + space[R].cur = 0; + + // 录入集合B的数据 + for(j = 1; j <= n; ++j) { + // 输入集合B的元素值 + ReadData(fp, "%d", &b); + + p = *S; // 指向静态链表头结点，后续总是指向k的前一个位置 + k = space[*S].cur; // 指向静态链表中的首个元素 + + // 在当前静态链表中查找是否存在b元素 + while(k != space[R].cur && space[k].data != b) { + p = k; + k = space[k].cur; + } + + // 如果该元素不存在，则加入静态链表 + if(k == space[R].cur) { + i = Malloc(space); + space[i].data = b; + space[i].cur = space[R].cur; + space[R].cur = i; + + // 如果该元素已存在，则需要移除 + } else { + space[p].cur = space[k].cur; + Free(space, k); + if(R == k) { + R = p; + } + } + } + + fclose(fp); +} \ No newline at end of file diff --git a/CLion/CourseBook/0207_Difference/Difference.h b/CLion/CourseBook/0207_Difference/Difference.h new file mode 100644 index 0000000..06c816c --- /dev/null +++ b/CLion/CourseBook/0207_Difference/Difference.h @@ -0,0 +1,28 @@ +/*=============== + * 静态链表去重 + * + * 包含算法: 2.17 + ================*/ + +#ifndef DIFFERENCE_H +#define DIFFERENCE_H + +#include +#include "Status.h" //**▲01 绪论**// +#include "SLinkList.h" //**▲02 线性表**// + +/* + * ████████ 算法2.17 ████████ + * + * S = (A-B)∪(B-A) + * + * 对集合A和集合B进行(A-B)∪(B-A)计算，计算结果存入静态链表S + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据。 + */ +void difference(char path[], SLinkList space, int* S); + +#endif diff --git a/CLion/CourseBook/0207_Difference/SLinkList.c b/CLion/CourseBook/0207_Difference/SLinkList.c new file mode 100644 index 0000000..4e09106 --- /dev/null +++ b/CLion/CourseBook/0207_Difference/SLinkList.c @@ -0,0 +1,116 @@ +/*================================= + * 静态链表 + * + * 包含算法: 2.13、2.14、2.15、2.16 + ==================================*/ + +#include "SLinkList.h" + +/* + * ██ 提示 ██ + * + * 以下所有函数的形参中： + * space：指示备用空间 + * S ：指示静态链表头结点索引 + */ + +/*━━━━━━━━━━━━━━━━━━━━━━ 备用空间操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * ████████ 算法2.14 ████████ + * + * 初始化备用空间 + * + * 备用空间为静态链表提供可用的内存。 + */ +void InitSpace(SLinkList space) { + int i; + + for(i = 0; i < MAXSIZE - 1; ++i) { + space[i].cur = i + 1; + } + + space[MAXSIZE - 1].cur = 0; +} + +/* + * ████████ 算法2.15 ████████ + * + * 申请空间 + * + * 为静态链表从备用空间申请结点空间， + * 如果申请成功，返回可用空间的索引， + * 申请失败时，返回0。 + */ +int Malloc(SLinkList space) { + int i = space[0].cur; + + if(i != 0) { + // 将申请到的空间从备用空间中删去 + space[0].cur = space[i].cur; + } + + // 返回新申请结点下标 + return i; +} + +/* + * ████████ 算法2.16 ████████ + * + * 回收空间 + * + * 回收索引k处的结点空间以供静态链表后续复用， + * 回收方式就是将该结点空间从静态链表上移除， + * 并将其添加到备用空间的列表当中。 + */ +void Free(SLinkList space, int k) { + space[k].cur = space[0].cur; + space[0].cur = k; +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 静态链表操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 遍历 + * + * 用visit函数访问静态链表S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)) { + int p; + + // 确保链表存在 + if(S == 0 || space[S].cur == 0) { + return; + } + + p = space[S].cur; + + while(p != 0) { + Visit(space[p].data); + p = space[p].cur; + } + + printf("\n"); +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 图形化输出 ━━━━━━━━━━━━━━━━━━━━━━*/ + +// 以图形化形式输出当前结构，仅限内部测试使用 +void PrintGraph(SLinkList space, int S) { + int i = 0; + + printf("==== 备用空间 ====\n"); + while(i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } + + printf("==== 静态链表 ====\n"); + i = S; + while(i>0 && i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } +} diff --git a/CLion/CourseBook/0207_Difference/SLinkList.h b/CLion/CourseBook/0207_Difference/SLinkList.h new file mode 100644 index 0000000..fc2e30d --- /dev/null +++ b/CLion/CourseBook/0207_Difference/SLinkList.h @@ -0,0 +1,89 @@ +/*================================= + * 静态链表 + * + * 包含算法: 2.13、2.14、2.15、2.16 + ==================================*/ + +#ifndef SLINKLIST_H +#define SLINKLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define MAXSIZE 1000 // 备用空间最大容量，近似于静态链表的最大长度 + +/* 静态链表元素类型定义 */ +typedef int ElemType; + +/* + * 静态链表结构 + * + * 注：静态链表依托于一个数组，该数组包含了已占用空间和空闲空间 + */ +typedef struct SLinkLNode { + ElemType data; + int cur; // cur是游标，做指针用，用来链接下一个结点（区别于数组下标） +} SLinkList[MAXSIZE]; // 链表空间类型 + + +/* + * ████ 提示 ████ + * + * 以下所有函数的形参中： + * space：指示备用空间 + * S ：指示静态链表头结点索引 + */ + + +/*━━━━━━━━━━━━━━━━━━━━━━ 备用空间操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * ████████ 算法2.14 ████████ + * + * 初始化备用空间 + * + * 备用空间为静态链表提供可用的内存。 + */ +void InitSpace(SLinkList space); + +/* + * ████████ 算法2.15 ████████ + * + * 申请空间 + * + * 为静态链表从备用空间申请结点空间， + * 如果申请成功，返回可用空间的索引， + * 申请失败时，返回0。 + */ +int Malloc(SLinkList space); + +/* + * ████████ 算法2.16 ████████ + * + * 回收空间 + * + * 回收索引k处的结点空间以供静态链表后续复用， + * 回收方式就是将该结点空间从静态链表上移除， + * 并将其添加到备用空间的列表当中。 + */ +void Free(SLinkList space, int k); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 静态链表操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 遍历 + * + * 用visit函数访问静态链表S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 图形化输出 ━━━━━━━━━━━━━━━━━━━━━━*/ + +// 以图形化形式输出当前结构，仅限内部测试使用 +void PrintGraph(SLinkList space, int S); + +#endif diff --git a/CLion/CourseBook/0207_Difference/TestData.txt b/CLion/CourseBook/0207_Difference/TestData.txt new file mode 100644 index 0000000..c03d314 --- /dev/null +++ b/CLion/CourseBook/0207_Difference/TestData.txt @@ -0,0 +1,4 @@ +集合A的长度：3 +集合B的长度：5 +集合A中元素：2 3 4 +集合B中元素：1 3 4 6 7 \ No newline at end of file diff --git a/CLion/CourseBook/0208_DuLinkList/CMakeLists.txt b/CLion/CourseBook/0208_DuLinkList/CMakeLists.txt new file mode 100644 index 0000000..0a6c9e3 --- /dev/null +++ b/CLion/CourseBook/0208_DuLinkList/CMakeLists.txt @@ -0,0 +1,7 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(DuLinkList DuLinkList.h DuLinkList.c DuLinkList-main.c) +# 链接公共库 +target_link_libraries(DuLinkList Scanf_lib) \ No newline at end of file diff --git a/CLion/CourseBook/0208_DuLinkList/DuLinkList-main.c b/CLion/CourseBook/0208_DuLinkList/DuLinkList-main.c new file mode 100644 index 0000000..8d8ae65 --- /dev/null +++ b/CLion/CourseBook/0208_DuLinkList/DuLinkList-main.c @@ -0,0 +1,149 @@ +#include +#include "Status.h" +#include "DuLinkList.h" //**▲02 线性表**// + +// 判断data>e是否成立 +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + DuLinkList L; + int i; + ElemType e; + + printf("████████ InitList \n"); + { + printf("█ 初始化双向循环链表 L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf("████████ ListEmpty \n"); + { + ListEmpty(L) ? printf("█ L 为空！！\n") : printf("█ L 不为空！\n"); + } + PressEnterToContinue(); + + + printf("████████ ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf("█ 在 L 第 %d 个位置插入 \"%d\" ...\n", i, 2 * i); + ListInsert(L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf("████████ ListTraverse \n"); + { + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ ListLength \n"); + { + printf("█ L 的长度为 %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf("████████ ListDelete \n"); + { + printf("█ 删除前的元素：L = "); + ListTraverse(L, PrintElem); + + printf("█ 尝试删除 L 中第 6 个元素...\n"); + + if(ListDelete(L, 6, &e) == OK) { + printf("█ 删除成功，被删除元素是：\"%d\"\n", e); + } else { + printf("█ 删除失败，第 6 个元素不存在！\n"); + } + + printf("█ 删除后的元素：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ GetElem \n"); + { + GetElem(L, 4, &e); + printf("█ L 中第 4 个位置的元素为 \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf("████████ LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + GetElem(L, i, &e); + printf("█ L 中第一个元素值大于 \"7\" 的元素是 \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf("████████ PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf("█ 元素 \"%d\" 的前驱为 \"%d\" \n", cur_e, e); + } else { + printf("█ 元素 \"%d\" 的前驱不存在！\n", cur_e); + } + } + PressEnterToContinue(); + + + printf("████████ NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf("█ 元素 \"%d\" 的后继为 \"%d\" \n", cur_e, e); + } else { + printf("█ 元素 \"%d\" 的后继不存在！\n", cur_e); + } + } + PressEnterToContinue(); + + + printf("████████ ClearList \n"); + { + printf("█ 清空 L 前："); + ListEmpty(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n"); + + ClearList(L); + + printf("█ 清空 L 后："); + ListEmpty(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n"); + } + PressEnterToContinue(); + + + printf("████████ DestroyList \n"); + { + printf("█ 销毁 L 前："); + L ? printf(" L 存在！\n") : printf(" L 不存在！！\n"); + + DestroyList(&L); + + printf("█ 销毁 L 后："); + L ? printf(" L 存在！\n") : printf(" L 不存在！！\n"); + } + PressEnterToContinue(); + + return 0; +} diff --git a/CLion/CourseBook/0208_DuLinkList/DuLinkList.c b/CLion/CourseBook/0208_DuLinkList/DuLinkList.c new file mode 100644 index 0000000..9dd94b7 --- /dev/null +++ b/CLion/CourseBook/0208_DuLinkList/DuLinkList.c @@ -0,0 +1,402 @@ +/*===================== + * 双向循环链表 + * + * 包含算法: 2.18、2.19 + ======================*/ + +#include "DuLinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(DuLinkList* L) { + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + // 前驱和后继均指向自身 + (*L)->next = (*L)->prior = *L; + + return OK; +} + +/* + * 销毁(结构) + * + * 释放双向循环链表所占内存。 + */ +Status DestroyList(DuLinkList* L) { + // 确保链表结构存在 + if(L == NULL || *L == NULL) { + return ERROR; + } + + ClearList(*L); + + free(*L); + + *L = NULL; + + return OK; +} + +/* + * 置空(内容) + * + * 这里需要释放双向循环链表中非头结点处的空间。 + */ +Status ClearList(DuLinkList L) { + DuLinkList p, q; + + if(L == NULL) { + return ERROR; + } + + p = L->next; + + while(p != L) { + q = p->next; + free(p); + p = q; + } + + L->next = L->prior = L; + + return OK; +} + +/* + * 判空 + * + * 判断双向循环链表中是否包含有效数据。 + * + * 返回值： + * TRUE : 双向循环链表为空 + * FALSE: 双向循环链表不为空 + */ +Status ListEmpty(DuLinkList L) { + if(L != NULL && L->next == L && L->prior == L) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * 计数 + * + * 返回双向循环链表包含的有效元素的数量。 + */ +int ListLength(DuLinkList L) { + DuLinkList p; + int i; + + if(L == NULL || L->next == L || L->prior == L) { + return 0; + } + + i = 0; + p = L->next; + + // 遍历所有结点 + while(p != L) { + i++; + p = p->next; + } + + return i; +} + +/* + * 取值 + * + * 获取双向循环链表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(DuLinkList L, int i, ElemType* e) { + DuLinkList p; + int j; + + // 确保双向循环链表存在 + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点的后继不为L + while(p->next != L && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p->next == L || j > i - 1) { + return ERROR; + } + + *e = p->next->data; + + return OK; +} + +/* + * 查找 + * + * 返回双向循环链表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(DuLinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + DuLinkList p; + + // 确保双向循环链表存在 + if(L == NULL || L->next == L || L->prior == L) { + return 0; + } + + i = 1; // i的初值为第1个元素的位序 + p = L->next; // p的初值为第1个元素的指针 + + while(p != L && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != L) { + return i; + } else { + return 0; + } +} + +/* + * 前驱 + * + * 获取元素cur_e的前驱， + * 如果存在，将其存储到pre_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status PriorElem(DuLinkList L, ElemType cur_e, ElemType* pre_e) { + DuLinkList p; + + // 确保双向循环链表存在 + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // 指向第1个元素 + p = L->next; + + // 第1个元素没有前驱 + if(p->data == cur_e) { + return ERROR; + } + + // 指向第2个元素 + p = p->next; + + // 从第2个元素开始，查找cur_e的位置 + while(p != L && p->data != cur_e) { + p = p->next; + } + + // 如果没找到元素cur_e，查找失败，返回ERROR + if(p == L) { + return ERROR; + } + + *pre_e = p->prior->data; + + return OK; +} + +/* + * 后继 + * + * 获取元素cur_e的后继， + * 如果存在，将其存储到next_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status NextElem(DuLinkList L, ElemType cur_e, ElemType* next_e) { + DuLinkList p; + + // 确保双向循环链表存在 + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // 指向第1个元素 + p = L->next; + + // 从第1个元素开始，查找cur_e的位置，且保证该结点的后继不为L + while(p->next != L && p->data != cur_e) { + p = p->next; + } + + // 如果没找到cur_e，或者找到了，但它没有后继，均返回ERROR + if(p->next == L) { + return ERROR; + } + + *next_e = p->next->data; + + return OK; +} + +/* + * ████████ 算法2.18 ████████ + * + * 插入 + * + * 向双向循环链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(DuLinkList L, int i, ElemType e) { + DuLinkList p, s; + + // 确保双向循环链表存在（但可能为空表） + if(L == NULL) { + return ERROR; + } + + // 查找第i个结点位置（引用） + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // 创建新结点 + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // 将s插入到p的前面，称为第i个结点 + s->prior = p->prior; + p->prior->next = s; + s->next = p; + p->prior = s; + + return OK; +} + +/* + * ████████ 算法2.19 ████████ + * + * 删除 + * + * 删除双向循环链表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListDelete(DuLinkList L, int i, ElemType* e) { + DuLinkList p; + + // 确保双向循环链表存在 + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // 查找第i个结点位置（引用） + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // 如果p==L，说明待删除元素是第len+1个元素，不合规 + if(p == L) { + return ERROR; + } + + *e = p->data; + + // 移除p结点 + p->prior->next = p->next; + p->next->prior = p->prior; + + free(p); + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问双向循环链表L + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)) { + DuLinkList p; + + // 确保双向循环链表存在 + if(L == NULL || L->next == L || L->prior == L) { + return; + } + + p = L->next; + + while(p != L) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * 获取循环链表L上第i个元素的引用 + * + * ▓▓▓▓ 注 ▓▓▓▓ + * 1.加static的含义是当前函数只在DuLinkList中使用，不会被别的文件引用 + * 2.假设链表长度为len，且需要获取第len+1个元素的引用时，由于这里是循环链表，所以返回的是头结点 + */ +static DuLinkList GetElemP(DuLinkList L, int i) { + DuLinkList p; + int count; + + // 确保双向循环链表存在（但可能为空表） + if(L == NULL) { + return NULL; + } + + // 位置不合规 + if(i < 1) { + return NULL; + } + + p = L; + count = 0; + + // 尝试查找第i个元素 + while(p->next != L && count < i) { + p = p->next; + ++count; + } + + // 恰好找到第i个元素 + if(count == i) { + return p; + } + + // 至此，说明p->next==L，此时需要判断i是否过大 + if(count + 1 < i) { + return NULL; + } + + // 至此，说明需要在len+1的位置上插入元素 + return L; +} diff --git a/CLion/CourseBook/0208_DuLinkList/DuLinkList.h b/CLion/CourseBook/0208_DuLinkList/DuLinkList.h new file mode 100644 index 0000000..e2bc01e --- /dev/null +++ b/CLion/CourseBook/0208_DuLinkList/DuLinkList.h @@ -0,0 +1,153 @@ +/*===================== + * 双向循环链表 + * + * 包含算法: 2.18、2.19 + ======================*/ + +#ifndef DULINKLIST_H +#define DULINKLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 双向循环链表元素类型定义 */ +typedef int ElemType; + +/* + * 双向循环链表结构 + * + * 注：这里的双向循环链表存在头结点 + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // 前驱 + struct DuLNode* next; // 后继 +} DuLNode; + +// 指向双向循环链表结点的指针 +typedef DuLNode* DuLinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(DuLinkList* L); + +/* + * 销毁(结构) + * + * 释放双向循环链表所占内存。 + */ +Status DestroyList(DuLinkList* L); + +/* + * 置空(内容) + * + * 这里需要释放双向循环链表中非头结点处的空间。 + */ +Status ClearList(DuLinkList L); + +/* + * 判空 + * + * 判断双向循环链表中是否包含有效数据。 + * + * 返回值： + * TRUE : 双向循环链表为空 + * FALSE: 双向循环链表不为空 + */ +Status ListEmpty(DuLinkList L); + +/* + * 计数 + * + * 返回双向循环链表包含的有效元素的数量。 + */ +int ListLength(DuLinkList L); + +/* + * 取值 + * + * 获取双向循环链表中第i个元素，将其存储到e中。 + * 如果可以找到，返回OK，否则，返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数，但这不符合编码的通用约定。 + * 通常，i的含义应该指索引，即从0开始计数。 + */ +Status GetElem(DuLinkList L, int i, ElemType* e); + +/* + * 查找 + * + * 返回双向循环链表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(DuLinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 前驱 + * + * 获取元素cur_e的前驱， + * 如果存在，将其存储到pre_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status PriorElem(DuLinkList L, ElemType cur_e, ElemType* pre_e); + +/* + * 后继 + * + * 获取元素cur_e的后继， + * 如果存在，将其存储到next_e中，返回OK， + * 如果不存在，则返回ERROR。 + */ +Status NextElem(DuLinkList L, ElemType cur_e, ElemType* next_e); + +/* + * ████████ 算法2.18 ████████ + * + * 插入 + * + * 向双向循环链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(DuLinkList L, int i, ElemType e); + +/* + * ████████ 算法2.19 ████████ + * + * 删除 + * + * 删除双向循环链表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListDelete(DuLinkList L, int i, ElemType* e); + +/* + * 遍历 + * + * 用visit函数访问双向循环链表L + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)); + +/* + * 获取循环链表L上第i个元素的引用 + * + * ▓▓▓▓ 注意 ▓▓▓▓ + * 1.加static的含义是当前函数只在DuLinkList中使用，不会被别的文件引用 + * 2.假设链表长度为len，且需要获取第len+1个元素的引用时，由于这里是循环链表，所以返回的是头结点 + */ +static DuLinkList GetElemP(DuLinkList L, int i); + +#endif diff --git a/CLion/CourseBook/0209_ELinkList/CMakeLists.txt b/CLion/CourseBook/0209_ELinkList/CMakeLists.txt new file mode 100644 index 0000000..4c765f6 --- /dev/null +++ b/CLion/CourseBook/0209_ELinkList/CMakeLists.txt @@ -0,0 +1,7 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(ELinkList ELinkList.h ELinkList.c ELinkList-main.c) +# 链接公共库 +target_link_libraries(ELinkList Scanf_lib) \ No newline at end of file diff --git a/CLion/CourseBook/0209_ELinkList/ELinkList-main.c b/CLion/CourseBook/0209_ELinkList/ELinkList-main.c new file mode 100644 index 0000000..a6ec568 --- /dev/null +++ b/CLion/CourseBook/0209_ELinkList/ELinkList-main.c @@ -0,0 +1,224 @@ +#include +#include "ELinkList.h" //**▲02 线性表**// + +// 判断data>e是否成立 +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ELinkList L; + Link p, q, s; + Position r; + int i; + ElemType e; + + printf("████████ InitList \n"); + { + printf("█ 初始化扩展的线性链表 L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf("████████ ListEmpty \n"); + { + ListEmpty(L) ? printf("█ L 为空！！\n") : printf("█ L 不为空！\n"); + } + PressEnterToContinue(); + + + printf("████████ ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf("█ 在 L 第 %d 个位置插入 \"%d\" ...\n", i, 2 * i); + ListInsert(&L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf("████████ ListTraverse \n"); + { + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ ListLength \n"); + { + printf("█ L 的长度为 %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf("████████ ListDelete \n"); + { + printf("█ 删除前的元素：L = "); + ListTraverse(L, PrintElem); + + printf("█ 尝试删除 L 中第 6 个元素...\n"); + + if(ListDelete(&L, 6, &e) == OK) { + printf("█ 删除成功，被删除元素是：\"%d\"\n", e); + } else { + printf("█ 删除失败，第 6 个元素不存在！\n"); + } + + printf("█ 删除后的元素：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ LocateElem \n"); + { + r = LocateElem(L, 7, CmpGreater); + printf("█ L 中第一个元素值大于 \"7\" 的元素是 \"%d\" \n", r->data); + } + PressEnterToContinue(); + + + printf("████████ PriorElem \n"); + { + Position pre = PriorPos(L, r); + + if(pre !=NULL) { + printf("█ 元素 \"%d\" 的前驱为 \"%d\" \n", r->data, pre->data); + } else { + printf("█ 元素 \"%d\" 的前驱不存在！\n", r->data); + } + } + PressEnterToContinue(); + + + printf("████████ NextElem \n"); + { + Position next = NextPos(L, r); + + if(next !=NULL) { + printf("█ 元素 \"%d\" 的后继为 \"%d\" \n", r->data, next->data); + } else { + printf("█ 元素 \"%d\" 的后继不存在！\n", r->data); + } + } + PressEnterToContinue(); + + + printf("████████ MakeNode \n"); + { + printf("█ 创建结点 \"100\" ...\n"); + MakeNode(&p, 100); + printf("█ 创建结点 \"200\" ...\n"); + MakeNode(&q, 200); + printf("█ 创建结点 \"300\" ...\n"); + MakeNode(&s, 300); + } + PressEnterToContinue(); + + + printf("████████ InsFirst \n"); + { + printf("█ 将元素 \"%d\" 插入到元素 \"%d\" 之后...\n", s->data, r->data); + InsFirst(&L, r, s); + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ DelFirst \n"); + { + printf("█ 删除元素 \"%d\" 之后的元素...\n", r->data); + DelFirst(&L, r, &s); + printf("█ 被删除的元素为：\"%d\"\n", s->data); + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ InsBefore \n"); + { + Link t = r; + + printf("█ 将元素 \"%d\" 插入到元素 \"%d\" 之前...\n", p->data, t->data); + InsBefore(&L, &t, p); + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ InsAfter \n"); + { + Link t = r; + + printf("█ 将元素 \"%d\" 插入到元素 \"%d\" 之后...\n", q->data, t->data); + InsAfter(&L, &t, q); + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ Append \n"); + { + printf("█ 创建结点 \"400\" ...\n"); + MakeNode(&s, 400); + + printf("█ 将元素 %d 插入到链表最后...\n", s->data); + Append(&L, s); + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ Remove \n"); + { + printf("█ 从链表最后删除元素...\n"); + Remove(&L, &s); + printf("█ 被删除的元素为：\"%d\"\n", s->data); + printf("█ L 中的元素为：L = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf("████████ ClearList \n"); + { + printf("清空 L 前："); + ListEmpty(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n"); + + ClearList(&L); + + printf("清空 L 后："); + ListEmpty(L) ? printf(" L 为空！！\n") : printf(" L 不为空！\n"); + } + PressEnterToContinue(); + + + printf("████████ DestroyList \n"); + { + printf("销毁 L 前："); + L.head != NULL && L.tail != NULL ? printf(" L 存在！\n") : printf(" L 不存在！！\n"); + + DestroyList(&L); + + printf("销毁 L 后："); + L.head != NULL && L.tail != NULL ? printf(" L 存在！\n") : printf(" L 不存在！！\n"); + + } + PressEnterToContinue(); + + return 0; +} + diff --git a/CLion/CourseBook/0209_ELinkList/ELinkList.c b/CLion/CourseBook/0209_ELinkList/ELinkList.c new file mode 100644 index 0000000..5087f66 --- /dev/null +++ b/CLion/CourseBook/0209_ELinkList/ELinkList.c @@ -0,0 +1,630 @@ +/*======================= + * 扩展的单链表（线性链表） + * + * 包含算法: 2.20 + ========================*/ + +#include "ELinkList.h" //**▲02 线性表**// + + +/*━━━━━━━━━━━━━━━━━━━━━━ 内存操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 内存分配 + * + * 为线性链表申请一个结点，并存入指定的数据e。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // 申请空间 + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // 这里没有退出程序，而是返回错误提示 + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * 内存回收 + * + * 释放线性链表中指定的结点。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表常规操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // 创建头结点 + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // 只有头结点时，首位游标指向自身 + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * 销毁(结构) + * + * 释放链表所占内存。 + */ +Status DestroyList(ELinkList* L) { + + // 链表不存在时没必要销毁 + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + ClearList(L); + + free((*L).head); + + (*L).head = (*L).tail = NULL; + + return OK; +} + +/* + * 置空(内容) + * + * 这里需要释放链表中非头结点处的空间。 + */ +Status ClearList(ELinkList* L) { + Link p, q; + + // 没有有效元素时不需要清理 + if(L == NULL || (*L).head == NULL || (*L).len <= 0) { + return ERROR; + } + + // 指向第1个元素 + p = (*L).head->next; + + // 释放所有元素所占内存 + while(p != NULL) { + q = p->next; + free(p); + p = q; + } + + (*L).head->next = NULL; + (*L).tail = (*L).head; + (*L).len = 0; + + return OK; +} + +/* + * 判空 + * + * 判断链表中是否包含有效数据。 + * + * 返回值： + * TRUE : 链表为空 + * FALSE: 链表不为空 + */ +Status ListEmpty(ELinkList L) { + if(L.len <= 0) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * 计数 + * + * 返回链表包含的有效元素的数量。 + */ +int ListLength(ELinkList L) { + return L.len; +} + +/* + * 查找 + * + * 返回链表中首个与e满足Compare关系的元素引用。 + * 如果不存在这样的元素，则返回NULL。 + * + *【备注】 + * 1.元素e是Compare函数第二个形参 + * 2.这里的返回值是目标元素的引用，而不是其位序 + */ +Position LocateElem(ELinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + Position p; + + if(L.len <= 0) { + return NULL; + } + + // 指向第1个元素 + p = L.head->next; + + while(p != NULL && !Compare(p->data, e)) { + p = p->next; + } + + return p; +} + +/* + * ████████ 算法2.20 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + * 可以看做是算法2.9的改写 + */ +Status ListInsert(ELinkList* L, int i, ElemType e) { + Link h, s; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // 确保i值合规[1, len+1] + if(i < 1 || i > (*L).len + 1) { + return ERROR; + } + + // 查找第i-1个元素的引用，存储在h中 + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // 分配新结点s + if(MakeNode(&s, e) == ERROR) { + return ERROR; + } + + // 将s结点插入到h结点后面，成为h后面的第一个结点 + if(InsFirst(L, h, s) == ERROR) { + return ERROR; + } + + return OK; +} + +/* + * 删除 + * + * 删除链表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + * 可以看做是算法2.10的改写 + */ +Status ListDelete(ELinkList* L, int i, ElemType* e) { + Link h, q; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // 确保i值合规[1, len] + if(i < 1 || i > (*L).len) { + return ERROR; + } + + // 查找第i-1个元素的引用，存储在h中 + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // 删除h结点后的第一个结点，并用q存储被删除结点的引用 + if(DelFirst(L, h, &q) == ERROR) { + return ERROR; + } + + // 记下被删除元素的值 + *e = q->data; + + // 释放被删除结点的空间 + FreeNode(&q); + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)) { + Link p; + + if(L.len <= 0) { + return; + } + + // 指向第1个元素 + p = L.head->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表扩展操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 取值 + * + * 获取结点p的元素值。 + */ +ElemType GetCurElem(Link p) { + if(p == NULL) { + return INT_MIN; + } + + return p->data; +} + +/* + * 设值 + * + * 为结点p设置元素值。 + */ +Status SetCurElem(Link p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + p->data = e; + + return OK; +} + +/* + * 头结点 + * + * 获取头结点引用。 + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * 尾结点 + * + * 获取尾结点引用。 + */ +Position GetLast(ELinkList L) { + return L.tail; +} + +/* + * 前驱 + * + * 获取结点p的前驱，如果不存在，则返回NULL。 + */ +Position PriorPos(ELinkList L, Link p) { + Link pre; + + // 确保链表(头结点)存在 + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + // 指向头结点 + pre = L.head; + + // 第一个结点无前驱 + if(pre->next == p) { + return NULL; + } + + // 查找P的前驱 + while(pre != NULL && pre->next != p) { + pre = pre->next; + } + + return pre; +} + +/* + * 后继 + * + * 获取结点p的后继，如果不存在，则返NULL。 + */ +Position NextPos(ELinkList L, Link p) { + + // 确保链表(头结点)存在 + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * 查找 + * + * 查找链表L中第i(允许为0)个结点，并将其引用存入p，且返回OK + * 如果i值不合规，则返回ERROR + * 特别注意，当i为0时，p存储的是头结点的引用 + */ +Status LocatePos(ELinkList L, int i, Link* p) { + int j; + Link r; + + // 注：i允许为0 + if(i < 0 || i > L.len) { + return ERROR; + } + + // 保证链表(头结点)存在 + if(L.head == NULL) { + return ERROR; + } + + // i为0时，取头结点 + if(i == 0) { + *p = L.head; + return OK; + } + + j = 0; // 计数 + r = L.head; // 指向头结点 + + while(r != NULL && j < i) { + j++; + r = r->next; + } + + if(r == NULL) { + return ERROR; + } + + *p = r; + + return OK; +} + +/* + * 插入 + * + * 将s结点插入到h结点后面，成为h后面的第一个结点 + * + *【备注】 + * 教材中对于该方法的描述有些问题，这里是修正过的版本 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // 若h为尾结点，则需要更新尾结点 + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * 删除 + * + * 删除h结点后的第一个结点，并用q存储被删除结点的引用 + * + *【备注】 + * 教材中对于该方法的定义略显粗糙，这里是修正过的版本 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // 如果没有结点可删除，返回错误信息 + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // 将被删除结点变成孤立的结点 + (*q)->next = NULL; + + // 如果h后只有一个结点，更改尾结点指针 + if(h->next == NULL) { + (*L).tail = h; + } + + // 并不释放被删结点所占空间 + (*L).len--; + + return OK; +} + +/* + * 前向插入 + * + * 将s结点插入到p结点之前，并将p指向新结点 + */ +Status InsBefore(ELinkList* L, Link* p, Link s) { + Link pre; + + if(L == NULL || (*L).head == NULL || p == NULL || s == NULL) { + return ERROR; + } + + // 指向头结点 + pre = (*L).head; + + // 查找p结点的广义前驱：即对于第一个元素，其前驱为头结点 + while(pre != NULL && pre->next != (*p)) { + pre = pre->next; + } + + // 没找到广义前驱 + if(pre == NULL) { + return ERROR; + } + + s->next = *p; + pre->next = s; + *p = s; + + (*L).len++; //修改len，需用到*L + + return OK; +} + +/* + * 后向插入 + * + * 将s结点插入到p结点之前，并将p指向新结点 + */ +Status InsAfter(ELinkList* L, Link* p, Link s) { + Link r; + + if(L == NULL || (*L).head == NULL || p == NULL || s == NULL) { + return ERROR; + } + + r = (*L).head; + + while(r != NULL && r != (*p)) { + r = r->next; + } + + // 如果未找到结点p，返回错误信息 + if(r == NULL) { + return ERROR; + } + + // 如果p指向最后一个结点，则需要更新尾指针 + if(*p == (*L).tail) { + (*L).tail = s; + } + + s->next = (*p)->next; + (*p)->next = s; + *p = s; + + (*L).len++; + + return OK; +} + +/* + * 向尾部添加 + * + * 将s所指的一串结点链接在链表L后面 + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // 确定新的尾结点位置 + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} + +/* + * 从尾部移除 + * + * 将链表的尾结点移除，并将被移除的结点引用存储在q中 + */ +Status Remove(ELinkList* L, Link* q) { + Link p; + + if(L == NULL || (*L).head == NULL || q == NULL) { + return ERROR; + } + + // 没有元素可供移除 + if((*L).len == 0) { + *q = NULL; + return ERROR; + } + + *q = (*L).tail; + + // 确定新的尾结点位置 + p = (*L).head; + while(p->next != (*L).tail) { + p = p->next; + } + p->next = NULL; + (*L).tail = p; + + (*L).len--; + + return OK; +} diff --git a/CLion/CourseBook/0209_ELinkList/ELinkList.h b/CLion/CourseBook/0209_ELinkList/ELinkList.h new file mode 100644 index 0000000..614ff32 --- /dev/null +++ b/CLion/CourseBook/0209_ELinkList/ELinkList.h @@ -0,0 +1,253 @@ +/*======================= + * 扩展的单链表（线性链表） + * + * 包含算法: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include // 提供一些极限常量 +#include "Status.h" //**▲01 绪论**// + +/* + * ████ 注意 ████ + * + * 教材中的线性链表命名为LinkList， + * 这里为了与单链表区分，故将其命名为ELinkList。 + * 线性链表可以理解成对普通链表的一种扩展。 + */ + +/* 线性链表元素类型定义 */ +typedef int ElemType; + +/* + * 线性链表结构 + * + * 注：这里的线性链表存在头结点 + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* 维护线性链表头尾指针及长度信息 */ +typedef struct { + Link head, tail; // 分别指向线性链表中的头结点和尾结点 + int len; // 指示线性链表中数据元素的个数 +} ELinkList; + + +/*━━━━━━━━━━━━━━━━━━━━━━ 内存操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 内存分配 + * + * 为线性链表申请一个结点，并存入指定的数据e。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +Status MakeNode(Link* p, ElemType e); + +/* + * 内存回收 + * + * 释放线性链表中指定的结点。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +void FreeNode(Link* p); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表常规操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(ELinkList* L); + +/* + * 销毁(结构) + * + * 释放链表所占内存。 + */ +Status DestroyList(ELinkList* L); + +/* + * 置空(内容) + * + * 这里需要释放链表中非头结点处的空间。 + */ +Status ClearList(ELinkList* L); + +/* + * 判空 + * + * 判断链表中是否包含有效数据。 + * + * 返回值： + * TRUE : 链表为空 + * FALSE: 链表不为空 + */ +Status ListEmpty(ELinkList L); + +/* + * 计数 + * + * 返回链表包含的有效元素的数量。 + */ +int ListLength(ELinkList L); + +/* + * 查找 + * + * 返回链表中首个与e满足Compare关系的元素引用。 + * 如果不存在这样的元素，则返回NULL。 + * + *【备注】 + * 1.元素e是Compare函数第二个形参 + * 2.这里的返回值是目标元素的引用，而不是其位序 + */ +Position LocateElem(ELinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ████████ 算法2.20 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + * 可以看做是算法2.9的改写 + */ +Status ListInsert(ELinkList* L, int i, ElemType e); + +/* + * 删除 + * + * 删除链表第i个位置上的元素，并将被删除元素存储到e中。 + * 删除成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + * 可以看做是算法2.10的改写 + */ +Status ListDelete(ELinkList* L, int i, ElemType* e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表扩展操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 取值 + * + * 获取结点p的元素值。 + */ +ElemType GetCurElem(Link p); + +/* + * 设值 + * + * 为结点p设置元素值。 + */ +Status SetCurElem(Link p, ElemType e); + +/* + * 头结点 + * + * 获取头结点引用。 + */ +Position GetHead(ELinkList L); + +/* + * 尾结点 + * + * 获取尾结点引用。 + */ +Position GetLast(ELinkList L); + +/* + * 前驱 + * + * 获取结点p的前驱，如果不存在，则返回NULL。 + */ +Position PriorPos(ELinkList L, Link p); + +/* + * 后继 + * + * 获取结点p的后继，如果不存在，则返NULL。 + */ +Position NextPos(ELinkList L, Link p); + +/* + * 查找 + * + * 查找链表L中第i(允许为0)个结点，并将其引用存入p，且返回OK + * 如果i值不合规，则返回ERROR + * 特别注意，当i为0时，p存储的是头结点的引用 + */ +Status LocatePos(ELinkList L, int i, Link* p); + +/* + * 插入 + * + * 将s结点插入到h结点后面，成为h后面的第一个结点 + * + *【备注】 + * 教材中对于该方法的描述有些问题，这里是修正过的版本 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * 删除 + * + * 删除h结点后的第一个结点，并用q存储被删除结点的引用 + * + *【备注】 + * 教材中对于该方法的定义略显粗糙，这里是修正过的版本 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * 前向插入 + * + * 将s结点插入到p结点之前，并将p指向新结点 + */ +Status InsBefore(ELinkList* L, Link* p, Link s); + +/* + * 后向插入 + * + * 将s结点插入到p结点之前，并将p指向新结点 + */ +Status InsAfter(ELinkList* L, Link* p, Link s); + +/* + * 向尾部添加 + * + * 将s所指的一串结点链接在链表L后面 + */ +Status Append(ELinkList* L, Link s); + +/* + * 从尾部移除 + * + * 将链表的尾结点移除，并将被移除的结点引用存储在q中 + */ +Status Remove(ELinkList* L, Link* q); + +#endif diff --git a/CLion/CourseBook/0210_MergeEList/CMakeLists.txt b/CLion/CourseBook/0210_MergeEList/CMakeLists.txt new file mode 100644 index 0000000..d09ff55 --- /dev/null +++ b/CLion/CourseBook/0210_MergeEList/CMakeLists.txt @@ -0,0 +1,12 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(MergeEList ELinkList.h ELinkList.c MergeEList.h MergeEList.c MergeEList-main.c) +# 链接公共库 +target_link_libraries(MergeEList Scanf_lib) + +# 记录要拷贝到*.exe目录下的资源文件 +file(GLOB TestData TestData*.txt) +# 将资源文件拷贝到*.exe目录下，不然无法加载 +file(COPY ${TestData} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) diff --git a/CLion/CourseBook/0210_MergeEList/ELinkList.c b/CLion/CourseBook/0210_MergeEList/ELinkList.c new file mode 100644 index 0000000..0ee0b2b --- /dev/null +++ b/CLion/CourseBook/0210_MergeEList/ELinkList.c @@ -0,0 +1,324 @@ +/*======================= + * 扩展的单链表（线性链表） + * + * 包含算法: 2.20 + ========================*/ + +#include "ELinkList.h" //**▲02 线性表**// + + +/*━━━━━━━━━━━━━━━━━━━━━━ 内存操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 内存分配 + * + * 为线性链表申请一个结点，并存入指定的数据e。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // 申请空间 + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // 这里没有退出程序，而是返回错误提示 + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * 内存回收 + * + * 释放线性链表中指定的结点。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表常规操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // 创建头结点 + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // 只有头结点时，首位游标指向自身 + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * ████████ 算法2.20 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + * 可以看做是算法2.9的改写 + */ +Status ListInsert(ELinkList* L, int i, ElemType e) { + Link h, s; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // 确保i值合规[1, len+1] + if(i < 1 || i > (*L).len + 1) { + return ERROR; + } + + // 查找第i-1个元素的引用，存储在h中 + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // 分配新结点s + if(MakeNode(&s, e) == ERROR) { + return ERROR; + } + + // 将s结点插入到h结点后面，成为h后面的第一个结点 + if(InsFirst(L, h, s) == ERROR) { + return ERROR; + } + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)) { + Link p; + + if(L.len <= 0) { + return; + } + + // 指向第1个元素 + p = L.head->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表扩展操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 取值 + * + * 获取结点p的元素值。 + */ +ElemType GetCurElem(Link p) { + if(p == NULL) { + return INT_MIN; + } + + return p->data; +} + +/* + * 头结点 + * + * 获取头结点引用。 + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * 后继 + * + * 获取结点p的后继，如果不存在，则返NULL。 + */ +Position NextPos(ELinkList L, Link p) { + + // 确保链表(头结点)存在 + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * 查找 + * + * 查找链表L中第i(允许为0)个结点，并将其引用存入p，且返回OK + * 如果i值不合规，则返回ERROR + * 特别注意，当i为0时，p存储的是头结点的引用 + */ +Status LocatePos(ELinkList L, int i, Link* p) { + int j; + Link r; + + // 注：i允许为0 + if(i < 0 || i > L.len) { + return ERROR; + } + + // 保证链表(头结点)存在 + if(L.head == NULL) { + return ERROR; + } + + // i为0时，取头结点 + if(i == 0) { + *p = L.head; + return OK; + } + + j = 0; // 计数 + r = L.head; // 指向头结点 + + while(r != NULL && j < i) { + j++; + r = r->next; + } + + if(r == NULL) { + return ERROR; + } + + *p = r; + + return OK; +} + +/* + * 插入 + * + * 将s结点插入到h结点后面，成为h后面的第一个结点 + * + *【备注】 + * 教材中对于该方法的描述有些问题，这里是修正过的版本 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // 若h为尾结点，则需要更新尾结点 + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * 删除 + * + * 删除h结点后的第一个结点，并用q存储被删除结点的引用 + * + *【备注】 + * 教材中对于该方法的定义略显粗糙，这里是修正过的版本 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // 如果没有结点可删除，返回错误信息 + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // ★将被删除结点变成孤立的结点 + (*q)->next = NULL; + + // 如果h后只有一个结点，更改尾结点指针 + if(h->next == NULL) { + (*L).tail = h; + } + + // 并不释放被删结点所占空间 + (*L).len--; + + return OK; +} + +/* + * 向尾部添加 + * + * 将s所指的一串结点链接在链表L后面 + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // 确定新的尾结点位置 + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} diff --git a/CLion/CourseBook/0210_MergeEList/ELinkList.h b/CLion/CourseBook/0210_MergeEList/ELinkList.h new file mode 100644 index 0000000..d6a031f --- /dev/null +++ b/CLion/CourseBook/0210_MergeEList/ELinkList.h @@ -0,0 +1,155 @@ +/*======================= + * 扩展的单链表（线性链表） + * + * 包含算法: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include // 提供一些极限常量 +#include "Status.h" //**▲01 绪论**// + +/* + * ████ 注意 ████ + * + * 教材中的线性链表命名为LinkList， + * 这里为了与单链表区分，故将其命名为ELinkList。 + * 线性链表可以理解成对普通链表的一种扩展。 + */ + +/* 线性链表元素类型定义 */ +typedef int ElemType; + +/* + * 线性链表结构 + * + * 注：这里的线性链表存在头结点 + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* 维护线性链表头尾指针及长度信息 */ +typedef struct { + Link head, tail; // 分别指向线性链表中的头结点和尾结点 + int len; // 指示线性链表中数据元素的个数 +} ELinkList; + + +/*━━━━━━━━━━━━━━━━━━━━━━ 内存操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 内存分配 + * + * 为线性链表申请一个结点，并存入指定的数据e。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +Status MakeNode(Link* p, ElemType e); + +/* + * 内存回收 + * + * 释放线性链表中指定的结点。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +void FreeNode(Link* p); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表常规操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(ELinkList* L); + +/* + * ████████ 算法2.20 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + * 可以看做是算法2.9的改写 + */ +Status ListInsert(ELinkList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表扩展操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 取值 + * + * 获取结点p的元素值。 + */ +ElemType GetCurElem(Link p); + +/* + * 头结点 + * + * 获取头结点引用。 + */ +Position GetHead(ELinkList L); + +/* + * 后继 + * + * 获取结点p的后继，如果不存在，则返NULL。 + */ +Position NextPos(ELinkList L, Link p); + +/* + * 查找 + * + * 查找链表L中第i(允许为0)个结点，并将其引用存入p，且返回OK + * 如果i值不合规，则返回ERROR + * 特别注意，当i为0时，p存储的是头结点的引用 + */ +Status LocatePos(ELinkList L, int i, Link* p); + +/* + * 插入 + * + * 将s结点插入到h结点后面，成为h后面的第一个结点 + * + *【备注】 + * 教材中对于该方法的描述有些问题，这里是修正过的版本 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * 删除 + * + * 删除h结点后的第一个结点，并用q存储被删除结点的引用 + * + *【备注】 + * 教材中对于该方法的定义略显粗糙，这里是修正过的版本 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * 向尾部添加 + * + * 将s所指的一串结点链接在链表L后面 + */ +Status Append(ELinkList* L, Link s); + +#endif diff --git a/CLion/CourseBook/0210_MergeEList/MergeEList-main.c b/CLion/CourseBook/0210_MergeEList/MergeEList-main.c new file mode 100644 index 0000000..dfc2a84 --- /dev/null +++ b/CLion/CourseBook/0210_MergeEList/MergeEList-main.c @@ -0,0 +1,71 @@ +#include +#include "MergeEList.h" //**▲02 线性表**// + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} + +/* + * 比较 + * + * 比较e1和e2的大小，返回值含义如下： + * < 0：e1 < e2 + * = 0：e1 = e2 + * > 0：e1 > e2 + */ +int Cmp(ElemType e1, ElemType e2) { + return e1 - e2; +} + +/* + * 尾插法创建链表 + * + *【备注】 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件fp中读取测试数据。 + */ +void CreateList_Tail(char path[], ELinkList* L) { + FILE* fp; + int i, n; + ElemType e; + + fp = fopen(path, "r"); + if(fp == NULL) { + printf("文件打开失败...\n"); + exit(ERROR); + } + + // 读取指定集合中元素的数量 + ReadData(fp, "%d", &n); + + InitList(L); + + for(i = 1; i <= n; i++) { + ReadData(fp, "%d", &e); + ListInsert(L, i, e); + } + + fclose(fp); +} + + +int main(int argc, char** argv) { + ELinkList La, Lb, Lc; + + printf("创建La和Lb以待测试...\n"); + + CreateList_Tail("TestData_La.txt", &La); + printf("La= "); + ListTraverse(La, PrintElem); + + CreateList_Tail("TestData_Lb.txt", &Lb); + printf("Lb= "); + ListTraverse(Lb, PrintElem); + + MergeEList(&La, &Lb, &Lc, Cmp); + printf("合并La和Lb为 Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} diff --git a/CLion/CourseBook/0210_MergeEList/MergeEList.c b/CLion/CourseBook/0210_MergeEList/MergeEList.c new file mode 100644 index 0000000..9984ca1 --- /dev/null +++ b/CLion/CourseBook/0210_MergeEList/MergeEList.c @@ -0,0 +1,75 @@ +/*=============== + * 归并非降序链表 + * + * 包含算法: 2.21 + ================*/ + +#include "MergeEList.h" + +Status MergeEList(ELinkList* La, ELinkList* Lb, ELinkList* Lc, int(Compare)(ElemType, ElemType)){ + Link ha, hb, pa, pb, q; + ElemType a, b; + + if(InitList(Lc) == ERROR) { + return ERROR; + } + + ha = GetHead(*La); // 指向La头结点 + hb = GetHead(*Lb); // 指向Lb头结点 + + // 保证La和Lb是有效的链表，不过有可能是空表 + if(ha == NULL || hb ==NULL) { + return ERROR; + } + + pa = NextPos(*La, ha); // 指向La第1个元素 + pb = NextPos(*La, hb); // 指向Lb第1个元素 + + // 遍历La和Lb，选出较小的元素，依次加入到Lc中 + while(pa !=NULL && pb!=NULL){ + a = GetCurElem(pa); + b = GetCurElem(pb); + + // 如果La<=Lb + if(Compare(a, b)<=0) { + // 摘下La中首个元素 + DelFirst(La, ha, &q); + + // 将上述摘下的元素追加到Lc中 + Append(Lc, q); + + // 依然是获取La中第1个元素 + pa = NextPos(*La, ha); + } else { + // 摘下Lb中首个元素 + DelFirst(Lb, hb, &q); + + // 将上述摘下的元素追加到Lc中 + Append(Lc, q); + + // 依然是获取La中第1个元素 + pb = NextPos(*Lb, hb); + } + } + + // 如果La还有剩余 + if(pa!=NULL) { + Append(Lc, pa); + } else { + Append(Lc, pb); + } + + // 释放La的头结点。教材中这里是对ha操作，但是那样无法置空La的头指针，因而这里做了修改 + FreeNode(&(La->head)); + + // 释放Lb的头结点。教材中这里是对hb操作，但是那样无法置空Lb的头指针，因而这里做了修改 + FreeNode(&(Lb->head)); + + La->tail = NULL; + Lb->tail = NULL; + + La->len = 0; + Lb->len = 0; + + return OK; +} \ No newline at end of file diff --git a/CLion/CourseBook/0210_MergeEList/MergeEList.h b/CLion/CourseBook/0210_MergeEList/MergeEList.h new file mode 100644 index 0000000..7c084b7 --- /dev/null +++ b/CLion/CourseBook/0210_MergeEList/MergeEList.h @@ -0,0 +1,36 @@ +/*=============== + * 归并非降序链表 + * + * 包含算法: 2.21 + ================*/ + +#ifndef MERGEELIST_H +#define MERGEELIST_H + +#include +#include "Status.h" //**▲01 绪论**// +#include "ELinkList.h" //**▲02 线性表**// + +/* + * ████ 注意 ████ + * + * 为了与之前的归并算法名称区分，这里将算法名称命名为MergeEList(教材中的名称是MergeList_L) + */ + +/* + * ████████ 算法2.21 ████████ + * + * 非递减链表归并：C=A+B + * + * 将链表A和B归并为C，且保持元素相对位置不变。 + * 归并结束后，会销毁La和Lb。 + */ +Status MergeEList(ELinkList* La, ELinkList* Lb, ELinkList* Lc, int(Compare)(ElemType, ElemType)); + +/*━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ +┃(01)算法2.21：La与Lb均非递减排列，将其归并为一个非递减排列的单链表Lc。┃ +┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━*/ + + + +#endif diff --git a/CLion/CourseBook/0210_MergeEList/TestData_La.txt b/CLion/CourseBook/0210_MergeEList/TestData_La.txt new file mode 100644 index 0000000..fddd3cc --- /dev/null +++ b/CLion/CourseBook/0210_MergeEList/TestData_La.txt @@ -0,0 +1,2 @@ +集合A的长度：6 +La = 1 2 3 5 7 8 \ No newline at end of file diff --git a/CLion/CourseBook/0210_MergeEList/TestData_Lb.txt b/CLion/CourseBook/0210_MergeEList/TestData_Lb.txt new file mode 100644 index 0000000..9ae416c --- /dev/null +++ b/CLion/CourseBook/0210_MergeEList/TestData_Lb.txt @@ -0,0 +1,2 @@ +集合B的长度：7 +Lb = 2 4 5 8 10 11 13 \ No newline at end of file diff --git a/CLion/CourseBook/0211_Polynomial/CMakeLists.txt b/CLion/CourseBook/0211_Polynomial/CMakeLists.txt new file mode 100644 index 0000000..b373b99 --- /dev/null +++ b/CLion/CourseBook/0211_Polynomial/CMakeLists.txt @@ -0,0 +1,12 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件 +add_executable(Polynomial ELinkList.h ELinkList.c Polynomial.h Polynomial.c Polynomial-main.c) +# 链接公共库 +target_link_libraries(Polynomial Scanf_lib) + +# 记录要拷贝到*.exe目录下的资源文件 +file(GLOB TestData TestData*.txt) +# 将资源文件拷贝到*.exe目录下，不然无法加载 +file(COPY ${TestData} DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) diff --git a/CLion/CourseBook/0211_Polynomial/ELinkList.c b/CLion/CourseBook/0211_Polynomial/ELinkList.c new file mode 100644 index 0000000..3d6467c --- /dev/null +++ b/CLion/CourseBook/0211_Polynomial/ELinkList.c @@ -0,0 +1,338 @@ +/*======================= + * 扩展的单链表（线性链表） + * + * 包含算法: 2.20 + ========================*/ + +#include "ELinkList.h" //**▲02 线性表**// + + +/*━━━━━━━━━━━━━━━━━━━━━━ 内存操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 内存分配 + * + * 为线性链表申请一个结点，并存入指定的数据e。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // 申请空间 + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // 这里没有退出程序，而是返回错误提示 + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * 内存回收 + * + * 释放线性链表中指定的结点。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表常规操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // 创建头结点 + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // 只有头结点时，首位游标指向自身 + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * 销毁(结构) + * + * 释放链表所占内存。 + */ +Status DestroyList(ELinkList* L) { + + // 链表不存在时没必要销毁 + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + ClearList(L); + + free((*L).head); + + (*L).head = (*L).tail = NULL; + + return OK; +} + +/* + * 置空(内容) + * + * 这里需要释放链表中非头结点处的空间。 + */ +Status ClearList(ELinkList* L) { + Link p, q; + + // 没有有效元素时不需要清理 + if(L == NULL || (*L).head == NULL || (*L).len <= 0) { + return ERROR; + } + + // 指向第1个元素 + p = (*L).head->next; + + // 释放所有元素所占内存 + while(p != NULL) { + q = p->next; + free(p); + p = q; + } + + (*L).head->next = NULL; + (*L).tail = (*L).head; + (*L).len = 0; + + return OK; +} + +/* + * 计数 + * + * 返回链表包含的有效元素的数量。 + */ +int ListLength(ELinkList L) { + return L.len; +} + +/* + * 查找 + * + * 这个查找函数与传统的版本不一样。 + * 这里首先会查找与元素e满足Compare()==0的元素，如果找到，使用q存储其引用，并返回True。 + * 如果不存在上述引用，则查找首个与元素e满足Compare()>0的元素的前驱，并返回FALSE。 + * 如果链表中的元素均大于e，q存储头结点引用。 + * 如果链表中的元素均小于e，q存储尾结点引用。 + * 其它情形下，会将q置空。 + * + *【备注】 + * 1.元素e是Compare函数第二个形参 + */ +Status LocateElem(ELinkList L, ElemType e, Position* q, Status(Compare)(ElemType, ElemType)) { + Position pre, p; + + *q = NULL; + + // 链表不存在，返回错误信息 + if(L.head == NULL) { + return FALSE; + } + + pre = L.head; + p = pre->next; + + while(p != NULL && Compare(p->data, e) < 0) { + pre = p; + p = p->next; + } + + // 找到了与e满足"相等"条件的元素 + if(p != NULL && Compare(p->data, e) == 0) { + *q = p; + return TRUE; + } + + // 所有元素均小于e，或者p元素大于e，又或者为空表 + *q = pre; + + return FALSE; +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表扩展操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 取值 + * + * 获取结点p的元素值。 + */ +ElemType GetCurElem(Link p) { + ElemType e; + + if(p == NULL) { + e.coef = 0.0f; + e.expn = -1; + return e; + } + + return p->data; +} + +/* + * 设值 + * + * 为结点p设置元素值。 + */ +Status SetCurElem(Link p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + p->data = e; + + return OK; +} + +/* + * 头结点 + * + * 获取头结点引用。 + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * 后继 + * + * 获取结点p的后继，如果不存在，则返NULL。 + */ +Position NextPos(ELinkList L, Link p) { + + // 确保链表(头结点)存在 + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * 插入 + * + * 将s结点插入到h结点后面，成为h后面的第一个结点 + * + *【备注】 + * 教材中对于该方法的描述有些问题，这里是修正过的版本 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // 若h为尾结点，则需要更新尾结点 + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * 删除 + * + * 删除h结点后的第一个结点，并用q存储被删除结点的引用 + * + *【备注】 + * 教材中对于该方法的定义略显粗糙，这里是修正过的版本 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // 如果没有结点可删除，返回错误信息 + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // 将被删除结点变成孤立的结点 + (*q)->next = NULL; + + // 如果h后只有一个结点，更改尾结点指针 + if(h->next == NULL) { + (*L).tail = h; + } + + // 并不释放被删结点所占空间 + (*L).len--; + + return OK; +} + +/* + * 向尾部添加 + * + * 将s所指的一串结点链接在链表L后面 + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // 确定新的尾结点位置 + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} diff --git a/CLion/CourseBook/0211_Polynomial/ELinkList.h b/CLion/CourseBook/0211_Polynomial/ELinkList.h new file mode 100644 index 0000000..cc377ab --- /dev/null +++ b/CLion/CourseBook/0211_Polynomial/ELinkList.h @@ -0,0 +1,175 @@ +/*======================= + * 扩展的单链表（线性链表） + * + * 包含算法: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include // 提供一些极限常量 +#include "Status.h" //**▲01 绪论**// + +/* + * ████ 注意 ████ + * + * 教材中的线性链表命名为LinkList， + * 这里为了与单链表区分，故将其命名为ELinkList。 + * 线性链表可以理解成对普通链表的一种扩展。 + */ + +/* + * 线性链表元素类型定义 + * 这里用在多项式中，用到了结构体类型的元素 + */ +typedef struct { + float coef; // 多项式系数 + int expn; // 多项式指数 +} ElemType; // 重新定义扩展的线性表中元素类型 + +/* + * 线性链表结构 + * + * 注：这里的线性链表存在头结点 + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* 维护线性链表头尾指针及长度信息 */ +typedef struct { + Link head, tail; // 分别指向线性链表中的头结点和尾结点 + int len; // 指示线性链表中数据元素的个数 +} ELinkList; + + +/*━━━━━━━━━━━━━━━━━━━━━━ 内存操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 内存分配 + * + * 为线性链表申请一个结点，并存入指定的数据e。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +Status MakeNode(Link* p, ElemType e); + +/* + * 内存回收 + * + * 释放线性链表中指定的结点。 + * + *【备注】 + * static修饰的含义是该函数仅限当前文件内使用 + */ +void FreeNode(Link* p); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表常规操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(ELinkList* L); + +/* + * 销毁(结构) + * + * 释放链表所占内存。 + */ +Status DestroyList(ELinkList* L); + +/* + * 置空(内容) + * + * 这里需要释放链表中非头结点处的空间。 + */ +Status ClearList(ELinkList* L); + +/* + * 计数 + * + * 返回链表包含的有效元素的数量。 + */ +int ListLength(ELinkList L); + +/* + * 查找 + * + * 这个查找函数与传统的版本不一样。 + * 这里首先会查找与元素e满足Compare()==0的元素，如果找到，使用q存储其引用，并返回True。 + * 如果不存在上述引用，则查找首个与元素e满足Compare()>0的元素的前驱，并返回FALSE。 + * 如果链表中的元素均大于e，q存储头结点引用。 + * 如果链表中的元素均小于e，q存储尾结点引用。 + * 其它情形下，会将q置空。 + * + *【备注】 + * 1.元素e是Compare函数第二个形参 + */ +Status LocateElem(ELinkList L, ElemType e, Position* q, Status(Compare)(ElemType, ElemType)); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 链表扩展操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 取值 + * + * 获取结点p的元素值。 + */ +ElemType GetCurElem(Link p); + +/* + * 设值 + * + * 为结点p设置元素值。 + */ +Status SetCurElem(Link p, ElemType e); + +/* + * 头结点 + * + * 获取头结点引用。 + */ +Position GetHead(ELinkList L); + +/* + * 后继 + * + * 获取结点p的后继，如果不存在，则返NULL。 + */ +Position NextPos(ELinkList L, Link p); + +/* + * 插入 + * + * 将s结点插入到h结点后面，成为h后面的第一个结点 + * + *【备注】 + * 教材中对于该方法的描述有些问题，这里是修正过的版本 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * 删除 + * + * 删除h结点后的第一个结点，并用q存储被删除结点的引用 + * + *【备注】 + * 教材中对于该方法的定义略显粗糙，这里是修正过的版本 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * 向尾部添加 + * + * 将s所指的一串结点链接在链表L后面 + */ +Status Append(ELinkList* L, Link s); + +#endif diff --git a/CLion/CourseBook/0211_Polynomial/Polynomial-main.c b/CLion/CourseBook/0211_Polynomial/Polynomial-main.c new file mode 100644 index 0000000..ff14ee8 --- /dev/null +++ b/CLion/CourseBook/0211_Polynomial/Polynomial-main.c @@ -0,0 +1,79 @@ +#include "Polynomial.h" //**▲02 线性表**// + +int main(int argc, char **argv) { + Polynomial Pa, Pb; + int m, n; + + m = 5; + n = 6; + + printf("████████ CreatPolyn \n"); + { + printf("█ 作为示范，创建项数为 %d 的多项式Pa...\n", m); + CreatPolyn("TestData_Pa.txt", &Pa, m); + + printf("█ 作为示范，创建项数为 %d 的多项式Pb...\n", n); + CreatPolyn("TestData_Pb.txt", &Pb, n); + } + PressEnterToContinue(); + + + printf("████████ PrintPolyn \n"); + { + printf("█ 一元多项式 Pa = "); + PrintPolyn(Pa); + + printf("█ 一元多项式 Pb = "); + PrintPolyn(Pb); + } + PressEnterToContinue(); + + + printf("████████ PolynLength \n"); + { + printf("█ La 的项数为 %d ，Lb 的项数为 %d\n", PolynLength(Pa), PolynLength(Pb)); + } + PressEnterToContinue(); + + + printf("████████ AddPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + AddPolyn(&Pa, &Pb); + + printf("█ Pa = Pa + Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + + printf("████████ SubtractPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + SubtractPolyn(&Pa, &Pb); + + printf("█ Pa = Pa - Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + + printf("████████ MultiplyPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + MultiplyPolyn(&Pa, &Pb); + + printf("█ Pa = Pa * Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/CLion/CourseBook/0211_Polynomial/Polynomial.c b/CLion/CourseBook/0211_Polynomial/Polynomial.c new file mode 100644 index 0000000..954b507 --- /dev/null +++ b/CLion/CourseBook/0211_Polynomial/Polynomial.c @@ -0,0 +1,397 @@ +/*======================== + * 一元多项式(基于线性链表) + * + * 包含算法: 2.22、2.23 + =========================*/ + +#include "Polynomial.h" + + +/*━━━━━━━━━━━━━━━━━━━━━━ 一元多项式操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * ████████ 算法2.22 ████████ + * + * 创建 + * + * 根据输入的系数和指数，创建项数为m的一元多项式 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据 + */ +void CreatPolyn(char path[], Polynomial* P, int m) { + FILE* fp; + int i; + ElemType e; + Position h, q; + Link s; + + // 初始化一个线性链表存放一元多项式 + InitList(P); + + // 获取多项式头指针 + h = GetHead(*P); + + // 为头结点填充数据 + e.coef = 0.0f; + e.expn = -1; + SetCurElem(h, e); + + // 打开文件，准备读取测试数据 + fp = fopen(path, "r"); + if(fp == NULL) { + exit(ERROR); + } + + // 依次录入m个有效项 + for(i = 1; i <= m; i++) { + // 读取系数和指数信息，临时存入e + ReadData(fp, "%f%d", &(e.coef), &(e.expn)); + + // 如果当前链表中不存在该指数项 + if(LocateElem(*P, e, &q, Cmp) == FALSE && q != NULL) { + // 创建新结点 + if(MakeNode(&s, e) == OK) { + // 在q结点之后插入s + InsFirst(P, q, s); + } + } + } + + fclose(fp); +} + +/* + * 销毁 + * + * 销毁一元多项式。 + */ +void DestroyPolyn(Polynomial* P) { + DestroyList(P); +} + +/* + * 计数 + * + * 返回一元多项式的项数。 + */ +int PolynLength(Polynomial P) { + return ListLength(P); +} + +/* + * ████████ 算法2.23 ████████ + * + * 加法 + * + * 一元多项式加法Pa=Pa+Pb， + * 计算完成后，计算结果存到Pa中，并将Pb销毁。 + */ +void AddPolyn(Polynomial* Pa, Polynomial* Pb) { + Position ha, hb; + Position qa, qb; + ElemType a, b; + float sum; + + // ha、hb分别指向Pa、Pb头结点 + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // qa、qb分别指向Pa、Pb的当前结点 + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + + // qa、qb均非空 + while(qa && qb) { + // a和b为两表中当前比较元素 + a = GetCurElem(qa); + b = GetCurElem(qb); + + //比较当前元素的指数大小 + switch(Cmp(a, b)) { + // 多项式Pa中当前结点的指数值较小 + case -1: { + ha = qa; + qa = NextPos(*Pa, qa); + } + break; + + // 两者数值相等 + case 0: { + sum = a.coef + b.coef; + + // 相加不能抵消时更新Pa结点的系数值 + if(sum != 0.0) { + // 这里用SetCurElem()不合适，不如直接赋值 + qa->data.coef = sum; + // ha后移 + ha = qa; + + //相加抵消时，删除Pa中当前结点 + } else { + // 删除ha后面的结点（其实删的就是qa） + DelFirst(Pa, ha, &qa); + // 释放被删除结点所占空间 + FreeNode(&qa); + } + + // 删除Pb中扫描过的结点 + DelFirst(Pb, hb, &qb); + // 释放被删除结点所占空间 + FreeNode(&qb); + + // qa、qb均后移 + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + + // 多项式Pb中当前结点的指数值较小 + case 1: { + // 摘下Pb当前结点 + DelFirst(Pb, hb, &qb); + + // 将摘下结点链入Pa中 + InsFirst(Pa, ha, qb); + + ha = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + }//switch + }//while + + // 若Pb还未扫描完，将剩余项链接到Pa后 + if(qb != NULL) { + Append(Pa, qb); + } + + // 释放Pb头结点 + FreeNode(&hb); + + // 设置Pb为销毁状态 + (*Pb).head = (*Pb).tail = NULL; + (*Pb).len = 0; +} + +/* + * 减法 + * + * 一元多项式减法Pa=Pa-Pb， + * 计算完成后，计算结果存到Pa中，并将Pb销毁。 + */ +void SubtractPolyn(Polynomial* Pa, Polynomial* Pb) { + Position ha, hb; + Position qa, qb; + Position r; + ElemType a, b; + float sum; + + // ha、hb分别指向Pa、Pb头结点 + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // qa、qb分别指向Pa、Pb的当前结点 + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + + // qa、qb均非空 + while(qa && qb) { + // a和b为两表中当前比较元素 + a = GetCurElem(qa); + b = GetCurElem(qb); + + // 比较当前元素的指数大小 + switch(Cmp(a, b)) { + // 多项式Pa中当前结点的指数值较小 + case -1: { + ha = qa; + qa = NextPos(*Pa, ha); + } + break; + + // 两者数值相等 + case 0: { + sum = a.coef - b.coef; + + // 相减不能抵消时更新Pa结点的系数值 + if(sum != 0.0) { + // 更新系数 + qa->data.coef = sum; + // ha后移 + ha = qa; + + // 相减抵消时，删除Pa中当前结点 + } else { + // 删除ha后面的结点（其实删的就是qa） + DelFirst(Pa, ha, &qa); + // 释放被删除结点所占空间 + FreeNode(&qa); + } + + // 删除Pb中扫描过的结点 + DelFirst(Pb, hb, &qb); + // 释放被删除结点所占空间 + FreeNode(&qb); + + // qa、qb均后移 + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + + // 多项式Pb中当前结点的指数值较小 + case 1: { + // 摘下Pb当前结点 + DelFirst(Pb, hb, &qb); + + // 改变当前结点符号 + qb->data.coef = -qb->data.coef; + + // 将摘下结点链入Pa中 + InsFirst(Pa, ha, qb); + + ha = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + }//switch + }//while + + // 若Pb还未扫描完，将剩余项的系数取反后链接到Pa后 + if(qb != NULL) { + // 改变剩余项的符号 + for(r = qb = 0; r != NULL; r = r->next) { + r->data.coef = -r->data.coef; + } + + Append(Pa, qb); + } + + // 释放Pb头结点 + FreeNode(&hb); + + // 设置Pb为销毁状态 + (*Pb).head = (*Pb).tail = NULL; + (*Pb).len = 0; +} + +/* + * 乘法 + * + * 一元多项式乘法Pa=Pa*Pb， + * 计算完成后，计算结果存到Pa中，并将Pb销毁。 + */ +void MultiplyPolyn(Polynomial* Pa, Polynomial* Pb) { + Polynomial Pc, Ptmp; + int i, j, la, lb; + Position ha, hb; + Position qa, qb; + Link s; + ElemType e; + + // 获取两个多项式的长度 + la = PolynLength(*Pa); + lb = PolynLength(*Pb); + + // ha、hb分别指向Pa、Pb头结点 + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // 累加计算结果 + InitList(&Pc); + + // 遍历Pa中的元素 + for(i = 1; i <= la; i++) { + // 存储临时计算结果 + InitList(&Ptmp); + + // 逐个摘下Pa中的结点 + DelFirst(Pa, ha, &qa); + + // 遍历Pb中所有结点，与Pa中摘下的结点进行运算 + for(j = 1, qb = NextPos(*Pb, hb); j <= lb; j++, qb = NextPos(*Pb, qb)) { + e.coef = qa->data.coef * qb->data.coef; //系数相乘 + e.expn = qa->data.expn + qb->data.expn; //指数相加 + + // 创建新结点存储结算结果 + MakeNode(&s, e); + + // 添加到临时多项式 + Append(&Ptmp, s); + } + + // 将新的多项式累加到Pc上 + AddPolyn(&Pc, &Ptmp); + } + + // 将所有结果添加到Pa上 + AddPolyn(Pa, &Pc); + + // 销毁多项式Pb + DestroyPolyn(Pb); +} + + +/*━━━━━━━━━━━━━━━━━━━━━━ 基础操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 输出 + * + * 打印输出一元多项式。 + */ +void PrintPolyn(Polynomial P) { + int i; + Link p; + + p = P.head->next; + for(i = 1; i <= P.len; i++) { + if(p->data.coef == 0.0f) { + continue; + } + + if(i == 1) { + printf("%g", p->data.coef); + } else { + if(p->data.coef > 0) { + printf(" + "); + printf("%g", p->data.coef); + } else { + printf(" - "); + printf("%g", -p->data.coef); + } + } + + if(p->data.expn) { + printf("x"); + + if(p->data.expn != 1) { + printf("^%d", p->data.expn); + } + } + + p = p->next; + } + + printf("\n"); +} + +/* + * 比较 + * + * 比较c1项和c2项指数大小。 + */ +int Cmp(ElemType c1, ElemType c2) { + // 计算指数差 + int i = c1.expn - c2.expn; + + if(i < 0) { + return -1; + } else if(i == 0) { + return 0; + } else { + return 1; + } +} diff --git a/CLion/CourseBook/0211_Polynomial/Polynomial.h b/CLion/CourseBook/0211_Polynomial/Polynomial.h new file mode 100644 index 0000000..2f533db --- /dev/null +++ b/CLion/CourseBook/0211_Polynomial/Polynomial.h @@ -0,0 +1,91 @@ +/*======================== + * 一元多项式(基于线性链表) + * + * 包含算法: 2.22、2.23 + =========================*/ + +#ifndef POLYNOMIAL_H +#define POLYNOMIAL_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "ELinkList.h" //**▲02 线性表**// + +/* 一元多项式类型定义 */ +typedef ELinkList Polynomial; + + +/*━━━━━━━━━━━━━━━━━━━━━━ 一元多项式操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * ████████ 算法2.22 ████████ + * + * 创建 + * + * 根据输入的系数和指数，创建项数为m的一元多项式 + * + *【备注】 + * 教材中默认从控制台读取数据。 + * 这里为了方便测试，避免每次运行都手动输入数据， + * 因而选择了从预设的文件path中读取测试数据 + */ +void CreatPolyn(char path[], Polynomial *P, int m); + +/* + * 销毁 + * + * 销毁一元多项式。 + */ +void DestroyPolyn(Polynomial *P); + +/* + * 计数 + * + * 返回一元多项式的项数。 + */ +int PolynLength(Polynomial P); + +/* + * ████████ 算法2.23 ████████ + * + * 加法 + * + * 一元多项式加法Pa=Pa+Pb， + * 计算完成后，计算结果存到Pa中，并将Pb销毁。 + */ +void AddPolyn(Polynomial *Pa, Polynomial *Pb); + +/* + * 减法 + * + * 一元多项式减法Pa=Pa-Pb， + * 计算完成后，计算结果存到Pa中，并将Pb销毁。 + */ +void SubtractPolyn(Polynomial *Pa, Polynomial *Pb); + +/* + * 乘法 + * + * 一元多项式乘法Pa=Pa*Pb， + * 计算完成后，计算结果存到Pa中，并将Pb销毁。 + */ +void MultiplyPolyn(Polynomial *Pa, Polynomial *Pb); + + +/*━━━━━━━━━━━━━━━━━━━━━━ 基础操作 ━━━━━━━━━━━━━━━━━━━━━━*/ + +/* + * 输出 + * + * 打印输出一元多项式。 + */ +void PrintPolyn(Polynomial P); + +/* + * 比较 + * + * 比较c1项和c2项指数大小。 + */ +int Cmp(ElemType c1, ElemType c2); + +#endif diff --git a/CLion/CourseBook/0211_Polynomial/TestData_Pa.txt b/CLion/CourseBook/0211_Polynomial/TestData_Pa.txt new file mode 100644 index 0000000..e72f216 --- /dev/null +++ b/CLion/CourseBook/0211_Polynomial/TestData_Pa.txt @@ -0,0 +1 @@ +Pa = (2.1 , 1) (5.3 , 7) (4.0 , 3) (2.5 , 9) (-3.12 , 5) \ No newline at end of file diff --git a/CLion/CourseBook/0211_Polynomial/TestData_Pb.txt b/CLion/CourseBook/0211_Polynomial/TestData_Pb.txt new file mode 100644 index 0000000..2940e87 --- /dev/null +++ b/CLion/CourseBook/0211_Polynomial/TestData_Pb.txt @@ -0,0 +1 @@ +Pb = (0.5 , 12) (-3.17 , 4) (3.4 , 2) (-2.5 , 9) (4.1 , 5) (1.8 , 8) \ No newline at end of file diff --git a/CLion/CourseBook/CMakeLists.txt b/CLion/CourseBook/CMakeLists.txt new file mode 100644 index 0000000..b08f9c3 --- /dev/null +++ b/CLion/CourseBook/CMakeLists.txt @@ -0,0 +1,11 @@ +add_subdirectory(0201_SqList) +add_subdirectory(0202_Union) +add_subdirectory(0203_MergeSqList) +add_subdirectory(0204_LinkList) +add_subdirectory(0205_MergeList) +add_subdirectory(0206_SLinkList) +add_subdirectory(0207_Difference) +add_subdirectory(0208_DuLinkList) +add_subdirectory(0209_ELinkList) +add_subdirectory(0210_MergeEList) +add_subdirectory(0211_Polynomial) diff --git a/CLion/ExerciseBook/01.16/01.16.c b/CLion/ExerciseBook/01.16/01.16.c new file mode 100644 index 0000000..0fdbc51 --- /dev/null +++ b/CLion/ExerciseBook/01.16/01.16.c @@ -0,0 +1,53 @@ +#include + +/* + * 题1.16 + * + * 将3个整数按从大到小顺序输出 + */ +void Algo_1_16(int *x, int *y, int *z); + + +int main(int argc, char* argv[]) { + int x, y, z; + + x = 3; + y = 7; + z = 1; + + printf("作为示范，设定输入为：%d %d %d...\n", x, y, z); + + // 进行排序 + Algo_1_16(&x, &y, &z); + + printf("将其从大到小排序后为：%d %d %d...\n", x, y, z); + + return 0; +} + + +// 将3个整数按从大到小顺序输出 +void Algo_1_16(int *x, int *y, int *z) { + int tmp; + + // 确保x>=y + if(*x < *y) { + tmp = *x; + *x = *y; + *y = tmp; + } + + // 确保z>=y + if(*y < *z) { + tmp = *y; + *y = *z; + *z = tmp; + } + + // 确保x>=z + if(*x < *z) { + tmp = *x; + *x = *z; + *z = tmp; + } +} diff --git a/CLion/ExerciseBook/01.16/CMakeLists.txt b/CLion/ExerciseBook/01.16/CMakeLists.txt new file mode 100644 index 0000000..4c1535d --- /dev/null +++ b/CLion/ExerciseBook/01.16/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(01.16 01.16.c) +target_link_libraries(01.16 Scanf_lib) \ No newline at end of file diff --git a/CLion/ExerciseBook/01.17/01.17.c b/CLion/ExerciseBook/01.17/01.17.c new file mode 100644 index 0000000..f48ad7f --- /dev/null +++ b/CLion/ExerciseBook/01.17/01.17.c @@ -0,0 +1,86 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* + * 题1.17———方法1：递归算法 + * + * 计算k阶斐波那契数列第m项的值 + * + * 注：计算结果是int类型，当项数过大时会溢出 + */ +int Algo_1_17_1(int k, int m); + +/* + * 题1.17———方法2：递推(迭代)算法 + * + * 计算k阶斐波那契数列第m项的值 + * + * 注：计算结果是int类型，当项数过大时会溢出 + */ +int Algo_1_17_2(int k, int m); + + +int main(int argc, char* argv[]) { + int k, m; + + k = 3; + m = 20; + + printf("作为示范，求得 %d 阶斐波那契数列第 %d 项的值为：%d \n", k, m, Algo_1_17_1(k, m)); + + printf("作为示范，求得 %d 阶斐波那契数列第 %d 项的值为：%d \n", k, m, Algo_1_17_2(k, m)); + + return 0; +} + + +// 计算k阶斐波那契数列第m项的值 +int Algo_1_17_1(int k, int m) { + int i, value; + + if(k < 2 || m < 0) { + exit(OVERFLOW); + } + + if(m < k - 1) { + return 0; + } else if(m == k - 1) { + return 1; + } else { + for(i = 1, value = 0; i <= k; i++) { + value += Algo_1_17_1(k, m - i); + } + + return value; + } +} + +// 计算k阶斐波那契数列第m项的值 +int Algo_1_17_2(int k, int m) { + int i, j; + int* fib; + + if(k < 1 || m < 0) { + exit(OVERFLOW); + } + + // 创建fib数组 + fib = (int*) malloc((m + 1) * sizeof(int)); + + // 初始化前k-1项为0 + for(i = 0; i < k - 1; i++) { + fib[i] = 0; + } + + fib[k - 1] = 1; + + for(i = k; i <= m; ++i) { + // 累加前k项 + for(j = i - 1, fib[i] = 0; j >= i - k; j--) { + fib[i] += fib[j]; + } + } + + return fib[m]; +} diff --git a/CLion/ExerciseBook/01.17/CMakeLists.txt b/CLion/ExerciseBook/01.17/CMakeLists.txt new file mode 100644 index 0000000..2807681 --- /dev/null +++ b/CLion/ExerciseBook/01.17/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(01.17 01.17.c) +target_link_libraries(01.17 Scanf_lib) \ No newline at end of file diff --git a/CLion/ExerciseBook/01.19/01.19.c b/CLion/ExerciseBook/01.19/01.19.c new file mode 100644 index 0000000..4e8a0cb --- /dev/null +++ b/CLion/ExerciseBook/01.19/01.19.c @@ -0,0 +1,55 @@ +#include +#include // 提供宏INT_MAX +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define arrsize 20 //数组长度 +#define maxint INT_MAX //最大的整数 + +/* + * 题1.17 + * + * 计算i!*2^i的值，并存入a[i-1]，i∈[1, arrsize] + * + * i!*2^i = (i-1)!*2^(i-1) * i * 2 + */ +Status Algo_1_19(int i, int a[]); + + +int main(int argc, char* argv[]) { + int i, a[arrsize]; + + i = 5; + + printf("计算i!*2^i...\n"); + + if(Algo_1_19(i, a) == OK) { + printf("作为示例，计算当i = %d 时，a[i-1] = %d\n", i, a[i - 1]); + } + + return 0; +} + + +// 计算i!*2^i的值 +Status Algo_1_19(int i, int a[]) { + int j; + + if(i < 1 || i > arrsize) { + return ERROR; + } + + // 计算i==1时的情形 + a[0] = 2; + + // 计算i>1时的情形 + for(j = 2; j <= i; j++) { + if(maxint / (2 * j) < a[j - 2]) { + return OVERFLOW; + } + + a[j - 1] = a[j - 2] * j * 2; + } + + return OK; +} diff --git a/CLion/ExerciseBook/01.19/CMakeLists.txt b/CLion/ExerciseBook/01.19/CMakeLists.txt new file mode 100644 index 0000000..1bddffb --- /dev/null +++ b/CLion/ExerciseBook/01.19/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(01.19 01.19.c) +target_link_libraries(01.19 Scanf_lib) \ No newline at end of file diff --git a/CLion/ExerciseBook/01.20/01.20.c b/CLion/ExerciseBook/01.20/01.20.c new file mode 100644 index 0000000..d67a411 --- /dev/null +++ b/CLion/ExerciseBook/01.20/01.20.c @@ -0,0 +1,34 @@ +#include +#include //提供pow原型 + +/* + * 题1.20 + * + * 计算多项式Pn(Xo)的值 + */ +double Algo_1_20(int a[], int x, int n); + + +int main(int argc, char* argv[]) { + int a[5] = {-2, 3, 6, -8, 7}; + int n = 5; + int Xo = 3; + + printf("作为示范，设定项数n = 5，变量Xo = 3，计算Pn(Xo)...\n"); + printf("P%d(%d) = %f\n", n, Xo, Algo_1_20(a, Xo, n)); + + return 0; +} + + +// 计算多项式Pn(Xo)的值 +double Algo_1_20(int a[], int x, int n) { + int i; + double tmp; + + for(i = 1, tmp = 0; i <= n; i++) { + tmp += a[i - 1] * pow(x, i - 1); + } + + return tmp; +} \ No newline at end of file diff --git a/CLion/ExerciseBook/01.20/CMakeLists.txt b/CLion/ExerciseBook/01.20/CMakeLists.txt new file mode 100644 index 0000000..486be06 --- /dev/null +++ b/CLion/ExerciseBook/01.20/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(01.20 01.20.c) +target_link_libraries(01.20 Scanf_lib) \ No newline at end of file diff --git a/CLion/ExerciseBook/02.10/02.10.c b/CLion/ExerciseBook/02.10/02.10.c new file mode 100644 index 0000000..de869e0 --- /dev/null +++ b/CLion/ExerciseBook/02.10/02.10.c @@ -0,0 +1,68 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "SqList.h" //**▲02 线性表**// + +/* + * 题2.10 + * + * 删除顺序表中从第i个元素起的k个元素 + * 如果i和k的值不合规，则顺序表不会有变化 + */ +Status Algo_2_10(SqList* a, int i, int k); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // 初始化顺序表 + InitList(&L); + + // 填充值 + for(i = 1; i <= 15; i++) { + ListInsert(&L, i, i); + } + + printf("删除前：L = "); + ListTraverse(L, PrintElem); + + printf("删除第 6 个元素起的 5 个元素...\n"); + Algo_2_10(&L, 6, 5); + + printf("删除后：L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// 删除顺序表中从第i个元素起的k个元素 +Status Algo_2_10(SqList* a, int i, int k) { + int j; + + // 确保顺序表存在 + if(a == NULL || a->elem == NULL) { + return ERROR; + } + + // 下标越界 + if(i < 1 || i > (*a).length || k < 0 || i + k - 1 > (*a).length) { + return ERROR; + } + + for(j = i; j <= i + k - 1; j++) { + (*a).elem[j - 1] = (*a).elem[j + k - 1]; + } + + (*a).length -= k; + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.10/CMakeLists.txt b/CLion/ExerciseBook/02.10/CMakeLists.txt new file mode 100644 index 0000000..1b638be --- /dev/null +++ b/CLion/ExerciseBook/02.10/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.10 SqList.h SqList.c 02.10.c) +target_link_libraries(02.10 Scanf_lib) diff --git a/CLion/ExerciseBook/02.10/SqList.c b/CLion/ExerciseBook/02.10/SqList.c new file mode 100644 index 0000000..ec36b00 --- /dev/null +++ b/CLion/ExerciseBook/02.10/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.10/SqList.h b/CLion/ExerciseBook/02.10/SqList.h new file mode 100644 index 0000000..23a33a2 --- /dev/null +++ b/CLion/ExerciseBook/02.10/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.11/02.11.c b/CLion/ExerciseBook/02.11/02.11.c new file mode 100644 index 0000000..6065f72 --- /dev/null +++ b/CLion/ExerciseBook/02.11/02.11.c @@ -0,0 +1,92 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// +#include "SqList.h" //**▲02 线性表**// + +/* + * 题2.11 + * + * 将x插入到递增序列va中 + */ +Status Algo_2_11(SqList* va, ElemType x); + +// 判断data>e是否成立 +Status CmpGreater(ElemType data, ElemType e); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // 初始化顺序表 + InitList(&L); + + // 填充值 + for(i = 1; i <= 5; i++) { + ListInsert(&L, i, 2 * i); + } + + printf("插入前：L = "); + ListTraverse(L, PrintElem); + + printf("将元素\"5\"插入到顺序表中...\n"); + Algo_2_11(&L, 5); + + printf("插入后：L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// 将x插入到递增序列va中 +Status Algo_2_11(SqList* va, ElemType x) { + int i, j; + ElemType* newbase; + + // 确保顺序表存在 + if(va == NULL || va->elem == NULL) { + return ERROR; + } + + // 若存储空间已满，需开辟新空间 + if((*va).length == (*va).listsize) { + newbase = (ElemType*) realloc((*va).elem, ((*va).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + exit(OVERFLOW); + } + + (*va).elem = newbase; + (*va).listsize += LISTINCREMENT; + } + + // 查找顺序表中首个大于元素x的元素位序，这个位序就是x需要插入的位置 + i = LocateElem(*va, x, CmpGreater); + if(i == 0) { + // 需要插入到顺序表最后 + i = (*va).length + 1; + } + + // 元素后移，腾出位置。注意j是位序，减1之后才是索引 + for(j=(*va).length + 1; j>i; j--){ + (*va).elem[j-1] = (*va).elem[j-2]; + } + + (*va).elem[j-1] = x; + (*va).length++; + + return OK; +} + +// 判断data>e是否成立 +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.11/CMakeLists.txt b/CLion/ExerciseBook/02.11/CMakeLists.txt new file mode 100644 index 0000000..8acae15 --- /dev/null +++ b/CLion/ExerciseBook/02.11/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.11 SqList.h SqList.c 02.11.c) +target_link_libraries(02.11 Scanf_lib) diff --git a/CLion/ExerciseBook/02.11/SqList.c b/CLion/ExerciseBook/02.11/SqList.c new file mode 100644 index 0000000..8b520e1 --- /dev/null +++ b/CLion/ExerciseBook/02.11/SqList.c @@ -0,0 +1,142 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * ████████ 算法2.6 ████████ + * + * 查找 + * + * 返回顺序表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // 确保顺序表结构存在 + if(L.elem == NULL) { + return ERROR; + } + + /* + * i的初值为第1个元素的位序 + * + * 其实，更自然的写法是将i初始化为第1个元素的索引 + * 但由于教材中是按位序计数的，所以这里仍写作位序 + */ + i = 1; + + // p的初值为第1个元素的存储位置 + p = L.elem; + + // 遍历顺序表 + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.11/SqList.h b/CLion/ExerciseBook/02.11/SqList.h new file mode 100644 index 0000000..34d50a5 --- /dev/null +++ b/CLion/ExerciseBook/02.11/SqList.h @@ -0,0 +1,74 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * ████████ 算法2.6 ████████ + * + * 查找 + * + * 返回顺序表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.12/02.12.c b/CLion/ExerciseBook/02.12/02.12.c new file mode 100644 index 0000000..f4fe844 --- /dev/null +++ b/CLion/ExerciseBook/02.12/02.12.c @@ -0,0 +1,86 @@ +#include +#include "SqList.h" //**▲02 线性表**// + +/* + * 题2.12 + * + * 比较顺序表大小，比较策略是从左向右遍历两个顺序表， + * 遇到首对不同的元素时，根据该元素的大小关系，确定顺序表的大小关系 + * + * 返回值是-1、0、1，分别代表AB + */ +int Algo_2_12(SqList A, SqList B); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + int i, mark; + SqList A, B; + + int a[7] = {1, 2, 3, 4, 5, 9, 12}; + int b[7] = {1, 2, 3, 4, 5, 11, 12}; + + // 初始化 + InitList(&A); + InitList(&B); + + // 赋值 + for(i = 1; i <= 7; i++) { + ListInsert(&A, i, a[i - 1]); + ListInsert(&B, i, b[i - 1]); + } + + printf("A = "); + ListTraverse(A, PrintElem); + + printf("B = "); + ListTraverse(B, PrintElem); + + mark = Algo_2_12(A, B); + if(mark < 0) { + printf("==> A 1) { + printf("==> A>B\n"); + } else { + printf("A==B\n"); + } + + return 0; +} + + +// 比较顺序表大小 +int Algo_2_12(SqList A, SqList B) { + int i = 0; + + // 扫描顺序表A和B + while(i < A.length && i < B.length) { + if(A.elem[i] > B.elem[i]) { + return 1; + } else if(A.elem[i] < B.elem[i]) { + return -1; + } else { + i++; //相等时比较下一元素 + } + } + + // 如果A还有剩余，A大 + if(i < A.length) { + return 1; + + // 如果B还有剩余，B大 + } else if(i < B.length) { + return -1; + + // 如果同时扫描完，相等 + } else { + return 0; + } +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.12/CMakeLists.txt b/CLion/ExerciseBook/02.12/CMakeLists.txt new file mode 100644 index 0000000..3aa0875 --- /dev/null +++ b/CLion/ExerciseBook/02.12/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.12 SqList.h SqList.c 02.12.c) +target_link_libraries(02.12 Scanf_lib) diff --git a/CLion/ExerciseBook/02.12/SqList.c b/CLion/ExerciseBook/02.12/SqList.c new file mode 100644 index 0000000..ec36b00 --- /dev/null +++ b/CLion/ExerciseBook/02.12/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.12/SqList.h b/CLion/ExerciseBook/02.12/SqList.h new file mode 100644 index 0000000..a46af33 --- /dev/null +++ b/CLion/ExerciseBook/02.12/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.13/02.13.c b/CLion/ExerciseBook/02.13/02.13.c new file mode 100644 index 0000000..db5a6f4 --- /dev/null +++ b/CLion/ExerciseBook/02.13/02.13.c @@ -0,0 +1,60 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.13 + * + * 寻找元素x在L中的位置。 + * 如果返回0，则说明x不存在。 + */ +int Algo_2_13(LinkList L, ElemType x); + +// 判断data==e是否成立 +Status Equals(ElemType data, ElemType e); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // 初始化顺序表 + InitList(&L); + + // 填充值 + for(i = 1; i <= 10; i++) { + ListInsert(L, i, 2 * i); + } + + // 输出顺序表 + printf("L = "); + ListTraverse(L, PrintElem); + + printf("元素 \"12\" 在链表L中的位置为 %d \n", Algo_2_13(L, 12)); + + return 0; +} + + +// 寻找元素x在L中的位置 +int Algo_2_13(LinkList L, ElemType x) { + // 直接调用链表的查找函数 + return LocateElem(L, x, Equals); +} + +// 判断data==e是否成立 +Status Equals(ElemType data, ElemType e) { + if(data == e) { + return TRUE; + } else { + return FALSE; + } +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.13/CMakeLists.txt b/CLion/ExerciseBook/02.13/CMakeLists.txt new file mode 100644 index 0000000..04c3b9d --- /dev/null +++ b/CLion/ExerciseBook/02.13/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.13 LinkList.h LinkList.c 02.13.c) +target_link_libraries(02.13 Scanf_lib) diff --git a/CLion/ExerciseBook/02.13/LinkList.c b/CLion/ExerciseBook/02.13/LinkList.c new file mode 100644 index 0000000..63df088 --- /dev/null +++ b/CLion/ExerciseBook/02.13/LinkList.c @@ -0,0 +1,125 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 查找 + * + * 返回链表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 1; // i的初值为第1个元素的位序 + p = L->next; // p的初值为第1个元素的指针 + + while(p != NULL && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != NULL) { + return i; + } else { + return 0; + } +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.13/LinkList.h b/CLion/ExerciseBook/02.13/LinkList.h new file mode 100644 index 0000000..d950387 --- /dev/null +++ b/CLion/ExerciseBook/02.13/LinkList.h @@ -0,0 +1,68 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * 查找 + * + * 返回链表中首个与e满足Compare关系的元素位序。 + * 如果不存在这样的元素，则返回0。 + * + *【备注】 + * 元素e是Compare函数第二个形参 + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.14/02.14.c b/CLion/ExerciseBook/02.14/02.14.c new file mode 100644 index 0000000..493a552 --- /dev/null +++ b/CLion/ExerciseBook/02.14/02.14.c @@ -0,0 +1,46 @@ +#include +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.14 + * + * 获取顺序表L的长度。 + */ +int Algo_2_14(LinkList L); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // 初始化顺序表 + InitList(&L); + + // 填充值 + for(i = 1; i <= 15; i++) { + ListInsert(L, i, 2 * i); + } + + // 输出顺序表 + printf("L = "); + ListTraverse(L, PrintElem); + + printf("链表L的长度为 %d \n", Algo_2_14(L)); + + return 0; +} + + +// 获取顺序表L的长度 +int Algo_2_14(LinkList L) { + // 直接调用链表的计数函数 + return ListLength(L); +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.14/CMakeLists.txt b/CLion/ExerciseBook/02.14/CMakeLists.txt new file mode 100644 index 0000000..c0fb37d --- /dev/null +++ b/CLion/ExerciseBook/02.14/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.14 LinkList.h LinkList.c 02.14.c) +target_link_libraries(02.14 Scanf_lib) diff --git a/CLion/ExerciseBook/02.14/LinkList.c b/CLion/ExerciseBook/02.14/LinkList.c new file mode 100644 index 0000000..f391ae6 --- /dev/null +++ b/CLion/ExerciseBook/02.14/LinkList.c @@ -0,0 +1,118 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 计数 + * + * 返回链表包含的有效元素的数量。 + */ +int ListLength(LinkList L) { + LinkList p; + int i; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 0; + p = L->next; + + // 遍历所有结点 + while(p != NULL) { + i++; + p = p->next; + } + + return i; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.14/LinkList.h b/CLion/ExerciseBook/02.14/LinkList.h new file mode 100644 index 0000000..b629505 --- /dev/null +++ b/CLion/ExerciseBook/02.14/LinkList.h @@ -0,0 +1,64 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * 计数 + * + * 返回链表包含的有效元素的数量。 + */ +int ListLength(LinkList L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.15/02.15.c b/CLion/ExerciseBook/02.15/02.15.c new file mode 100644 index 0000000..c365487 --- /dev/null +++ b/CLion/ExerciseBook/02.15/02.15.c @@ -0,0 +1,90 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.15 + * + * 连接ha和hb，存储到hc中。 + */ +Status Algo_2_15(LinkList* ha, LinkList* hb, LinkList* hc); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList ha, hb, hc = NULL; + int i; + + // 初始化 + InitList(&ha); + InitList(&hb); + + // 赋值 + for(i = 1; i <= 5; i++) { + ListInsert(ha, i, 2 * i - 1); + ListInsert(hb, i, 2 * i); + } + + printf("ha = "); + ListTraverse(ha, PrintElem); + + printf("hb = "); + ListTraverse(hb, PrintElem); + + // 连接ha和hb + Algo_2_15(&ha, &hb, &hc); + + printf("hc = "); + ListTraverse(hc, PrintElem); + + return 0; +} + + +// 连接ha和hb，存储到hc中 +Status Algo_2_15(LinkList* ha, LinkList* hb, LinkList* hc) { + LinkList pa, pb; + + *hc = NULL; + + // 确保ha和hb都存在 + if(ha == NULL || *ha == NULL || hb == NULL || *hb == NULL) { + return ERROR; + } + + pa = *ha; + pb = *hb; + + // 为了提高效率，需要先遍历共同的部分 + while(pa->next != NULL && pb->next != NULL) { + pa = pa->next; + pb = pb->next; + } + + // 如果ha已经遍历到头了，且hb有剩余 + if(pa->next == NULL && pb->next != NULL) { + *hc = *ha; + pa->next = (*hb)->next; + free(*hb); + } + + // 如果hb已经遍历到头了，ha可能有剩余，也可能没有 + if(pb->next == NULL) { + *hc = *hb; + pb->next = (*ha)->next; + free(*ha); + } + + // 销毁了ha/hb的头结点 + *ha = NULL; + *hb = NULL; + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.15/CMakeLists.txt b/CLion/ExerciseBook/02.15/CMakeLists.txt new file mode 100644 index 0000000..67cdb15 --- /dev/null +++ b/CLion/ExerciseBook/02.15/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.15 LinkList.h LinkList.c 02.15.c) +target_link_libraries(02.15 Scanf_lib) diff --git a/CLion/ExerciseBook/02.15/LinkList.c b/CLion/ExerciseBook/02.15/LinkList.c new file mode 100644 index 0000000..589e298 --- /dev/null +++ b/CLion/ExerciseBook/02.15/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.15/LinkList.h b/CLion/ExerciseBook/02.15/LinkList.h new file mode 100644 index 0000000..03a96e2 --- /dev/null +++ b/CLion/ExerciseBook/02.15/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.16-02.18/02.16-02.18.c b/CLion/ExerciseBook/02.16-02.18/02.16-02.18.c new file mode 100644 index 0000000..d9e1826 --- /dev/null +++ b/CLion/ExerciseBook/02.16-02.18/02.16-02.18.c @@ -0,0 +1,296 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表【没有】头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 题2.16 + * + * 删除la中第i个位置起的len个元素，并将其添加到lb第j个位置之前。 + */ +Status Algo_2_16(LinkList* la, LinkList* lb, int i, int j, int len); + +/* + * 题2.17 + * + * 将元素b插入到链表L第i个位置上，i是元素的位序，从1开始计数。。 + */ +Status Algo_2_17(LinkList* L, int i, ElemType b); + +/* + * 题2.18 + * + * 删除链表L的第i个结点，i是元素的位序，从1开始计数。 + */ +Status Algo_2_18(LinkList* L, int i); + +// 初始化无头结点的链表L +void InitList(LinkList* L); + +// 输出无头结点的链表中的元素 +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + int i; + LinkList la, lb; + + InitList(&la); + InitList(&lb); + + printf("████████ 题 2.17 验证...\n"); + for(i = 1; i <= 10; i++) { + Algo_2_17(&la, i, 2 * i - 1); + Algo_2_17(&lb, i, 2 * i); + } + printf("█ 创建无头结点链表：\n"); + printf("█ la = "); + Output(la); + printf("█ lb = "); + Output(lb); + PressEnterToContinue(); + + printf("████████ 题 2.16 验证...\n"); + printf("█ 将la中从第2个结点起的5个结点插入到lb的第6个结点之前...\n"); + Algo_2_16(&la, &lb, 2, 6, 5); + printf("█ la = "); + Output(la); + printf("█ lb = "); + Output(lb); + PressEnterToContinue(); + + printf("████████ 题 2.18 验证...\n"); + printf("█ 删除lb第6个结点起的5个结点...\n"); + for(i = 1; i <= 5; i++) { + Algo_2_18(&lb, 6); + } + printf("█ 删除完成后：lb = "); + Output(lb); + + return 0; +} + + +// 删除la中第i个位置起的len个元素，并将其添加到lb第j个位置之前 +Status Algo_2_16(LinkList* la, LinkList* lb, int i, int j, int len) { + LinkList p; // 指向la中第i-1个结点 + LinkList q; // 指向la中第i+len-1个结点 + LinkList r; // 指向q后面的结点 + LinkList s; // 指向lb中第j-1个结点 + int k; + + if(i <= 0 || j <= 0 || len <= 0) { + return ERROR; + } + + // 确保la中有结点可摘 + if(la == NULL || *la == NULL) { + return ERROR; + } + + + // 确定p的位置 + k = 1; + p = *la; + + if(i == 1) { + p = NULL; + } else { + // 查找la中第i-1个结点，且保证它后继存在 + while(p->next != NULL && k < i - 1) { + ++k; + p = p->next; + } + + // 未找到合适的位置 + if(p->next == NULL) { + return ERROR; + } + } + + + // 确定q的位置 + if(p == NULL) { + q = *la; + } else { + q = p->next; + } + k = i; + + while(q != NULL && k < i + len - 1) { + ++k; + q = q->next; + } + + if(q == NULL) { + return ERROR; + } + + // 确定r的位置 + r = q->next; + + + if(lb == NULL) { + return ERROR; + } + + // 确定s的位置 + k = 1; + s = *lb; + + // 插入到lb第一个位置之前 + if(j == 1) { + q->next = *lb; + + if(p == NULL) { + *lb = *la; + *la = r; + } else { + *lb = p->next; + p->next = r; + } + } else { + // 查找lb中第j-1个结点，且保证它后继存在 + while(s->next != NULL && k < j - 1) { + ++k; + s = s->next; + } + + // 未找到合适的位置 + if(s->next == NULL) { + return ERROR; + } + + q->next = s->next; + + if(p == NULL) { + *lb = *la; + *la = r; + } else { + s->next = p->next; + p->next = r; + } + } + + return OK; +} + +// 将元素b插入到链表L第i个位置上 +Status Algo_2_17(LinkList* L, int i, ElemType b) { + LinkList p, s; + int j; + + if(L == NULL) { + return ERROR; + } + + // i从1开始计数 + if(i <= 0) { + return ERROR; + } + + // 创建新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = b; + + j = 1; + p = *L; + + // 特殊情形 + if(i == 1) { + s->next = p; + *L = s; + } else { + // 查找第i-1个结点，且保证它自身存在 + while(p != NULL && j < i - 1) { + ++j; + p = p->next; + } + + // 未找到合适的位置 + if(p == NULL) { + return ERROR; + } + + s->next = p->next; + p->next = s; + } + + return OK; +} + +// 删除链表L的第i个结点 +Status Algo_2_18(LinkList* L, int i) { + LinkList p, q; + int j; + + // 确保有结点可删除 + if(L == NULL || *L == NULL) { + return ERROR; + } + + // i从1开始计数 + if(i <= 0) { + return ERROR; + } + + j = 1; + p = *L; + + // 特殊情形 + if(i == 1) { + *L = p->next; + free(p); + } else { + // 查找第i-1个结点，且保证它后继存在 + while(p->next != NULL && j < i - 1) { + ++j; + p = p->next; + } + + // 未找到合适的位置 + if(p->next == NULL) { + return ERROR; + } + + q = p->next; + p->next = q->next; + free(q); + } + + return OK; +} + +// 初始化无头结点的链表L +void InitList(LinkList* L) { + *L = NULL; +} + +// 输出无头结点的链表中的元素 +void Output(LinkList L) { + while(L != NULL) { + printf("%2d ", L->data); + L = L->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.16-02.18/CMakeLists.txt b/CLion/ExerciseBook/02.16-02.18/CMakeLists.txt new file mode 100644 index 0000000..38097b6 --- /dev/null +++ b/CLion/ExerciseBook/02.16-02.18/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.16-02.18 02.16-02.18.c) +target_link_libraries(02.16-02.18 Scanf_lib) diff --git a/CLion/ExerciseBook/02.19-02.20/02.19-02.20.c b/CLion/ExerciseBook/02.19-02.20/02.19-02.20.c new file mode 100644 index 0000000..31eeb31 --- /dev/null +++ b/CLion/ExerciseBook/02.19-02.20/02.19-02.20.c @@ -0,0 +1,194 @@ +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.19———方法一 + * + * 删除递增线性表中元素值介于(mink, maxk)之间的结点。 + */ +Status Algo_2_19_1(LinkList L, int mink, int maxk); + +/* + * 题2.19———方法二 + * + * 删除递增线性表中元素值介于(mink, maxk)之间的结点。 + */ +Status Algo_2_19_2(LinkList L, int mink, int maxk); + +/* + * 题2.20 + * + * 对非递减线性表去重：对于重复元素，仅保留一个。 + */ +Status Algo_2_20(LinkList L); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int mink1, mink2, maxk1, maxk2, i; + int a[] = {1, 2, 2, 3, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 9, 9, 10, 11, 12, 12}; + + mink1 = 2; + maxk1 = 4; + + mink2 = 5; + maxk2 = 8; + + InitList(&L); + + for(i = 1; i <= 20; i++) { + ListInsert(L, i, a[i - 1]); + } + + printf("█ L = "); + ListTraverse(L, PrintElem); + + printf("████████ 题 2.19 验证...\n"); + printf("█ 删除 (%d, %d) 范围内的元素之后：", mink1, maxk1); + Algo_2_19_1(L, mink1, maxk1); + printf("L = "); + ListTraverse(L, PrintElem); + + printf("█ 删除 (%d, %d) 范围内的元素之后：", mink2, maxk2); + Algo_2_19_2(L, mink2, maxk2); + printf("L = "); + ListTraverse(L, PrintElem); + + printf("████████ 题 2.20 验证...\n"); + printf("█ 对非递减链表去重之后："); + Algo_2_20(L); + printf("L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// 删除递增线性表中元素值介于(mink, maxk)之间的结点 +Status Algo_2_19_1(LinkList L, int mink, int maxk) { + LinkList p, q; + int flag; // 用来提高效率 + + // 确保链表存在 + if(L == NULL) { + return ERROR; + } + + // 范围设定错误 + if(mink >= maxk) { + return ERROR; + } + + // 链表为空，直接返回 + if(L->next == NULL) { + return OK; + } + + p = L; // 指向头结点 + flag = 0; // 标记未遇到(mink, maxk)范围内的元素 + + while(p->next != NULL) { + q = p->next; + + // 遇到需要删除的结点 + if(q->data > mink && q->data < maxk) { + // 标记遇到了(mink, maxk)范围内的元素 + flag = 1; + p->next = q->next; + free(q); + } else { + // 说明剩余元素均>=maxk，无需再遍历 + if(flag == 1) { + break; + } + p = q; + } + } + + return OK; +} + +// 删除递增线性表中元素值介于(mink, maxk)之间的结点 +Status Algo_2_19_2(LinkList L, int mink, int maxk) { + LinkList p, q; + + // 确保链表存在 + if(L == NULL) { + return ERROR; + } + + // 范围设定错误 + if(mink >= maxk) { + return ERROR; + } + + // 链表为空，直接返回 + if(L->next == NULL) { + return OK; + } + + p = L; // 指向头结点 + + // 查找下限 + while(p->next != NULL && p->next->data <= mink) { + p = p->next; + } + + // 遍历完成 + if(p->next == NULL) { + return OK; + } + + // 查找上限，删除(mink, maxk)之间的部分 + while(p->next != NULL && p->next->data < maxk) { + q = p->next; + p->next = q->next; + free(q); + } + + return OK; +} + +// 对非递减线性表去重：对于重复元素，仅保留一个 +Status Algo_2_20(LinkList L) { + LinkList p, q; + + // 确保链表存在 + if(L == NULL) { + return ERROR; + } + + // 链表为空，直接返回 + if(L->next == NULL) { + return OK; + } + + // 指向第1个元素 + p = L->next; + + while(p->next != NULL) { + q = p->next; + + // 遇到了重复元素，则需要删除一个 + if(p->data == q->data) { + p->next = q->next; + free(q); + + // 如果是不同的元素，则p前进一步 + } else { + p = q; + } + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.19-02.20/CMakeLists.txt b/CLion/ExerciseBook/02.19-02.20/CMakeLists.txt new file mode 100644 index 0000000..1e023f2 --- /dev/null +++ b/CLion/ExerciseBook/02.19-02.20/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.19-02.20 LinkList.h LinkList.c 02.19-02.20.c) +target_link_libraries(02.19-02.20 Scanf_lib) diff --git a/CLion/ExerciseBook/02.19-02.20/LinkList.c b/CLion/ExerciseBook/02.19-02.20/LinkList.c new file mode 100644 index 0000000..589e298 --- /dev/null +++ b/CLion/ExerciseBook/02.19-02.20/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.19-02.20/LinkList.h b/CLion/ExerciseBook/02.19-02.20/LinkList.h new file mode 100644 index 0000000..03a96e2 --- /dev/null +++ b/CLion/ExerciseBook/02.19-02.20/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.21/02.21.c b/CLion/ExerciseBook/02.21/02.21.c new file mode 100644 index 0000000..4ae8ee6 --- /dev/null +++ b/CLion/ExerciseBook/02.21/02.21.c @@ -0,0 +1,63 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "SqList.h" //**▲02 线性表**// + +/* + * 题2.21 + * + * 顺序表逆置。 + */ +Status Algo_2_21(SqList L); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // 准备测试数据 + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(&L, i, i); + } + + printf("顺序：L = "); + ListTraverse(L, PrintElem); + + Algo_2_21(L); + + printf("逆置：L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// 顺序表逆置 +Status Algo_2_21(SqList L) { + int i, mid; + ElemType tmp; + + // 确保顺序表存在 + if(L.elem == NULL) { + return ERROR; + } + + // 只需要遍历前一半的元素即可 + mid = L.length / 2; + + for(i = 1; i <= mid; i++) { + tmp = L.elem[i - 1]; + L.elem[i - 1] = L.elem[L.length - i]; + L.elem[L.length - i] = tmp; + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/CLion/ExerciseBook/02.21/CMakeLists.txt b/CLion/ExerciseBook/02.21/CMakeLists.txt new file mode 100644 index 0000000..bbd6d0e --- /dev/null +++ b/CLion/ExerciseBook/02.21/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.21 SqList.h SqList.c 02.21.c) +target_link_libraries(02.21 Scanf_lib) diff --git a/CLion/ExerciseBook/02.21/SqList.c b/CLion/ExerciseBook/02.21/SqList.c new file mode 100644 index 0000000..ec36b00 --- /dev/null +++ b/CLion/ExerciseBook/02.21/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.21/SqList.h b/CLion/ExerciseBook/02.21/SqList.h new file mode 100644 index 0000000..d0b676e --- /dev/null +++ b/CLion/ExerciseBook/02.21/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.22/02.22.c b/CLion/ExerciseBook/02.22/02.22.c new file mode 100644 index 0000000..8f090b0 --- /dev/null +++ b/CLion/ExerciseBook/02.22/02.22.c @@ -0,0 +1,62 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.22 + * + * 链表逆置。 + */ +Status Algo_2_22(LinkList L); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // 准备测试数据 + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(L, i, i); + } + + printf("顺序：L = "); + ListTraverse(L, PrintElem); + + Algo_2_22(L); + + printf("逆置：L = "); + ListTraverse(L, PrintElem); + + return 0; +} + +// 链表逆置 +Status Algo_2_22(LinkList L) { + LinkList p, q; + + // 确保链表存在 + if(L==NULL) { + return ERROR; + } + + p = L->next; + L->next = NULL; + + // 头插法 + while(p!=NULL){ + q = p->next; + p->next = L->next; + L->next = p; + p = q; + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/CLion/ExerciseBook/02.22/CMakeLists.txt b/CLion/ExerciseBook/02.22/CMakeLists.txt new file mode 100644 index 0000000..c1c2d3b --- /dev/null +++ b/CLion/ExerciseBook/02.22/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.22 LinkList.h LinkList.c 02.22.c) +target_link_libraries(02.22 Scanf_lib) diff --git a/CLion/ExerciseBook/02.22/LinkList.c b/CLion/ExerciseBook/02.22/LinkList.c new file mode 100644 index 0000000..589e298 --- /dev/null +++ b/CLion/ExerciseBook/02.22/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.22/LinkList.h b/CLion/ExerciseBook/02.22/LinkList.h new file mode 100644 index 0000000..ce0e7f2 --- /dev/null +++ b/CLion/ExerciseBook/02.22/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.23/02.23.c b/CLion/ExerciseBook/02.23/02.23.c new file mode 100644 index 0000000..038f66b --- /dev/null +++ b/CLion/ExerciseBook/02.23/02.23.c @@ -0,0 +1,147 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.23——方法一：将La插入到Lb中 + * + * 合并两个单链表。 + * 合并完成后，将La和Lb置空，但不销毁。 + */ +Status Algo_2_23_1(LinkList La, LinkList Lb, LinkList* Lc); + +/* + * 题2.23——方法二：将La和Lb中的元素交替插入到Lc中 + * + * 合并两个单链表。 + * 合并完成后，将La和Lb置空，但不销毁。 + */ +Status Algo_2_23_2(LinkList La, LinkList Lb, LinkList* Lc); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + // 准备测试数据 + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 5; i++) { + ListInsert(La, i, 2 * i - 1); + ListInsert(Lb, i, 2 * i); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 合并方法测试 +// Algo_2_23_1(La, Lb, &Lc); + Algo_2_23_2(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +// 合并两个单链表 +Status Algo_2_23_1(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList p, pb; + + // 确保La和Lb存在 + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + pb = Lb; + + while(La->next != NULL && pb->next != NULL) { + // 从La中摘下结点 + p = La->next; + La->next = p->next; + + // 将La中摘下的结点插入到Lb中 + p->next = pb->next; + pb->next = p; + + // 前进到原Lb中下一个结点的位置 + pb = pb->next->next; + } + + // 如果La有剩余，需要将其全部链接到Lb的尾部 + if(pb->next == NULL && La->next != NULL) { + pb->next = La->next; + La->next = NULL; + } + + InitList(Lc); + + (*Lc)->next = Lb->next; + Lb->next = NULL; + + return OK; +} + +// 合并两个单链表 +Status Algo_2_23_2(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList p, pc; + int flag; // 指挥插入La中的元素还是插入Lb中的元素 + + // 确保La和Lb存在 + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + InitList(Lc); + + flag = 0; + pc = *Lc; + + while(La->next!=NULL && Lb->next!=NULL){ + // 需要插入La中的元素 + if(flag==0) { + // 摘下La中的元素 + p = La->next; + La->next = p->next; + + flag = 1; + } else { + // 摘下La中的元素 + p = Lb->next; + Lb->next = p->next; + + flag = 0; + } + + // 将摘下的元素插入到Lc + pc->next = p; + pc = pc->next; + } + + // 如果Lb可能有剩余 + if(La->next==NULL) { + // 摘下Lb中的元素 + p = Lb->next; + Lb->next = NULL; + pc->next = p; + + // 如果La有剩余 + } else { + // 摘下La中的元素 + p = La->next; + La->next = NULL; + pc->next = p; + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.23/CMakeLists.txt b/CLion/ExerciseBook/02.23/CMakeLists.txt new file mode 100644 index 0000000..0335c1c --- /dev/null +++ b/CLion/ExerciseBook/02.23/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.23 LinkList.h LinkList.c 02.23.c) +target_link_libraries(02.23 Scanf_lib) diff --git a/CLion/ExerciseBook/02.23/LinkList.c b/CLion/ExerciseBook/02.23/LinkList.c new file mode 100644 index 0000000..589e298 --- /dev/null +++ b/CLion/ExerciseBook/02.23/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.23/LinkList.h b/CLion/ExerciseBook/02.23/LinkList.h new file mode 100644 index 0000000..ce0e7f2 --- /dev/null +++ b/CLion/ExerciseBook/02.23/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.24/02.24.c b/CLion/ExerciseBook/02.24/02.24.c new file mode 100644 index 0000000..3ed2d12 --- /dev/null +++ b/CLion/ExerciseBook/02.24/02.24.c @@ -0,0 +1,94 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.24 + * + * 归并两个递增单链表为一个递减单链表。 + * 归并策略是：逐个摘下La和Lb中的元素，并使用头插法插入到Lc中 + * 归并完成后，将原表置空，但不销毁。 + */ +Status Algo_2_24(LinkList La, LinkList Lb, LinkList* Lc); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + // 准备测试数据 + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 5; i++) { + ListInsert(La, i, 2 * i - 1); + ListInsert(Lb, i, 2 * i); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 归并方法测试 + Algo_2_24(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +// 归并两个递增单链表为一个递减单链表 +Status Algo_2_24(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList pa, pb; + + // 确保La和Lb存在 + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + InitList(Lc); + + // 遍历La和Lb + while(La->next!=NULL && Lb->next!=NULL){ + pa = La->next; + pb = Lb->next; + + // 摘下La和Lb中较小的元素 + if(pa->data<=pb->data) { + La->next = pa->next; + pa->next = (*Lc)->next; + (*Lc)->next = pa; + } else { + Lb->next = pb->next; + pb->next = (*Lc)->next; + (*Lc)->next = pb; + } + } + + // 如果La还有剩余，将La中剩余元素插入到Lc中 + while(La->next!=NULL){ + pa = La->next; + La->next = pa->next; + pa->next = (*Lc)->next; + (*Lc)->next = pa; + } + + // 如果Lb还有剩余，将Lb中剩余元素插入到Lc中 + while(Lb->next!=NULL){ + pb = Lb->next; + Lb->next = pb->next; + pb->next = (*Lc)->next; + (*Lc)->next = pb; + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.24/CMakeLists.txt b/CLion/ExerciseBook/02.24/CMakeLists.txt new file mode 100644 index 0000000..5a5936e --- /dev/null +++ b/CLion/ExerciseBook/02.24/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.24 LinkList.h LinkList.c 02.24.c) +target_link_libraries(02.24 Scanf_lib) diff --git a/CLion/ExerciseBook/02.24/LinkList.c b/CLion/ExerciseBook/02.24/LinkList.c new file mode 100644 index 0000000..589e298 --- /dev/null +++ b/CLion/ExerciseBook/02.24/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.24/LinkList.h b/CLion/ExerciseBook/02.24/LinkList.h new file mode 100644 index 0000000..ce0e7f2 --- /dev/null +++ b/CLion/ExerciseBook/02.24/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.25/02.25.c b/CLion/ExerciseBook/02.25/02.25.c new file mode 100644 index 0000000..c43158a --- /dev/null +++ b/CLion/ExerciseBook/02.25/02.25.c @@ -0,0 +1,82 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "SqList.h" //**▲02 线性表**// + +/* + * 题2.25 + * + * 求交集：C=A∩B。 + */ +Status Algo_2_25(SqList La, SqList Lb, SqList* Lc); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // 准备测试数据 + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 求交集 + Algo_2_25(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 求交集：C=A∩B +Status Algo_2_25(SqList La, SqList Lb, SqList* Lc) { + int i, j, k; + + // 确保La和Lb存在 + if(La.elem == NULL || Lb.elem == NULL) { + return ERROR; + } + + InitList(Lc); + + i = j = 0; // 遍历La和Lb + k = 0; // 遍历Lc + + // 只遍历La和Lb的共同部分就行 + while(i < La.length && j < Lb.length) { + if(La.elem[i] < Lb.elem[j]) { + i++; + } else if(La.elem[i] > Lb.elem[j]) { + j++; + // 如果La和Lb中的元素相等 + } else { + // Lc中元素可能重复 + ListInsert(Lc, k+1, La.elem[i]); + k++; + i++; + j++; + } + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.25/CMakeLists.txt b/CLion/ExerciseBook/02.25/CMakeLists.txt new file mode 100644 index 0000000..5593dbc --- /dev/null +++ b/CLion/ExerciseBook/02.25/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.25 SqList.h SqList.c 02.25.c) +target_link_libraries(02.25 Scanf_lib) diff --git a/CLion/ExerciseBook/02.25/SqList.c b/CLion/ExerciseBook/02.25/SqList.c new file mode 100644 index 0000000..ec36b00 --- /dev/null +++ b/CLion/ExerciseBook/02.25/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.25/SqList.h b/CLion/ExerciseBook/02.25/SqList.h new file mode 100644 index 0000000..23a33a2 --- /dev/null +++ b/CLion/ExerciseBook/02.25/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.26/02.26.c b/CLion/ExerciseBook/02.26/02.26.c new file mode 100644 index 0000000..5615f32 --- /dev/null +++ b/CLion/ExerciseBook/02.26/02.26.c @@ -0,0 +1,89 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.26 + * + * 求交集：C=A∩B。 + */ +Status Algo_2_26(LinkList La, LinkList Lb, LinkList* Lc); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // 准备测试数据 + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 求交集 + Algo_2_26(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 求交集：C=A∩B +Status Algo_2_26(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList pa, pb, pc, s; + + // 确保La和Lb存在 + if(La == NULL || Lb == NULL) { + return ERROR; + } + + InitList(Lc); + + pa = La->next; + pb = Lb->next; + pc = *Lc; + + // 只遍历La和Lb的共同部分就行 + while(pa != NULL && pb != NULL) { + if(pa->data < pb->data) { + pa = pa->next; + } else if(pa->data > pb->data) { + pb = pb->next; + } else { + // Lc中元素可能重复 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = pa->data; + s->next = NULL; + + pc->next = s; + + pc = pc->next; + + pa = pa->next; + pb = pb->next; + } + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.26/CMakeLists.txt b/CLion/ExerciseBook/02.26/CMakeLists.txt new file mode 100644 index 0000000..6a2169c --- /dev/null +++ b/CLion/ExerciseBook/02.26/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.26 LinkList.h LinkList.c 02.26.c) +target_link_libraries(02.26 Scanf_lib) diff --git a/CLion/ExerciseBook/02.26/LinkList.c b/CLion/ExerciseBook/02.26/LinkList.c new file mode 100644 index 0000000..589e298 --- /dev/null +++ b/CLion/ExerciseBook/02.26/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.26/LinkList.h b/CLion/ExerciseBook/02.26/LinkList.h new file mode 100644 index 0000000..ce0e7f2 --- /dev/null +++ b/CLion/ExerciseBook/02.26/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.27/02.27.c b/CLion/ExerciseBook/02.27/02.27.c new file mode 100644 index 0000000..03a294d --- /dev/null +++ b/CLion/ExerciseBook/02.27/02.27.c @@ -0,0 +1,96 @@ +#include +#include "SqList.h" //**▲02 线性表**// + +/* + * 题2.27 + * + * 求交集：C=A∩B。 + * 不允许C中的元素重复，且C会利用A原有的空间，A被销毁。 + */ +SqList Algo_2_27(SqList* La, SqList Lb); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // 准备测试数据 + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 求交集 + Lc = Algo_2_27(&La, Lb); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 求交集：C=A∩B +SqList Algo_2_27(SqList* La, SqList Lb) { + int i, j, k; + SqList Lc; + + // 确保La和Lb存在 + if((*La).elem == NULL || Lb.elem == NULL) { + Lc.elem = NULL; + Lc.length = 0; + Lc.listsize = 0; + return Lc; + } + + i = j = 0; // 遍历La和Lb + k = 0; // 遍历Lc + + Lc.elem = (*La).elem; + Lc.listsize = La->listsize; + + // 只遍历La和Lb的共同部分就行 + while(i < (*La).length && j < Lb.length) { + if((*La).elem[i] < Lb.elem[j]) { + i++; + } else if((*La).elem[i] > Lb.elem[j]) { + j++; + // 如果La和Lb中的元素相等 + } else { + // 确保Lc中的元素不重复 + if(k == 0 || Lc.elem[k - 1] != (*La).elem[i]) { + Lc.elem[k] = (*La).elem[i]; + k++; + } + + i++; + j++; + } + } + + // 销毁A，但其空间交给了C使用 + (*La).elem = NULL; + (*La).length = 0; + (*La).listsize = 0; + + Lc.length = k; + + return Lc; +} + +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.27/CMakeLists.txt b/CLion/ExerciseBook/02.27/CMakeLists.txt new file mode 100644 index 0000000..4f85e58 --- /dev/null +++ b/CLion/ExerciseBook/02.27/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.27 SqList.h SqList.c 02.27.c) +target_link_libraries(02.27 Scanf_lib) diff --git a/CLion/ExerciseBook/02.27/SqList.c b/CLion/ExerciseBook/02.27/SqList.c new file mode 100644 index 0000000..ec36b00 --- /dev/null +++ b/CLion/ExerciseBook/02.27/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.27/SqList.h b/CLion/ExerciseBook/02.27/SqList.h new file mode 100644 index 0000000..23a33a2 --- /dev/null +++ b/CLion/ExerciseBook/02.27/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.28/02.28.c b/CLion/ExerciseBook/02.28/02.28.c new file mode 100644 index 0000000..d209ba3 --- /dev/null +++ b/CLion/ExerciseBook/02.28/02.28.c @@ -0,0 +1,92 @@ +#include +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.28 + * + * 求交集：C=A∩B。 + * 不允许C中的元素重复，且C会利用A原有的空间，A被销毁。 + */ +LinkList Algo_2_28(LinkList* La, LinkList Lb); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // 准备测试数据 + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 求交集 + Lc = Algo_2_28(&La, Lb); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +LinkList Algo_2_28(LinkList* La, LinkList Lb) { + LinkList Lc; + LinkList pa, pb, pc, s; + + // 确保La和Lb存在 + if(La == NULL || *La == NULL || Lb == NULL) { + return NULL; + } + + pa = (*La)->next; + pb = Lb->next; + + Lc = *La; + Lc->next = NULL; + pc = Lc; + + // 只遍历La和Lb的共同部分就行 + while(pa != NULL && pb != NULL) { + if(pa->data < pb->data) { + s = pa; + pa = pa->next; + free(s); + } else if(pa->data > pb->data) { + pb = pb->next; + } else { + // 确保Lc中的元素不重复 + if(pc == Lc || pc->data != pa->data) { + pc->next = pa; + pc = pc->next; + } + + pa = pa->next; + pb = pb->next; + } + } + + pc->next = NULL; + + + *La = NULL; + + return Lc; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.28/CMakeLists.txt b/CLion/ExerciseBook/02.28/CMakeLists.txt new file mode 100644 index 0000000..9b7033f --- /dev/null +++ b/CLion/ExerciseBook/02.28/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.28 LinkList.h LinkList.c 02.28.c) +target_link_libraries(02.28 Scanf_lib) diff --git a/CLion/ExerciseBook/02.28/LinkList.c b/CLion/ExerciseBook/02.28/LinkList.c new file mode 100644 index 0000000..589e298 --- /dev/null +++ b/CLion/ExerciseBook/02.28/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.28/LinkList.h b/CLion/ExerciseBook/02.28/LinkList.h new file mode 100644 index 0000000..ce0e7f2 --- /dev/null +++ b/CLion/ExerciseBook/02.28/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.29/02.29.c b/CLion/ExerciseBook/02.29/02.29.c new file mode 100644 index 0000000..fb097f0 --- /dev/null +++ b/CLion/ExerciseBook/02.29/02.29.c @@ -0,0 +1,104 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "SqList.h" //**▲02 线性表**// + +/* + * 题2.29 + * + * A=A-B∩C。 + */ +Status Algo_2_29(SqList* La, SqList Lb, SqList Lc); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int b[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int c[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // 准备测试数据 + InitList(&La); + InitList(&Lb); + InitList(&Lc); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + ListInsert(&Lc, i, c[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + + // 处理后 + Algo_2_29(&La, Lb, Lc); + + printf("La = La-Lb∩Lc = "); + ListTraverse(La, PrintElem); + + return 0; +} + +// A=A-B∩C +Status Algo_2_29(SqList* La, SqList Lb, SqList Lc) { + int i, j, k, count; + + if(La==NULL || (*La).elem==NULL || Lb.elem==NULL || Lc.elem==NULL) { + return ERROR; + } + + i = j = k = 0; + count = 0; + + // 获取B和C的交集，然后将其从A中删除 + while(i < (*La).length && j < Lb.length && k < Lc.length) { + if(Lb.elem[j] < Lc.elem[k]) { + j++; + } else if(Lb.elem[j] > Lc.elem[k]) { + k++; + } else { + // 在A中查找交集元素 + while(i < (*La).length && (*La).elem[i] < Lb.elem[j]) { + (*La).elem[count] = (*La).elem[i]; + count++; + i++; + } + + // 跳过交集元素 + while(i < (*La).length && (*La).elem[i] == Lb.elem[j]) { + i++; + } + + // A还没有遍历完 + if(i < (*La).length) { + j++; + k++; + } + } + } + + // 将剩余的元素放到合适的位置 + while(i < (*La).length) { + (*La).elem[count] = (*La).elem[i]; + count++; + i++; + } + + (*La).length = count; + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/CLion/ExerciseBook/02.29/CMakeLists.txt b/CLion/ExerciseBook/02.29/CMakeLists.txt new file mode 100644 index 0000000..d81d5c2 --- /dev/null +++ b/CLion/ExerciseBook/02.29/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.29 SqList.h SqList.c 02.29.c) +target_link_libraries(02.29 Scanf_lib) diff --git a/CLion/ExerciseBook/02.29/SqList.c b/CLion/ExerciseBook/02.29/SqList.c new file mode 100644 index 0000000..ec36b00 --- /dev/null +++ b/CLion/ExerciseBook/02.29/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#include "SqList.h" + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L) { + // 分配指定容量的内存，如果分配失败，则返回NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + (*L).length = 0; // 初始化顺序表长度为0 + (*L).listsize = LIST_INIT_SIZE; // 顺序表初始内存分配量 + + return OK; // 初始化成功 +} + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // 确保顺序表结构存在 + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // i值越界 + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 若存储空间已满，则增加新空间 + if((*L).length >= (*L).listsize) { + // 基于现有空间扩容 + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 存储内存失败 + exit(OVERFLOW); + } + + // 新基址 + (*L).elem = newbase; + // 存的存储空间 + (*L).listsize += LISTINCREMENT; + } + + // q为插入位置 + q = &(*L).elem[i - 1]; + + // 1.右移元素，腾出位置 + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.插入e + *q = e; + + // 3.表长增1 + (*L).length++; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.29/SqList.h b/CLion/ExerciseBook/02.29/SqList.h new file mode 100644 index 0000000..23a33a2 --- /dev/null +++ b/CLion/ExerciseBook/02.29/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * 线性表的顺序存储结构（顺序表） + * + * 包含算法: 2.3、2.4、2.5、2.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 宏定义 */ +#define LIST_INIT_SIZE 100 // 顺序表存储空间的初始分配量 +#define LISTINCREMENT 10 // 顺序表存储空间的分配增量 + +/* 顺序表元素类型定义 */ +typedef int ElemType; + +/* + * 顺序表结构 + * + * 注：elem在使用前需要先为其分配内存，且元素从elem[0]处开始存储 + */ +typedef struct { + ElemType* elem; // 顺序表存储空间的基址（指向顺序表所占内存的起始位置） + int length; // 当前顺序表长度（包含多少元素） + int listsize; // 当前分配的存储容量（可以存储多少元素） +} SqList; + + +/* + * ████████ 算法2.3 ████████ + * + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(SqList* L); + +/* + * ████████ 算法2.4 ████████ + * + * 插入 + * + * 向顺序表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问顺序表L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.30/02.30.c b/CLion/ExerciseBook/02.30/02.30.c new file mode 100644 index 0000000..61cf01d --- /dev/null +++ b/CLion/ExerciseBook/02.30/02.30.c @@ -0,0 +1,97 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "LinkList.h" //**▲02 线性表**// + +/* + * 题2.30 + * + * A=A-B∩C。 + */ +Status Algo_2_30(LinkList La, LinkList Lb, LinkList Lc); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int b[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int c[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // 准备测试数据 + InitList(&La); + InitList(&Lb); + InitList(&Lc); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + ListInsert(Lc, i, c[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + // 处理后 + Algo_2_30(La, Lb, Lc); + + printf("La = La-Lb∩Lc = "); + ListTraverse(La, PrintElem); + + return 0; +} + +// A=A-B∩C +Status Algo_2_30(LinkList La, LinkList Lb, LinkList Lc) { + LinkList pa, pb, pc, p; + + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + pa = La->next; + pb = Lb->next; + pc = Lc->next; + p = La; + + // 获取B和C的交集，然后将其从A中删除 + while(pa != NULL && pb != NULL && pc != NULL) { + if(pb->data < pc->data) { + pb = pb->next; + } else if(pb->data > pc->data) { + pc = pc->next; + } else { + // 在A中查找交集元素 + while(pa != NULL && pa->data < pb->data) { + p = pa; + pa = pa->next; + } + + // 跳过交集元素 + while(pa != NULL && pa->data == pb->data) { + p->next = pa->next; + free(pa); + pa = p->next; + } + + // A还没有遍历完 + if(pa != NULL ) { + pb = pb->next; + pc = pc->next; + } + } + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/CLion/ExerciseBook/02.30/CMakeLists.txt b/CLion/ExerciseBook/02.30/CMakeLists.txt new file mode 100644 index 0000000..f5396c1 --- /dev/null +++ b/CLion/ExerciseBook/02.30/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.30 LinkList.h LinkList.c 02.30.c) +target_link_libraries(02.30 Scanf_lib) diff --git a/CLion/ExerciseBook/02.30/LinkList.c b/CLion/ExerciseBook/02.30/LinkList.c new file mode 100644 index 0000000..589e298 --- /dev/null +++ b/CLion/ExerciseBook/02.30/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#include "LinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 只是初始化一个头结点。 + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // 确保链表存 + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // 寻找第i-1个结点，且保证该结点本身不为NULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // 如果遍历到头了，或者i的值不合规(比如i<=0)，说明没找到合乎目标的结点 + if(p == NULL || j > i - 1) { + return ERROR; + } + + // 生成新结点 + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // 确保链表存在且不为空表 + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.30/LinkList.h b/CLion/ExerciseBook/02.30/LinkList.h new file mode 100644 index 0000000..3176ef5 --- /dev/null +++ b/CLion/ExerciseBook/02.30/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * 线性表的链式存储结构（链表） + * + * 包含算法: 2.8、2.9、2.10、2.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 单链表元素类型定义 */ +typedef int ElemType; + +/* + * 单链表结构 + * + * 注：这里的单链表存在头结点 + */ +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向单链表结点的指针 +typedef LNode* LinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(LinkList* L); + +/* + * ████████ 算法2.9 ████████ + * + * 插入 + * + * 向链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问链表L + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/CLion/ExerciseBook/02.31/02.31.c b/CLion/ExerciseBook/02.31/02.31.c new file mode 100644 index 0000000..91cfee1 --- /dev/null +++ b/CLion/ExerciseBook/02.31/02.31.c @@ -0,0 +1,136 @@ +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 链表元素类型定义 */ +typedef int ElemType; + +// 单向循环链表结构（无头结点） +typedef struct LNode { + ElemType data; // 数据结点 + struct LNode* next; // 指向下一个结点的指针 +} LNode; + +// 指向链表结点的指针 +typedef LNode* LinkList; + + +/* + * 题2.31 + * + * 删除s结点的前驱 + */ +Status Algo_2_31(LinkList* L, LinkList s); + +// 用指定的数据创建【无】头结点的单向循环链表 +Status CreatList(LinkList* L, ElemType elems[], int n); + +// 输出链表L +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L, s; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + // 准备测试数据 + CreatList(&L, a, 10); + printf("L = "); + Output(L); + + s = L->next->next->next->next; + + printf("删除 %d 的前驱后...\n", s->data); + Algo_2_31(&L, s); + + printf("L = "); + Output(L); + + return 0; +} + +// 删除s结点的前驱 +Status Algo_2_31(LinkList* L, LinkList s) { + LinkList p, pre; + + if(L == NULL || *L == NULL) { + return ERROR; + } + + // 无前驱 + if(s == NULL || s->next == s) { + return ERROR; + } + + p = s; + + // 使用p->next指向s的前驱 + while(p->next->next != s) { + p = p->next; + } + + // s的前驱 + pre = p->next; + + // 删掉前驱 + p->next = pre->next; + free(pre); + + // 如果前驱正好是 + if(pre == *L) { + *L = s; + } + + return OK; +} + +// 用指定的数据创建无头结点的单向循环链表 +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + *L = NULL; + + for(i = 0; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + + s->data = elems[i]; + + if(i == 0) { + *L = s; + s->next = *L; // 循环 + r = *L; + } else { + s->next = r->next; + r->next = s; + r = r->next; + } + } + + return OK; +} + +// 输出链表L +void Output(LinkList L) { + LinkList p; + + if(L == NULL) { + return; + } + + printf("%2d ", L->data); + + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.31/CMakeLists.txt b/CLion/ExerciseBook/02.31/CMakeLists.txt new file mode 100644 index 0000000..31e82d9 --- /dev/null +++ b/CLion/ExerciseBook/02.31/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.31 02.31.c) +target_link_libraries(02.31 Scanf_lib) diff --git a/CLion/ExerciseBook/02.32/02.32.c b/CLion/ExerciseBook/02.32/02.32.c new file mode 100644 index 0000000..0b6218b --- /dev/null +++ b/CLion/ExerciseBook/02.32/02.32.c @@ -0,0 +1,134 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 链表元素类型定义 */ +typedef int ElemType; + +// 双循环链表结构体 +typedef struct LNode { + ElemType data; + struct LNode* next; + struct LNode* pre; +} LNode; + +// 指向链表结点的指针 +typedef LNode* LinkList; + + +/* + * 题2.32 + * + * 将单向循环链表修改为双向循环链表 + */ +Status Algo_2_32(LinkList L); + +// 用指定的数据创建【有】头结点的单向循环链表 +Status CreatList(LinkList* L, ElemType elems[], int n); + +// 正向输出链表 +void Output(LinkList L); + +// 反向输出链表 +void OutputReverse(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L; + ElemType a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + // 准备测试数据，并正序输出 + CreatList(&L, a, 10); + printf("L = "); + Output(L); + + // 变为双向链表 + Algo_2_32(L); + + // 逆序输出链表 + printf("L = "); + OutputReverse(L); + + return 0; +} + + +// 将单向循环链表修改为双向循环链表 +Status Algo_2_32(LinkList L) { + LinkList r; + + if(L==NULL || L->next==L) { + return ERROR; + } + + for(r = L; r->next != L; r = r->next) { + r->next->pre = r; + } + + L->pre = r; + + return OK; +} + +// 用指定的数据创建【有】头结点的单向循环链表 +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + // 初始化头结点 + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->pre = NULL; + (*L)->next = *L; + + for(i = 0, r = *L; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + s->pre = NULL; + + s->next = r->next; + r->next = s; + r = r->next; + } + + return OK; +} + +// 正向输出链表 +void Output(LinkList L) { + LinkList p; + + if(L == NULL || L->next == L) { + return; + } + + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + + printf("\n"); +} + +// 反向输出链表 +void OutputReverse(LinkList L) { + LinkList p; + + if(L == NULL || L->pre == L) { + return; + } + + for(p = L->pre; p != L; p = p->pre) { + printf("%2d ", p->data); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.32/CMakeLists.txt b/CLion/ExerciseBook/02.32/CMakeLists.txt new file mode 100644 index 0000000..abbaf36 --- /dev/null +++ b/CLion/ExerciseBook/02.32/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.32 02.32.c) +target_link_libraries(02.32 Scanf_lib) diff --git a/CLion/ExerciseBook/02.33/02.33.c b/CLion/ExerciseBook/02.33/02.33.c new file mode 100644 index 0000000..9915d96 --- /dev/null +++ b/CLion/ExerciseBook/02.33/02.33.c @@ -0,0 +1,174 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include // 提供isalpha、isdigit原型 +#include "Status.h" //**▲01 绪论**// + +/* 链表元素类型定义 */ +typedef char ElemType; + +// 单循环链表结构体 +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode; + +// 指向链表结点的指针 +typedef LNode* LinkList; + + +/* + * 题2.33 + * + * 拆分链表，拆成字符、数字、其他三类 + */ +Status Algo_2_33(LinkList L, LinkList* L_char, LinkList* L_num, LinkList* L_other); + +// 初始化一个单向循环链表 +Status InitList(LinkList* L); + +// 用指定的数据创建【有】头结点的单向循环链表 +Status CreatList(LinkList* L, ElemType elems[], int n); + +// 正向输出链表 +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L, L_char, L_num, L_other; + + ElemType a[20+1] = "2a3@A5e$T*1%s&7pl(o)"; + + // 准备测试数据，并正序输出 + CreatList(&L, a, 20); + printf("L = "); + Output(L); + + // 拆分链表 + Algo_2_33(L, &L_char, &L_num, &L_other); + + // 输出拆分后的链表 + printf("L_char = "); + Output(L_char); + printf("L_num = "); + Output(L_num); + printf("L_other = "); + Output(L_other); + + return 0; +} + + +// 拆分链表，拆成字符、数字、其他三类 +Status Algo_2_33(LinkList L, LinkList* L_char, LinkList* L_num, LinkList* L_other) { + LinkList r, rc, rn, ro, s; + + if(L_char == NULL || L_num == NULL || L_other == NULL) { + return ERROR; + } + + if(L == NULL || L->next == L) { + return ERROR; + } + + InitList(L_char); + InitList(L_num); + InitList(L_other); + + r = L->next; + rc = *L_char; + rn = *L_num; + ro = *L_other; + + while(r != L) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = r->data; + + // 元素为字符 + if(isalpha(r->data)) { + s->next = rc->next; + rc->next = s; + rc = rc->next; + + // 元素为数字 + } else if(isdigit(r->data)) { + s->next = rn->next; + rn->next = s; + rn = rn->next; + + // 其它 + } else { + s->next = ro->next; + ro->next = s; + ro = ro->next; + } + + r = r->next; + } + + return OK; +} + + +// 初始化一个单向循环链表 +Status InitList(LinkList* L) { + if(L == NULL) { + return ERROR; + } + + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = *L; + + return OK; +} + +// 用指定的数据创建【有】头结点的单向循环链表 +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + // 初始化头结点 + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = *L; + + for(i = 0, r = *L; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + + s->next = r->next; + r->next = s; + r = r->next; + } + + return OK; +} + +// 正向输出链表 +void Output(LinkList L) { + LinkList p; + + if(L == NULL || L->next == L) { + return; + } + + for(p = L->next; p != L; p = p->next) { + printf("%c ", p->data); + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.33/CMakeLists.txt b/CLion/ExerciseBook/02.33/CMakeLists.txt new file mode 100644 index 0000000..9a0bbae --- /dev/null +++ b/CLion/ExerciseBook/02.33/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.33 02.33.c) +target_link_libraries(02.33 Scanf_lib) diff --git a/CLion/ExerciseBook/02.34-02.36/02.34-02.36.c b/CLion/ExerciseBook/02.34-02.36/02.34-02.36.c new file mode 100644 index 0000000..eca0dbe --- /dev/null +++ b/CLion/ExerciseBook/02.34-02.36/02.34-02.36.c @@ -0,0 +1,433 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include +#include "Status.h" //**▲01 绪论**// + +// 异或指针链表元素 +typedef char XElemType; + +// 异或指针链表结点结构 +typedef struct XorNode { + XElemType data; + struct XorNode* LRPtr; +} XorNode; +typedef XorNode* XorPointer; + +// 无头结点的异或指针双向链表的头尾指针 +typedef struct { + XorPointer Left; // 分别指向链表的最左端（头指针）和最右端（尾指针） + XorPointer Right; +} XorLinkedList; + + +/* + * 题2.34——方法一：借助PriorOrNext函数遍历链表 + * + * 输出L，mark表示输出方向：0，从左向右输出，1，从右向左输出 + */ +void Algo_2_34_1(XorLinkedList L, int mark); + +/* + * 题2.34——方法二：【不】借助PriorOrNext函数遍历链表 + * + * 输出L，mark表示输出方向：0，从左向右输出，1，从右向左输出 + */ +void Algo_2_34_2(XorLinkedList L, int mark); + +/* + * 题2.35 + * + * 将元素e插入到第i个结点之前 + */ +Status Algo_2_35(XorLinkedList* L, int i, XElemType e); + +/* + * 题2.36 + * + * 删除第i(>0)个结点，并用e接受结点中元素值 + */ +Status Algo_2_36(XorLinkedList* L, int i, char* e); + +// 指针异或函数，返回指针p和q的异或值（异或运算：p^q） +XorPointer XorP(XorPointer p, XorPointer q); + +// 创建异或指针链表L +Status Create(XorLinkedList* L, XElemType elems[], int n); + +// 获取当前结点(cur)的前驱(mark=0)或后继(mark=1) +XorPointer PriorOrNext(XorLinkedList L, XorPointer cur, int mark); + + +int main(int argc, char** argv) { + XorLinkedList L; + XElemType e; + XElemType* data = "123456789"; + + Create(&L, data, strlen(data)); + printf("████████ 题 2.34 验证...\n"); + printf("█ 正向输出 L = "); + Algo_2_34_1(L, 0); + printf("█ 逆向输出 L = "); + Algo_2_34_1(L, 1); + + printf("████████ 题 2.35 验证...\n"); + Algo_2_35(&L, 5, '*'); + printf("█ 插入 '*' 为L的第5个结点后顺序输出...\n"); + printf("█ 正向输出 L = "); + Algo_2_34_2(L, 0); + + printf("████████ 题 2.36 验证...\n"); + Algo_2_36(&L, 5, &e); + printf("█ 删除L的第5个结点 '%c' 后逆序输出...\n", e); + printf("█ 逆向输出 L = "); + Algo_2_34_2(L, 1); + + return 0; +} + + +// 异或运算：p^q +XorPointer XorP(XorPointer p, XorPointer q) { + unsigned long x, y, z; + + x = (unsigned long) p; + y = (unsigned long) q; + + // 求异或 + z = x ^ y; + + return (XorPointer) z; +} + +// 创建异或指针链表L +Status Create(XorLinkedList* L, XElemType elems[], int n) { + int i; + XorPointer pre_l, pre_m, pre_r; // 准备三个指针，指向链表中紧邻的三个结点 + + (*L).Left = NULL; + (*L).Right = NULL; + + pre_l = pre_m = NULL; + + for(i = 0; i < n; i++) { + pre_r = (XorPointer) malloc(sizeof(XorNode)); + if(pre_r == NULL) { + exit(OVERFLOW); + } + pre_r->data = elems[i]; + + // 左指针（创建首结点时设立） + if(i == 0) { + L->Left = pre_r; + } + + // 右指针，指向最后一个结点 + L->Right = pre_r; + + // 有新结点加入时，上一个结点的指针域需要作出修改 + if(pre_m != NULL) { + pre_m->LRPtr = XorP(pre_l, pre_r); + } + + pre_r->LRPtr = XorP(pre_m, NULL); + pre_l = pre_m; + pre_m = pre_r; + } + + return OK; +} + +// 获取当前结点(cur)的前驱(mark=0)或后继(mark=1) +XorPointer PriorOrNext(XorLinkedList L, XorPointer cur, int mark) { + XorPointer p_l, p_m, p_r; + + if(mark != 1 && mark != 0) { + return NULL; + } + + // 确保链表存在 + if(L.Left == NULL || L.Right == NULL || cur == NULL) { + return NULL; + } + + // 求后继，从左向右 + if(mark == 1) { + p_l = NULL; + p_m = L.Left; + + // 指针不断向右推进 + while(p_m != cur) { + p_r = XorP(p_l, p_m->LRPtr); //计算右侧第一个结点地址 + p_l = p_m; + p_m = p_r; + } + + // p_m指向cur的前驱 + p_r = XorP(p_l, p_m->LRPtr); + + return p_r; + + // 求前驱，从右向左 + } else { + p_m = L.Right; + p_r = NULL; + + // 指针不断向左推进 + while(p_m != cur) { + p_l = XorP(p_m->LRPtr, p_r); //计算左侧第一个结点地址 + p_r = p_m; + p_m = p_l; + } + + // p_m指向cur的后继 + p_l = XorP(p_m->LRPtr, p_r); + + return p_l; + } +} + +// 输出L，mark表示输出方向：0，从左向右输出，1，从右向左输出 +void Algo_2_34_1(XorLinkedList L, int mark) { + XorPointer cur; + + if(mark != 1 && mark != 0) { + return; + } + + // 确保链表存在 + if(L.Left == NULL || L.Right == NULL) { + return; + } + + // 从左向右输出 + if(mark == 0) { + cur = L.Left; + do { + printf("%c ", cur->data); + // 获取cur的后继 + cur = PriorOrNext(L, cur, 1); + } while(cur != NULL); + + // 从右向左输出 + } else { + cur = L.Right; + do { + printf("%c ", cur->data); + // 获取cur的前驱 + cur = PriorOrNext(L, cur, 0); + } while(cur != NULL); + } + + printf("\n"); +} + +// 输出L，mark表示输出方向：0，从左向右输出，1，从右向左输出 +void Algo_2_34_2(XorLinkedList L, int mark) { + XorPointer p_l, p_m, p_r; + + if(mark != 1 && mark != 0) { + return; + } + + // 确保链表存在 + if(L.Left == NULL || L.Right == NULL) { + return; + } + + // 从左向右输出 + if(mark == 0) { + p_l = NULL; + p_m = L.Left; + + // p_m为空时说明已输出完毕 + while(p_m != NULL) { + printf("%c ", p_m->data); + p_r = XorP(p_l, p_m->LRPtr); // 计算右侧第一个结点地址 + p_l = p_m; // 指针不断向后推进 + p_m = p_r; + } + + // 从右向左输出 + } else { + p_m = L.Right; + p_r = NULL; + + // p_m为空时说明已输出完毕 + while(p_m != NULL) { + printf("%c ", p_m->data); + p_l = XorP(p_m->LRPtr, p_r); // 计算左侧第一个结点地址 + p_r = p_m; // 指针不断向前推进 + p_m = p_l; + } + } + + printf("\n"); +} + +// 将元素e插入到第i个结点之前 +Status Algo_2_35(XorLinkedList* L, int i, XElemType e) { + XorPointer pl; // 指向第i-2个结点 + XorPointer pre; // 指向第i-1个结点 + XorPointer p; // 指向第i个结点 + XorPointer pr; // 指向第i+1个结点 + XorPointer s; + int j; + + if(L == NULL) { + return ERROR; + } + + // i>=1 + if(i < 1) { + return ERROR; + } + + // 创建新结点 + s = (XorPointer) malloc(sizeof(XorNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // 先处理链表为空的情形 + if((*L).Left == NULL && (*L).Right == NULL) { + if(i != 1) { + return ERROR; // 链表为空时，i只能为1 + } + + (*L).Left = (*L).Right = s; + s->LRPtr = NULL; + + return OK; + } + + j = 0; + pre = NULL; + p = (*L).Left; + + // 查找第i-1个结点，且由pre指向它 + while(j < i - 1 && p != NULL) { + j++; + pr = XorP(pre, p->LRPtr); + pre = p; + p = pr; + } + + // i值不合规（过大） + if(j < i - 1) { + return ERROR; + } + + // 需要插入到链表尾部 + if(p == NULL) { + pl = XorP(pre->LRPtr, p); + pre->LRPtr = XorP(pl, s); + + s->LRPtr = XorP(pre, p); + + (*L).Right = s; + + return OK; + } + + // 需要插入到链表的头部 + if(pre == NULL) { + pr = XorP(pre, p->LRPtr); + p->LRPtr = XorP(s, pr); + + s->LRPtr = XorP(pre, p); + + (*L).Left = s; + + return OK; + } + + // 其他情形 + pl = XorP(pre->LRPtr, p); + pr = XorP(pre, p->LRPtr); + pre->LRPtr = XorP(pl, s); + p->LRPtr = XorP(s, pr); + s->LRPtr = XorP(pre, p); + + return OK; +} + +// 删除第i(>0)个结点，并用e接受结点中元素值 +Status Algo_2_36(XorLinkedList* L, int i, XElemType* e) { + XorPointer pl; // 指向第i-2个结点 + XorPointer pre; // 指向第i-1个结点 + XorPointer p; // 指向第i个结点 + XorPointer pr; // 指向第i+1个结点 + XorPointer prr; // 指向第i+2个结点 + int j; + + if(L == NULL || (*L).Left == NULL || (*L).Right == NULL) { + return ERROR; + } + + // i>=1 + if(i < 1) { + return ERROR; + } + + // 先处理只有一个结点的情形 + if((*L).Left == (*L).Right) { + if(i != 1) { + return ERROR; // 链表只有一个结点时，i只能为1 + } + + *e = (*L).Left->data; + (*L).Left = (*L).Right = NULL; + + return OK; + } + + j = 0; + pre = NULL; + p = (*L).Left; + + // 查找第i-1个结点，且由pre指向它 + while(j < i - 1 && p != NULL) { + j++; + pr = XorP(pre, p->LRPtr); + pre = p; + p = pr; + } + + // i值不合规（过大） + if(j < i - 1 || p == NULL) { + return ERROR; + } + + // 存储被删元素的值 + *e = p->data; + + /* 至此，至少有两个元素存在，且p指向被删除元素 */ + + pr = XorP(pre, p->LRPtr); + + // 删除头结点 + if(pre == NULL) { + // 由于此时至少有两个结点，故pr!=NULL + prr = XorP(p, pr->LRPtr); + + pr->LRPtr = XorP(pre, prr); + + (*L).Left = pr; + } else { + pl = XorP(pre->LRPtr, p); + pre->LRPtr = XorP(pl, pr); + + // 删除最后一个结点 + if(pr == NULL) { + (*L).Right = pre; + } else { + prr = XorP(p, pr->LRPtr); + pr->LRPtr = XorP(pre, prr); + } + } + + free(p); + + return OK; +} diff --git a/CLion/ExerciseBook/02.34-02.36/CMakeLists.txt b/CLion/ExerciseBook/02.34-02.36/CMakeLists.txt new file mode 100644 index 0000000..a75ae7f --- /dev/null +++ b/CLion/ExerciseBook/02.34-02.36/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.34-02.36 02.34-02.36.c) +target_link_libraries(02.34-02.36 Scanf_lib) diff --git a/CLion/ExerciseBook/02.37/02.37.c b/CLion/ExerciseBook/02.37/02.37.c new file mode 100644 index 0000000..b4e7292 --- /dev/null +++ b/CLion/ExerciseBook/02.37/02.37.c @@ -0,0 +1,73 @@ +#include +#include "Status.h" //**▲01 绪论**// +#include "DuLinkList.h" //**▲02 线性表**// + +/* + * 题2.37 + * + * 按奇偶次序重排链表各元素位序：奇数位序元素靠前正序，偶数位序元素靠后逆序 + */ +Status Algo_2_37(DuLinkList L); + +// 测试函数，打印元素 +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + DuLinkList L; + int i; + + // 准备测试数据 + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(L, i, i); + } + printf("重排前 L = "); + ListTraverse(L, PrintElem); + + Algo_2_37(L); + + printf("重排后 L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// 按奇偶次序重排链表各元素位序：奇数位序元素靠前正序，偶数位序元素靠后逆序 +Status Algo_2_37(DuLinkList L) { + DuLinkList head, tail, p; + + if(L == NULL || L->prior == NULL || L->next == NULL) { + return ERROR; + } + + head = L->next; // 指向表首，向右推进 + tail = L->prior; // 指向表尾，固定不动 + + // 如果head跟tail中间至少隔了一个元素 + while(head != tail && head->next != tail) { + // 指向原偶数位序的元素 + p = head->next; + + // 摘下此偶数位序的元素 + p->next->prior = head; + head->next = p->next; + + // 将此元素添加到原tail后面 + p->next = tail->next; + p->prior = tail; + tail->next->prior = p; + tail->next = p; + + // 前进到下一个奇数位序的元素上 + head = head->next; + } + + return OK; +} + +// 测试函数，打印元素 +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/CLion/ExerciseBook/02.37/CMakeLists.txt b/CLion/ExerciseBook/02.37/CMakeLists.txt new file mode 100644 index 0000000..443e083 --- /dev/null +++ b/CLion/ExerciseBook/02.37/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.37 DuLinkList.h DuLinkList.c 02.37.c) +target_link_libraries(02.37 Scanf_lib) diff --git a/CLion/ExerciseBook/02.37/DuLinkList.c b/CLion/ExerciseBook/02.37/DuLinkList.c new file mode 100644 index 0000000..e1e34f3 --- /dev/null +++ b/CLion/ExerciseBook/02.37/DuLinkList.c @@ -0,0 +1,130 @@ +/*===================== + * 双向循环链表 + * + * 包含算法: 2.18、2.19 + ======================*/ + +#include "DuLinkList.h" //**▲02 线性表**// + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(DuLinkList* L) { + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + // 前驱和后继均指向自身 + (*L)->next = (*L)->prior = *L; + + return OK; +} + +/* + * ████████ 算法2.18 ████████ + * + * 插入 + * + * 向双向循环链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(DuLinkList L, int i, ElemType e) { + DuLinkList p, s; + + // 确保双向循环链表存在（但可能为空表） + if(L == NULL) { + return ERROR; + } + + // 查找第i个结点位置（引用） + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // 创建新结点 + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // 将s插入到p的前面，称为第i个结点 + s->prior = p->prior; + p->prior->next = s; + s->next = p; + p->prior = s; + + return OK; +} + +/* + * 遍历 + * + * 用visit函数访问双向循环链表L + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)) { + DuLinkList p; + + // 确保双向循环链表存在 + if(L == NULL || L->next == L || L->prior == L) { + return; + } + + p = L->next; + + while(p != L) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * 获取循环链表L上第i个元素的引用 + * + * ▓▓▓▓ 注 ▓▓▓▓ + * 1.加static的含义是当前函数只在DuLinkList中使用，不会被别的文件引用 + * 2.假设链表长度为len，且需要获取第len+1个元素的引用时，由于这里是循环链表，所以返回的是头结点 + */ +static DuLinkList GetElemP(DuLinkList L, int i) { + DuLinkList p; + int count; + + // 确保双向循环链表存在（但可能为空表） + if(L == NULL) { + return NULL; + } + + // 位置不合规 + if(i < 1) { + return NULL; + } + + p = L; + count = 0; + + // 尝试查找第i个元素 + while(p->next != L && count < i) { + p = p->next; + ++count; + } + + // 恰好找到第i个元素 + if(count == i) { + return p; + } + + // 至此，说明p->next==L，此时需要判断i是否过大 + if(count + 1 < i) { + return NULL; + } + + // 至此，说明需要在len+1的位置上插入元素 + return L; +} diff --git a/CLion/ExerciseBook/02.37/DuLinkList.h b/CLion/ExerciseBook/02.37/DuLinkList.h new file mode 100644 index 0000000..a29fde1 --- /dev/null +++ b/CLion/ExerciseBook/02.37/DuLinkList.h @@ -0,0 +1,67 @@ +/*===================== + * 双向循环链表 + * + * 包含算法: 2.18、2.19 + ======================*/ + +#ifndef DULINKLIST_H +#define DULINKLIST_H + +#include +#include //提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 双向循环链表元素类型定义 */ +typedef int ElemType; + +/* + * 双向循环链表结构 + * + * 注：这里的双向循环链表存在头结点 + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // 前驱 + struct DuLNode* next; // 后继 +} DuLNode; + +// 指向双向循环链表结点的指针 +typedef DuLNode* DuLinkList; + + +/* + * 初始化 + * + * 初始化成功则返回OK，否则返回ERROR。 + */ +Status InitList(DuLinkList* L); + +/* + * ████████ 算法2.18 ████████ + * + * 插入 + * + * 向双向循环链表第i个位置上插入e，插入成功则返回OK，否则返回ERROR。 + * + *【备注】 + * 教材中i的含义是元素位置，从1开始计数 + */ +Status ListInsert(DuLinkList L, int i, ElemType e); + +/* + * 遍历 + * + * 用visit函数访问双向循环链表L + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)); + +/* + * 获取循环链表L上第i个元素的引用 + * + * ▓▓▓▓ 注意 ▓▓▓▓ + * 1.加static的含义是当前函数只在DuLinkList中使用，不会被别的文件引用 + * 2.假设链表长度为len，且需要获取第len+1个元素的引用时，由于这里是循环链表，所以返回的是头结点 + */ +static DuLinkList GetElemP(DuLinkList L, int i); + +#endif diff --git a/CLion/ExerciseBook/02.38/02.38.c b/CLion/ExerciseBook/02.38/02.38.c new file mode 100644 index 0000000..0136963 --- /dev/null +++ b/CLion/ExerciseBook/02.38/02.38.c @@ -0,0 +1,153 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +/* 双向循环链表元素类型定义 */ +typedef int ElemType; + +/* + * 双向循环链表结构，增加了一个访问拼读域 + * + * 注：这里的双向循环链表存在头结点 + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // 前驱 + struct DuLNode* next; // 后继 + int freq; // 访问频度域 +} DuLNode; + +// 指向双循环链表结构的指针 +typedef DuLNode* DuLinkList; + +/* + * 题2.38 + * + * 查找元素e在首次在L中出现的位序，并按访问频度重排链表。 + */ +DuLinkList Algo_2_38(DuLinkList* L, ElemType e); + +// 创建双循环链表 +Status CreatList(DuLinkList* L, ElemType elems[], int n); + +// 正向输出链表 +void Output(DuLinkList L); + + +int main(int argc, char* argv[]) { + DuLinkList L; + int i; + ElemType data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + ElemType visit[10] = {1, 2, 2, 2, 3, 4, 4, 5, 5, 9}; + + CreatList(&L, data, 10); + printf("访问前： L = \n"); + Output(L); + + // 依次访问tmp中预设的数字 + for(i = 0; i < 10; i++) { + Algo_2_38(&L, visit[i]); + } + + printf("访问后：L = \n"); + Output(L); + + return 0; +} + +// 查找元素e在首次在L中出现的位序，并按访问频度重排链表 +DuLinkList Algo_2_38(DuLinkList* L, ElemType e) { + DuLinkList pre, r; + + // 确保链表存在 + if(L == NULL || *L == NULL) { + return NULL; + } + + for(pre = *L; pre->next != *L && pre->next->data != e; pre = pre->next) { + // 查找元素e的前驱 + } + + // 没找到满足条件的元素 + if(pre->next == *L) { + return NULL; + } + + // 摘下元素e + r = pre->next; + pre->next = r->next; + r->next->prior = pre; + + // 频度增一 + r->freq++; + + for(pre = *L; pre->next != *L && pre->next->freq > r->freq; pre = pre->next) { + // 根据访问频度，寻找元素e应该插入的位置的前驱 + } + + // 将元素e插入到合适的位置 + r->next = pre->next; + r->prior = pre; + pre->next->prior = r; + pre->next = r; + + // 返回指向元素e的引用 + return r; +} + +// 创建双循环链表 +Status CreatList(DuLinkList* L, ElemType elems[], int n) { + DuLinkList s, p; + int i; + + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->data = -1; + (*L)->prior = *L; + (*L)->next = *L; + (*L)->freq = 0; + + p = *L; + + for(i = 0; i < n; i++) { + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + s->freq = 0; + + // 尾插 + s->next = *L; + (*L)->prior = s; + s->prior = p; + p->next = s; + + p = p->next; + } + + return OK; +} + +// 正向输出链表 +void Output(DuLinkList L) { + DuLinkList p; + + if(L == NULL || L->next == L || L->prior == NULL) { + return; + } + + printf("数据："); + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + printf("\n"); + + printf("频度："); + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->freq); + } + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.38/CMakeLists.txt b/CLion/ExerciseBook/02.38/CMakeLists.txt new file mode 100644 index 0000000..a4ee52d --- /dev/null +++ b/CLion/ExerciseBook/02.38/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.38 02.38.c) +target_link_libraries(02.38 Scanf_lib) diff --git a/CLion/ExerciseBook/02.39-02.40/02.39-02.40.c b/CLion/ExerciseBook/02.39-02.40/02.39-02.40.c new file mode 100644 index 0000000..624c0b5 --- /dev/null +++ b/CLion/ExerciseBook/02.39-02.40/02.39-02.40.c @@ -0,0 +1,184 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include // 提供pow原型 +#include "Status.h" //**▲01 绪论**// + +// 稀疏多项式顺序结构 +typedef struct { + int coef; //系数 + int exp; //指数 +} PolyTerm; + +// 多项式的顺序存储结构 +typedef struct { + PolyTerm* data; + int last; // 多项式项数 +} SqPoly; + +/* + * 题2.39 + * + * 求多项式的值。 + */ +int Algo_2_39(SqPoly P, int x); + +/* + * 题2.40 + * + * Pc=Pa-Pb。 + */ +Status Algo_2_40(SqPoly Pa, SqPoly Pb, SqPoly* Pc); + +// 创建稀疏多项式 +Status CreatPoly(SqPoly* P, PolyTerm Data[], int n); + +// 输出稀疏多项式 +void OutputPoly(SqPoly P); + + +int main(int argc, char* argv[]) { + SqPoly Pa, Pb, Pc; + + PolyTerm a[5] = {{-2, 1}, {4, 3}, {11, 5}, {-7, 7}, {8, 9}}; + PolyTerm b[5] = {{3, 2}, {-5, 3}, {12, 4}, {-7, 7}, {6, 11}}; + + // 准备测试数据 + CreatPoly(&Pa, a, 5); + CreatPoly(&Pb, b, 5); + printf("Pan(x) = "); + OutputPoly(Pa); + printf("Pbn(x) = "); + OutputPoly(Pb); + + printf("\n"); + + printf("████████ 题 2.39 验证...\n"); + printf("█ Pa5(2) = %d", Algo_2_39(Pa, 2)); + printf("\n"); + printf("█ Pb5(2) = %d", Algo_2_39(Pb, 2)); + printf("\n\n"); + + printf("████████ 题 2.40 验证...\n"); + Algo_2_40(Pa, Pb, &Pc); + printf("█ Pcn(x) = "); + OutputPoly(Pc); + + printf("计算多项式Pc的值 Pc5(2) = %d\n", Algo_2_39(Pc, 2)); + + return 0; +} + + +// 求多项式的值 +int Algo_2_39(SqPoly P, int x) { + int i, sum; + + for(i = 0, sum = 0; i < P.last; i++) { + sum += P.data[i].coef * (int) (pow(x, P.data[i].exp)); + } + + return sum; +} + +// Pc=Pa-Pb +Status Algo_2_40(SqPoly Pa, SqPoly Pb, SqPoly* Pc) { + int i, j, k, sum; + + (*Pc).data = (PolyTerm*) malloc((Pa.last + Pb.last) * sizeof(PolyTerm)); + if((*Pc).data == NULL) { + exit(OVERFLOW); + } + + i = j = k = 0; + + // 遍历Pa和Pb的公共部分 + while(i < Pa.last && j < Pb.last) { + // Pa指数较小，则处理Pa + if(Pa.data[i].exp < Pb.data[j].exp) { + (*Pc).data[k++] = Pa.data[i]; + i++; + // Pa指数较大，则处理Pb，只需简单改变系数符号就行 + } else if(Pa.data[i].exp > Pb.data[j].exp) { + (*Pc).data[k].coef = -Pb.data[j].coef; //符号改变 + (*Pc).data[k].exp = Pb.data[j].exp; + k++; + j++; + // 指数相等时，需要做减法运算 + } else { + sum = Pa.data[i].coef - Pb.data[j].coef; + + // 如果相减后仍存在有效项 + if(sum != 0) { + (*Pc).data[k].coef = sum; + (*Pc).data[k].exp = Pa.data[i].exp; + k++; + } + + i++; + j++; + } + } + + // 如果Pa未扫描完，但Pb扫描完了，则把Pa中剩余部分存到Pc中 + while(i < Pa.last) { + (*Pc).data[k++] = Pa.data[i]; + i++; + } + + // 如果Pb未扫描完，则需要将其系数符号逆转后存到Pc中 + while(j < Pb.last) { + (*Pc).data[k].coef = -Pb.data[j].coef; + (*Pc).data[k].exp = Pb.data[j].exp; + k++; + j++; + } + + // 记录运算后的项数 + (*Pc).last = k; + + return OK; +} + +Status CreatPoly(SqPoly* P, PolyTerm Data[], int n) { + int i; + + (*P).data = (PolyTerm*) malloc(n * sizeof(PolyTerm)); + if((*P).data == NULL) { + exit(OVERFLOW); + } + (*P).last = n; + + for(i = 0; i < n; i++) { + (*P).data[i] = Data[i]; + } + + return OK; +} + +void OutputPoly(SqPoly P) { + int i; + + for(i = 0; i < P.last; i++) { + if(i == 0) { + printf("%d", P.data[i].coef); + } else { + if(P.data[i].coef < 0) { + printf(" - "); + printf("%d", -P.data[i].coef); + } else { + printf(" + "); + printf("%d", P.data[i].coef); + } + } + + if(P.data[i].exp) { + printf("x"); + + if(P.data[i].exp != 1) { + printf("^%d", P.data[i].exp); + } + } + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.39-02.40/CMakeLists.txt b/CLion/ExerciseBook/02.39-02.40/CMakeLists.txt new file mode 100644 index 0000000..a5292d3 --- /dev/null +++ b/CLion/ExerciseBook/02.39-02.40/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.39-02.40 02.39-02.40.c) +target_link_libraries(02.39-02.40 Scanf_lib) diff --git a/CLion/ExerciseBook/02.41-02.42/02.41-02.42.c b/CLion/ExerciseBook/02.41-02.42/02.41-02.42.c new file mode 100644 index 0000000..a345ee3 --- /dev/null +++ b/CLion/ExerciseBook/02.41-02.42/02.41-02.42.c @@ -0,0 +1,215 @@ +#include +#include // 提供malloc、realloc、free、exit原型 +#include "Status.h" //**▲01 绪论**// + +// 稀疏多项式的项 +typedef struct { + int coef; // 系数 + int exp; // 指数 +} PolyTerm; + +// 稀疏多项式链式结构（这里采用循环链表结构） +typedef struct PolyNode { + PolyTerm data; + struct PolyNode* next; +} PolyNode; + +typedef PolyNode* PolyLink; +typedef PolyLink LinkedPoly; + + +/* + * 题2.41 + * + * 求多项式的导函数。 + */ +Status Algo_2_41(LinkedPoly P); + +/* + * 题2.42 + * + * 按指数奇偶性拆分多项式。 + */ +Status Algo_2_42(LinkedPoly* P, LinkedPoly* P_Odd, LinkedPoly* P_Even); + +// 创建稀疏多项式 +Status CreatPoly(LinkedPoly* P, PolyTerm Data[], int n); + +// 输出稀疏多项式 +void OutputPoly(LinkedPoly P); + + +int main(int argc, char* argv[]) { + LinkedPoly P1, P2; + PolyTerm a[7] = {{-2, 1}, {4, 2}, {2, 3}, {11, 5}, {-7, 6}, {8, 9}, {-3, 10}}; + + // 准备测试数据 + CreatPoly(&P1, a, 7); + CreatPoly(&P2, a, 7); + printf("Pn(x) = "); + OutputPoly(P1); + printf("\n"); + + printf("████████ 题 2.41 验证...\n"); + { + + Algo_2_41(P1); + printf("█ 求多项式的导函数之后...\n"); + printf("█ Pn(x) = "); + OutputPoly(P1); + printf("\n"); + } + + printf("████████ 题 2.42 验证...\n"); + { + LinkedPoly P_odd, P_even; + Algo_2_42(&P2, &P_odd, &P_even); + printf("█ 按指数奇偶性拆分多项式之后...\n"); + printf("█ 奇次幂 P_odd = "); + OutputPoly(P_odd); + printf("█ 偶次幂 P_even = "); + OutputPoly(P_even); + } + + return 0; +} + + +// 求多项式的导函数 +Status Algo_2_41(LinkedPoly P) { + LinkedPoly r, pre; + + if(P == NULL || P->next == P) { + return ERROR; + } + + pre = P; + r = P->next; + + while(r != P) { + // 存在不为0的指数 + if(r->data.exp != 0) { + r->data.coef *= r->data.exp; // 系数与指数想乘 + r->data.exp--; // 指数减一 + pre = r; + + // 指数为0时，该项求导后为0，需要删除当前结点 + } else { + pre->next = r->next; + free(r); + } + + r = pre->next; + } + + return OK; +} + +// 按指数奇偶性拆分多项式 +Status Algo_2_42(LinkedPoly* P, LinkedPoly* P_Odd, LinkedPoly* P_Even) { + LinkedPoly r, s, p, q; + + // 创建头结点 + *P_Odd = (LinkedPoly) malloc(sizeof(PolyNode)); + *P_Even = (LinkedPoly) malloc(sizeof(PolyNode)); + if(*P_Odd == NULL || *P_Even == NULL) { + exit(OVERFLOW); + } + (*P_Odd)->next = *P_Odd; + (*P_Even)->next = *P_Even; + + if(P == NULL || *P == NULL) { + return ERROR; + } + + p = *P_Odd; + q = *P_Even; + r = (*P)->next; + + // 遍历多项式，并将其拆分 + while(r != (*P)) { + s = r; + r = r->next; + + // 指数为奇数 + if(s->data.exp % 2 != 0) { + s->next = p->next; + p->next = s; + p = p->next; + + // 指数为偶数 + } else { + s->next = q->next; + q->next = s; + q = q->next; + } + } + + // 销毁原来的多项式 + free(*P); + *P = NULL; + + return OK; +} + +// 创建稀疏多项式 +Status CreatPoly(LinkedPoly* P, PolyTerm Data[], int n) { + int i; + LinkedPoly s, r; + + // 创建头结点 + *P = (LinkedPoly) malloc(sizeof(PolyNode)); + if(*P == NULL) { + exit(OVERFLOW); + } + (*P)->next = *P; + + for(i = 0, r = *P; i < n; i++) { + s = (LinkedPoly) malloc(sizeof(PolyNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = Data[i]; + + // 链接到多项式中 + s->next = r->next; + r->next = s; + + r = r->next; + } + + return OK; +} + +// 输出稀疏多项式 +void OutputPoly(LinkedPoly P) { + LinkedPoly r; + + if(P == NULL || P->next == P) { + return; + } + + for(r = P->next; r != P; r = r->next) { + if(r == P->next) { + printf("%d", r->data.coef); + } else { + if(r->data.coef < 0) { + printf(" - "); + printf("%d", -r->data.coef); + } else { + printf(" + "); + printf("%d", r->data.coef); + } + } + + if(r->data.exp) { + printf("x"); + + if(r->data.exp != 1) { + printf("^%d", r->data.exp); + } + } + } + + printf("\n"); +} diff --git a/CLion/ExerciseBook/02.41-02.42/CMakeLists.txt b/CLion/ExerciseBook/02.41-02.42/CMakeLists.txt new file mode 100644 index 0000000..c73d572 --- /dev/null +++ b/CLion/ExerciseBook/02.41-02.42/CMakeLists.txt @@ -0,0 +1,6 @@ +# 包含公共库 +include_directories(${CMAKE_SOURCE_DIR}/Status) + +# 生成可执行文件，并链接公共库 +add_executable(02.41-02.42 02.41-02.42.c) +target_link_libraries(02.41-02.42 Scanf_lib) diff --git a/CLion/ExerciseBook/CMakeLists.txt b/CLion/ExerciseBook/CMakeLists.txt new file mode 100644 index 0000000..c0f1208 --- /dev/null +++ b/CLion/ExerciseBook/CMakeLists.txt @@ -0,0 +1,31 @@ +add_subdirectory(01.16) +add_subdirectory(01.17) +add_subdirectory(01.19) +add_subdirectory(01.20) + +add_subdirectory(02.10) +add_subdirectory(02.11) +add_subdirectory(02.12) +add_subdirectory(02.13) +add_subdirectory(02.14) +add_subdirectory(02.15) +add_subdirectory(02.16-02.18) +add_subdirectory(02.19-02.20) +add_subdirectory(02.21) +add_subdirectory(02.22) +add_subdirectory(02.23) +add_subdirectory(02.24) +add_subdirectory(02.25) +add_subdirectory(02.26) +add_subdirectory(02.27) +add_subdirectory(02.28) +add_subdirectory(02.29) +add_subdirectory(02.30) +add_subdirectory(02.31) +add_subdirectory(02.32) +add_subdirectory(02.33) +add_subdirectory(02.34-02.36) +add_subdirectory(02.37) +add_subdirectory(02.38) +add_subdirectory(02.39-02.40) +add_subdirectory(02.41-02.42) \ No newline at end of file diff --git a/CLion/README.md b/CLion/README.md index 7a32a17..2b8a2fe 100644 --- a/CLion/README.md +++ b/CLion/README.md @@ -8,3 +8,25 @@ > **CLion** [2019] > **Cygwin64** [gcc-7.3.0] + +## 使用说明 + +1. 确保 **CLion** 的工具链已配置完毕（配置方式可自行搜索） +![CLion00](image/CLion00.png) + +2. 启动 **CLion** ，选择"New CMake Project from Sources" +![CLion01](image/CLion01.png) + +3. 选择待启动的项目（CLion版本的源码） +![CLion02](image/CLion02.png) + +4. 选择"Open Existing Project"，打开存在的项目，等待加载完成 +![CLion03](image/CLion03.png) + +5. 加载完成后，选择包含"main"方法的测试文件运行就可以 + +## 注意事项 + +1. 教材源码CourseBook跟习题集源码ExerciseBook是放在**一个项目**当中的 +2. CLion版本的源码，其文件编码格式使用了UTF-8 +3. CLion除了支持使用gcc编译器，也支持使用Microsoft Visual C++的MSVC++编译器（参见第一张图的工具链配置）。如果想使用MSVC++编译器，则需要将文件编码格式更改为与本地编码一致（中文环境一般为GB2312），否则输出内容时会出现乱码。 diff --git a/CLion/Status/CMakeLists.txt b/CLion/Status/CMakeLists.txt new file mode 100644 index 0000000..4c5a673 --- /dev/null +++ b/CLion/Status/CMakeLists.txt @@ -0,0 +1,8 @@ +# 生成一个静态库，因为所有其他数据结构都会引用这个库 +add_library(Scanf_lib Status.c) + +# 注： +## 本次修订的目的包括降低耦合，争取每个模块都可以单独运行 +## 但是Status这个模块会被所有其他模块引用，引用次数很多。 +## 如果直接将Status模块复制到其它模块中，则会导致太多重复代码， +## 因此这里生成一个公共静态库让其它模块共享比较划算 diff --git a/CLion/Status/Status.c b/CLion/Status/Status.c new file mode 100644 index 0000000..be9a4e6 --- /dev/null +++ b/CLion/Status/Status.c @@ -0,0 +1,164 @@ +#include +#include +#include // 提供宏va_list、va_start、va_arg、va_end +#include // 提供isprint原型 + +/* + * 这是自定义的数据录入函数，用于从文件fp中读取格式化的输入 + * 与fscanf不同之处在于此函数只会读取西文字符，对于中文字符，则会跳过 + * + * 注： + * 1. 这里约定所有格式串为简单形式，如：%d%c%s等，而不是%2d%5s等 + * 2. 读取字符串时，遇到空格或非打印字符会停止读取 + */ +int ReadData(FILE* fp, char* format, ...) { + int* i; // 存储读取到的整型 + float* f; // 存储读取到的浮点型 + char* ch; // 存储读取到的字符型 + char* s; // 存储读取到的字符串型 + + int n; // 遍历存储字符串的字符数组 + + int len; // 格式串format的长度 + int k; // 遍历格式串时的游标 + + int tmp; // 暂存从文件中读取到的字符 + + va_list ap; // 可变参数指针，指向存储数据的变量 + + // 累计成功读取到的字符数 + int count = 0; + + + /* + * 获取格式串的长度 + * 这里预设格式串仅由简单 + */ + len = strlen(format); + + // ap指向首个可变参数 + va_start(ap, format); + + // 只遍历奇数索引，因为偶数索引下都是% + for(k = 1; k <= len; k = k + 2) { + // 跳过所有非西文字符 + while((tmp = getc(fp)) != EOF) { + // 遇到首个西文字符，将此西文字符重新放入输入流 + if((tmp >= 0 && tmp <= 127)) { + ungetc(tmp, fp); + break; + } + } + + // 如果已读到文件结尾，结束读取 + if(tmp == EOF) { + break; + } + + // 遇到了"%c"，应该读取字符 + if(format[k] == 'c') { + ch = va_arg(ap, char*); + + count += fscanf(fp, "%c", ch); + } + + // 遇到了"%d"，应该读取整型 + if(format[k] == 'd') { + i = va_arg(ap, int*); + + while((tmp = getc(fp)) != EOF) { + // 寻找整数区域 + if((tmp >= '0' && tmp <= '9') || tmp == '-' || tmp == '+') { + ungetc(tmp, fp); + break; + } + } + + if(tmp != EOF) { + count += fscanf(fp, "%d", i); + } + } + + // 读取浮点型，一律存储为double类型 + if(format[k] == 'f') { + f = va_arg(ap, float*); + + while((tmp = getc(fp)) != EOF) { + if((tmp >= '0' && tmp <= '9') || tmp == '-' || tmp == '+' || tmp == '.') { + ungetc(tmp, fp); + break; + } + } + + if(tmp != EOF) { + count += fscanf(fp, "%f", f); + } + } + + // 读取字符串 + if(format[k] == 's') { + s = va_arg(ap, char*); + + n = 0; + + // 查找排除空格的可打印字符 + while((tmp = getc(fp)) != EOF && (!isprint(tmp) || tmp == ' ')) { + } + + // 如果未到文件结尾 + if(!feof(fp)) { + + // 将上面读到的字符重新放入流中 + ungetc(tmp, fp); + + while((tmp = getc(fp)) != EOF) { + // 存储排除空格的可打印字符 + if(isprint(tmp) && tmp != ' ') { + s[n++] = tmp; + } else { + ungetc(tmp, fp); + break; + } + } + + count++; + } + + // 字符串最后一个字符为空字符 + s[n] = '\0'; + } + }// for + + va_end(ap); + + return count; +} + +// 摁下回车键以继续运行 +void PressEnterToContinue() { + int debug = 1; + + fflush(stdin); + + printf("\nPress Enter to Continue..."); + + // 处于测试阶段时，可以让debug=1，自动添加换行，便于测试 + if(debug) { + printf("\n"); + + // 发布时，可以让debug=0，手动输入换行，否则让程序暂停下来，观察每一步的输出 + } else { + getchar(); + } + + fflush(stdin); +} + +// 函数暂停一段时间，time不代表具体的时间 +void Wait(long time) { + double i; + + for(i = 0.01; i <= 100000.0 * time; i += 0.01) { + // 空循环 + } +} diff --git a/CLion/Status/Status.h b/CLion/Status/Status.h new file mode 100644 index 0000000..0279a70 --- /dev/null +++ b/CLion/Status/Status.h @@ -0,0 +1,45 @@ +/* + * 注： + * 本次修订的目的包括降低耦合，争取每个模块都可以单独运行 + * 但是Status这个模块会被所有其他模块引用，引用次数很多。 + * 如果直接将Status模块复制到其它模块中，则会导致太多重复代码， + * 因此这里生成一个公共静态库让其它模块共享比较划算 + */ + +#ifndef STATUS_H +#define STATUS_H + +#include + +/* 状态码 */ +#define TRUE 1 // 真/是 +#define FALSE 0 // 假/否 +#define OK 1 // 通过/成功 +#define ERROR 0 // 错误/失败 + +//系统中已有此状态码定义，要防止冲突 +#ifndef OVERFLOW +#define OVERFLOW -2 //堆栈上溢 +#endif + +//系统中已有此状态码定义，要防止冲突 +#ifndef NULL +#define NULL ((void*)0) +#endif + +/* 状态码类型 */ +typedef int Status; + + +// 读取数据 +int ReadData(FILE* fp, char* format, ...); + +// 摁下回车键以继续运行 +void PressEnterToContinue(); + +// 函数暂停一段时间，time不代表具体的时间 +void Wait(long time); + +#endif + + diff --git a/CLion/image/CLion00.png b/CLion/image/CLion00.png new file mode 100644 index 0000000..a61c6ff Binary files /dev/null and b/CLion/image/CLion00.png differ diff --git a/CLion/image/CLion01.png b/CLion/image/CLion01.png new file mode 100644 index 0000000..982a006 Binary files /dev/null and b/CLion/image/CLion01.png differ diff --git a/CLion/image/CLion02.png b/CLion/image/CLion02.png new file mode 100644 index 0000000..9eb5e18 Binary files /dev/null and b/CLion/image/CLion02.png differ diff --git a/CLion/image/CLion03.png b/CLion/image/CLion03.png new file mode 100644 index 0000000..7075590 Binary files /dev/null and b/CLion/image/CLion03.png differ diff --git a/Dev-C++/CourseBook/0201_SqList/SqList-main.cpp b/Dev-C++/CourseBook/0201_SqList/SqList-main.cpp new file mode 100644 index 0000000..684e954 --- /dev/null +++ b/Dev-C++/CourseBook/0201_SqList/SqList-main.cpp @@ -0,0 +1,171 @@ +#include +#include "SqList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SqList L; // ˳ + + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼ˳ L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + if(ListEmpty(L) == TRUE) { + printf(" L Ϊգ\n"); + } else { + printf(" L Ϊգ\n"); + } + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" Ϊʾ L %d λò \"%d\"...\n", i, 2 * i); + ListInsert(&L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + i = ListLength(L); + printf(" L ijΪ %d \n", i); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأL = "); + ListTraverse(L, PrintElem); + + printf(" ɾ L е 6 Ԫ...\n"); + + if(ListDelete(&L, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" GetElem \n"); + { + GetElem(L, 4, &e); + printf(" L е 4 λõԪΪ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + printf(" L еһԪֵ \"7\" Ԫ \"%d\" \n", L.elem[i - 1]); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" L ǰ"); + if(ListEmpty(L) == TRUE) { + printf(" L Ϊգ\n"); + } else { + printf(" L Ϊգ\n"); + } + + ClearList(&L); + + printf(" L "); + if(ListEmpty(L) == TRUE) { + printf(" L Ϊգ\n"); + } else { + printf(" L Ϊգ\n"); + } + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" L ǰ"); + if(L.elem != NULL) { + printf(" L ڣ\n"); + } else { + printf(" L ڣ\n"); + } + + DestroyList(&L); + + printf(" L "); + if(L.elem != NULL) { + printf(" L ڣ\n"); + } else { + printf(" L ڣ\n"); + } + } + PressEnterToContinue(); + + + return 0; +} + diff --git a/Dev-C++/CourseBook/0201_SqList/SqList.cpp b/Dev-C++/CourseBook/0201_SqList/SqList.cpp new file mode 100644 index 0000000..79387a1 --- /dev/null +++ b/Dev-C++/CourseBook/0201_SqList/SqList.cpp @@ -0,0 +1,338 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * (ṹ) + * + * ͷ˳ռڴ档 + */ +Status DestroyList(SqList* L) { + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // ͷ˳ڴ + free((*L).elem); + + // ͷڴÿָ + (*L).elem = NULL; + + // ˳ȸ + (*L).length = 0; + (*L).listsize = 0; + + return OK; +} + +/* + * ÿ() + * + * ֻ˳д洢ݣͷ˳ռڴ档 + */ +Status ClearList(SqList* L) { + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + (*L).length = 0; + + return OK; +} + +/* + * п + * + * ж˳ǷЧݡ + * + * ֵ + * TRUE : ˳Ϊ + * FALSE: ˳Ϊ + */ +Status ListEmpty(SqList L) { + return L.length == 0 ? TRUE : FALSE; +} + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e) { + // ΪiĺλãϷΧǣ[1, length] + if(i < 1 || i > L.length) { + return ERROR; //iֵϷ + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // ȷ˳ṹ + if(L.elem == NULL) { + return ERROR; + } + + /* + * iijֵΪ1Ԫصλ + * + * ʵȻдǽiʼΪ1Ԫص + * ڽ̲ǰλģдλ + */ + i = 1; + + // pijֵΪ1ԪصĴ洢λ + p = L.elem; + + // ˳ + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(SqList L, ElemType cur_e, ElemType* pre_e) { + int i; + + // ȷ˳ṹڣٰԪ + if(L.elem == NULL || L.length < 2) { + return ERROR; + } + + // iʼΪ1Ԫصġ + i = 0; + + // ӵ1Ԫؿʼcur_eλ + while(i < L.length && L.elem[i] != cur_e) { + ++i; + } + + // cur_e׸Ԫ(ûǰ)ûҵԪcur_eERROR + if(i==0 || i >= L.length) { + return ERROR; + } + + // 洢cur_eǰ + *pre_e = L.elem[i - 1]; + + return OK; +} + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(SqList L, ElemType cur_e, ElemType* next_e) { + int i; + + // ȷ˳ṹڣٰԪ + if(L.elem == NULL || L.length < 2) { + return ERROR; + } + + // iʼΪ1Ԫصġ + i = 0; + + // ӵ1Ԫؿʼcur_eλ + while(i < L.length-1 && L.elem[i] != cur_e) { + ++i; + } + + // cur_e1Ԫ(ûǰ)ûҵԪcur_eERROR + if(i >= L.length-1) { + return ERROR; + } + + // 洢cur_eǰ + *next_e = L.elem[i + 1]; + + return OK; +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * 㷨2.5 + * + * ɾ + * + * ɾ˳iλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(SqList* L, int i, ElemType* e) { + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length) { + return ERROR; + } + + // pΪɾԪصλ + p = &(*L).elem[i - 1]; + + // 1.ȡɾԪ + *e = *p; + + // βԪλ + q = (*L).elem + (*L).length - 1; + + // 2.ԪأɾԪصλϻԪؽ + for(++p; p <= q; ++p) { + *(p - 1) = *p; + } + + // 3.1 + (*L).length--; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} + diff --git a/Dev-C++/CourseBook/0201_SqList/SqList.dev b/Dev-C++/CourseBook/0201_SqList/SqList.dev new file mode 100644 index 0000000..06cb8da --- /dev/null +++ b/Dev-C++/CourseBook/0201_SqList/SqList.dev @@ -0,0 +1,82 @@ +[Project] +FileName=SqList.dev +Name=SqList +Type=1 +Ver=2 +ObjFiles= +Includes= +Libs= +PrivateResource= +ResourceIncludes= +MakeIncludes= +Compiler= +CppCompiler= +Linker=_@@_ +IsCpp=0 +Icon= +ExeOutput= +ObjectOutput= +LogOutput= +LogOutputEnabled=0 +OverrideOutput=0 +OverrideOutputName=SqList.exe +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=1.0.0.0 +FileDescription=Developed using the Dev-C++ IDE +InternalName= +LegalCopyright= +LegalTrademarks= +OriginalFilename= +ProductName= +ProductVersion=1.0.0.0 +AutoIncBuildNr=0 +SyncProduct=1 + +[Unit2] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit1] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0201_SqList/SqList.h b/Dev-C++/CourseBook/0201_SqList/SqList.h new file mode 100644 index 0000000..655ee13 --- /dev/null +++ b/Dev-C++/CourseBook/0201_SqList/SqList.h @@ -0,0 +1,150 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * (ṹ) + * + * ͷ˳ռڴ档 + */ +Status DestroyList(SqList* L); + +/* + * ÿ() + * + * ֻ˳д洢ݣͷ˳ռڴ档 + */ +Status ClearList(SqList* L); + +/* + * п + * + * ж˳ǷЧݡ + * + * ֵ + * TRUE : ˳Ϊ + * FALSE: ˳Ϊ + */ +Status ListEmpty(SqList L); + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L); + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(SqList L, ElemType cur_e, ElemType* pre_e); + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(SqList L, ElemType cur_e, ElemType* next_e); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 㷨2.5 + * + * ɾ + * + * ɾ˳iλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(SqList* L, int i, ElemType* e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif + diff --git a/Dev-C++/CourseBook/0202_Union/SqList.cpp b/Dev-C++/CourseBook/0202_Union/SqList.cpp new file mode 100644 index 0000000..6a7df05 --- /dev/null +++ b/Dev-C++/CourseBook/0202_Union/SqList.cpp @@ -0,0 +1,173 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e) { + // ΪiĺλãϷΧǣ[1, length] + if(i < 1 || i > L.length) { + return ERROR; //iֵϷ + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // ȷ˳ṹ + if(L.elem == NULL) { + return ERROR; + } + + /* + * iijֵΪ1Ԫصλ + * + * ʵȻдǽiʼΪ1Ԫص + * ڽ̲ǰλģдλ + */ + i = 1; + + // pijֵΪ1ԪصĴ洢λ + p = L.elem; + + // ˳ + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} + diff --git a/Dev-C++/CourseBook/0202_Union/SqList.h b/Dev-C++/CourseBook/0202_Union/SqList.h new file mode 100644 index 0000000..4ea223f --- /dev/null +++ b/Dev-C++/CourseBook/0202_Union/SqList.h @@ -0,0 +1,94 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L); + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif + diff --git a/Dev-C++/CourseBook/0202_Union/Union-main.cpp b/Dev-C++/CourseBook/0202_Union/Union-main.cpp new file mode 100644 index 0000000..8a6c397 --- /dev/null +++ b/Dev-C++/CourseBook/0202_Union/Union-main.cpp @@ -0,0 +1,44 @@ +#include +#include "Union.h" //**02 Ա**// +#include "SqList.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ElemType a[5] = {5, 2, 1, 3, 9}; + ElemType b[7] = {7, 2, 6, 9, 11, 3, 10}; + SqList La, Lb; + int i; + + // ʼLa + InitList(&La); + for(i = 1; i <= 5; i++) { + ListInsert(&La, i, a[i - 1]); + } + + // ʼLb + InitList(&Lb); + for(i = 1; i <= 7; i++) { + ListInsert(&Lb, i, b[i - 1]); + } + + // La + printf("La = "); + ListTraverse(La, PrintElem); + + // Lb + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // ±La + printf("La = LaLb = "); + Union(&La, Lb); + ListTraverse(La, PrintElem); + + return 0; +} + diff --git a/Dev-C++/CourseBook/0202_Union/Union.cpp b/Dev-C++/CourseBook/0202_Union/Union.cpp new file mode 100644 index 0000000..ec0245a --- /dev/null +++ b/Dev-C++/CourseBook/0202_Union/Union.cpp @@ -0,0 +1,46 @@ +/*============== + * 󲢼 + * + * 㷨: 2.1 + ===============*/ + +#include "Union.h" //**02 Ա**// + +/* + * 㷨2.1 + * + * A=AB + * + * LaLbIJء + * ɵIJƴLaϣLaΪָ͡ + */ +void Union(SqList* La, SqList Lb) { + int La_len, Lb_len; + int i; + ElemType e; + + // ˳ + La_len = ListLength(*La); + Lb_len = ListLength(Lb); + + for(i = 1; i <= Lb_len; i++) { + // ȡLbеiԪظe + GetElem(Lb, i, &e); + + // eLa + if(!LocateElem(*La, e, equal)) { + ListInsert(La, ++La_len, e); + } + } +} + +/* + * е + * + * жԪǷȡ + * ȣ򷵻TRUE򣬷FALSE + */ +Status equal(ElemType e1, ElemType e2) { + return e1 == e2 ? TRUE : FALSE; +} + diff --git a/Dev-C++/CourseBook/0202_Union/Union.dev b/Dev-C++/CourseBook/0202_Union/Union.dev new file mode 100644 index 0000000..3d910ea --- /dev/null +++ b/Dev-C++/CourseBook/0202_Union/Union.dev @@ -0,0 +1,102 @@ +[Project] +FileName=Union.dev +Name=Union +Type=1 +Ver=2 +ObjFiles= +Includes= +Libs= +PrivateResource= +ResourceIncludes= +MakeIncludes= +Compiler= +CppCompiler= +Linker= +IsCpp=0 +Icon= +ExeOutput= +ObjectOutput= +LogOutput= +LogOutputEnabled=0 +OverrideOutput=0 +OverrideOutputName=Union.exe +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=1.0.0.0 +FileDescription=Developed using the Dev-C++ IDE +InternalName= +LegalCopyright= +LegalTrademarks= +OriginalFilename= +ProductName= +ProductVersion=1.0.0.0 +AutoIncBuildNr=0 +SyncProduct=1 + +[Unit2] +FileName=Union.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit4] +FileName=Union.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit5] +FileName=Union-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit1] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0202_Union/Union.h b/Dev-C++/CourseBook/0202_Union/Union.h new file mode 100644 index 0000000..c089ede --- /dev/null +++ b/Dev-C++/CourseBook/0202_Union/Union.h @@ -0,0 +1,34 @@ +/*============== + * 󲢼 + * + * 㷨: 2.1 + ===============*/ + +#ifndef UNION_H +#define UNION_H + +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + + +/* + * 㷨2.1 + * + * A=AB + * + * LaLbIJء + * ɵIJƴLaϣLaΪָ͡ + */ +void Union(SqList* La, SqList Lb); + +/* + * е + * + * жԪǷȡ + * ȣ򷵻TRUE򣬷FALSE + */ +Status equal(ElemType e1, ElemType e2); + +#endif + diff --git a/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList-main.cpp b/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList-main.cpp new file mode 100644 index 0000000..f6834fa --- /dev/null +++ b/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList-main.cpp @@ -0,0 +1,49 @@ +#include +#include "SqList.h" +#include "MergeSqList.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ElemType a[4] = {3, 5, 8, 11}; + ElemType b[7] = {2, 6, 8, 9, 11, 15, 20}; + + SqList La, Lb, Lc1, Lc2; + int i; + + // ʼLa + InitList(&La); + for(i = 1; i <= 4; i++) { + ListInsert(&La, i, a[i - 1]); + } + + // ʼLb + InitList(&Lb); + for(i = 1; i <= 7; i++) { + ListInsert(&Lb, i, b[i - 1]); + } + + // La + printf("La = "); + ListTraverse(La, PrintElem); + + // Lb + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 鲢˳LaLb㷨2.2 + MergeSqList_1(La, Lb, &Lc1); + printf("鲢LaLbΪLc1 = "); + ListTraverse(Lc1, PrintElem); + + // 鲢˳LaLb㷨2.7 + MergeSqList_2(La, Lb, &Lc2); + printf("鲢LaLbΪLc2 = "); + ListTraverse(Lc2, PrintElem); + + return 0; +} diff --git a/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.cpp b/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.cpp new file mode 100644 index 0000000..4df7d41 --- /dev/null +++ b/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.cpp @@ -0,0 +1,104 @@ +/*================== + * 鲢ǽ˳ + * + * 㷨: 2.22.7 + ===================*/ + +#include "MergeSqList.h" //**02 Ա**// + + +/* + * 㷨2.2 + * + * ǵݼ鲢C=A+B + * + * 鲢˳LaLbµ˳Lc + * УLaLbLcΪǵݼС + */ +void MergeSqList_1(SqList La, SqList Lb, SqList* Lc) { + int La_len, Lb_len; + int i, j, k; + ElemType ai, bj; + + i = j = 1; + k = 0; + + // ʼLc + InitList(Lc); + + // ȡLaLbij + La_len = ListLength(La); + Lb_len = ListLength(Lb); + + // LaLbδ + while(i <= La_len && j <= Lb_len) { + GetElem(La, i, &ai); + GetElem(Lb, j, &bj); + + // ȽϱԪأȽȽСԪؼ˳Lc + if(ai <= bj) { + ListInsert(Lc, ++k, ai); + i++; + } else { + ListInsert(Lc, ++k, bj); + j++; + } + } + + // Lbѱ꣬Laδ꣬LaʣԪؼLc + while(i <= La_len) { + GetElem(La, i++, &ai); + ListInsert(Lc, ++k, ai); + } + + // Laѱ꣬Lbδ꣬LbʣԪؼLc + while(j <= Lb_len) { + GetElem(Lb, j++, &bj); + ListInsert(Lc, ++k, bj); + } +} + +/* + * 㷨2.7 + * + * ǵݼ鲢C=A+B + * + * 鲢˳LaLbµ˳Lc + * УLaLbLcΪǵݼС + */ +void MergeSqList_2(SqList La, SqList Lb, SqList* Lc) { + ElemType* pa, * pb, * pc; + ElemType* pa_last, * pb_last; + + pa = La.elem; // ָLaһԪ + pb = Lb.elem; // ָLbһԪ + + // ûʹInitListLc + (*Lc).listsize = (*Lc).length = La.length + Lb.length; + pc = (*Lc).elem = (ElemType*) malloc((*Lc).listsize * sizeof(ElemType)); + if(pc == NULL) { + exit(OVERFLOW); + } + + pa_last = La.elem + La.length - 1; // ָLaһԪ + pb_last = Lb.elem + Lb.length - 1; // ָLbһԪ + + // LaLbδ + while(pa <= pa_last && pb <= pb_last) { + if(*pa <= *pb) { + *pc++ = *pa++; + } else { + *pc++ = *pb++; + } + } + + // Lbѱ꣬Laδ꣬LaʣԪؼLc + while(pa <= pa_last) { + *pc++ = *pa++; + } + + // Laѱ꣬Lbδ꣬LbʣԪؼLc + while(pb <= pb_last) { + *pc++ = *pb++; + } +} \ No newline at end of file diff --git a/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.dev b/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.dev new file mode 100644 index 0000000..9daeb8f --- /dev/null +++ b/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.dev @@ -0,0 +1,102 @@ +[Project] +FileName=MergeSqList.dev +Name=MergeSqList +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=MergeSqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=MergeSqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=MergeSqList-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit4] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit5] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.h b/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.h new file mode 100644 index 0000000..12704b0 --- /dev/null +++ b/Dev-C++/CourseBook/0203_MergeSqList/MergeSqList.h @@ -0,0 +1,35 @@ +/*================== + * 鲢ǽ˳ + * + * 㷨: 2.22.7 + ===================*/ + +#ifndef MERGESQLIST_H +#define MERGESQLIST_H + +#include +#include +#include "SqList.h" //**02 Ա**// + + +/* + * 㷨2.2 + * + * ǵݼ鲢C=A+B + * + * 鲢˳LaLbµ˳Lc + * УLaLbLcΪǵݼС + */ +void MergeSqList_1(SqList La, SqList Lb, SqList* Lc); + +/* + * 㷨2.7 + * + * ǵݼ鲢C=A+B + * + * 鲢˳LaLbµ˳Lc + * УLaLbLcΪǵݼС + */ +void MergeSqList_2(SqList La, SqList Lb, SqList* Lc); + +#endif diff --git a/Dev-C++/CourseBook/0203_MergeSqList/SqList.cpp b/Dev-C++/CourseBook/0203_MergeSqList/SqList.cpp new file mode 100644 index 0000000..93b7b2c --- /dev/null +++ b/Dev-C++/CourseBook/0203_MergeSqList/SqList.cpp @@ -0,0 +1,129 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e) { + // ΪiĺλãϷΧǣ[1, length] + if(i < 1 || i > L.length) { + return ERROR; //iֵϷ + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/Dev-C++/CourseBook/0203_MergeSqList/SqList.h b/Dev-C++/CourseBook/0203_MergeSqList/SqList.h new file mode 100644 index 0000000..a90a6f3 --- /dev/null +++ b/Dev-C++/CourseBook/0203_MergeSqList/SqList.h @@ -0,0 +1,80 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L); + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/Dev-C++/CourseBook/0204_LinkList/LinkList-main.cpp b/Dev-C++/CourseBook/0204_LinkList/LinkList-main.cpp new file mode 100644 index 0000000..c2790e2 --- /dev/null +++ b/Dev-C++/CourseBook/0204_LinkList/LinkList-main.cpp @@ -0,0 +1,170 @@ +#include +#include "Status.h" +#include "LinkList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + LinkList L; + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼ L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" L %d λò \"%d\" ...\n", i, 2 * i); + ListInsert(L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + printf(" L ijΪ %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأL = "); + ListTraverse(L, PrintElem); + + printf(" ɾ L е 6 Ԫ...\n"); + + if(ListDelete(L, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" GetElem \n"); + { + GetElem(L, 4, &e); + printf(" L е 4 λõԪΪ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + GetElem(L, i, &e); + printf(" L еһԪֵ \"7\" Ԫ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" L ǰ"); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + + ClearList(L); + + printf(" L "); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" L ǰ"); + L ? printf(" L ڣ\n") : printf(" L ڣ\n"); + + DestroyList(&L); + + printf(" L "); + L ? printf(" L ڣ\n") : printf(" L ڣ\n"); + } + PressEnterToContinue(); + + + printf(" CreateList_Head \n"); + { + LinkList L; + printf(" ͷ巨 L = "); + CreateList_Head("TestData_Head.txt", &L, 5); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" CreateList_Tail \n"); + { + LinkList L; + printf(" β巨 L = "); + CreateList_Tail("TestData_Tail.txt", &L, 5); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/Dev-C++/CourseBook/0204_LinkList/LinkList.cpp b/Dev-C++/CourseBook/0204_LinkList/LinkList.cpp new file mode 100644 index 0000000..d87e5b5 --- /dev/null +++ b/Dev-C++/CourseBook/0204_LinkList/LinkList.cpp @@ -0,0 +1,488 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * (ṹ) + * + * ͷռڴ棬ͷҲᱻ + */ +Status DestroyList(LinkList* L) { + LinkList p; + + // ȷṹ + if(L == NULL || *L == NULL) { + return ERROR; + } + + p = *L; + + while(p != NULL) { + p = (*L)->next; + free(*L); + (*L) = p; + } + + *L = NULL; + + return OK; +} + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(LinkList L) { + LinkList pre, p; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L->next; + + // ͷнռڴ + while(p != NULL) { + pre = p; + p = p->next; + free(pre); + } + + L->next = NULL; + + return OK; +} + +/* + * п + * + * жǷЧݡ + * + * ֵ + * TRUE : Ϊ + * FALSE: Ϊ + */ +Status ListEmpty(LinkList L) { + // ֻͷʱΪΪ + if(L != NULL && L->next == NULL) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * + * + * ЧԪص + */ +int ListLength(LinkList L) { + LinkList p; + int i; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 0; + p = L->next; + + // н + while(p != NULL) { + i++; + p = p->next; + } + + return i; +} + +/* + * 㷨2.8 + * + * ȡֵ + * + * ȡеiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(LinkList L, int i, ElemType* e) { + LinkList p; + int j; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ýĺ̲ΪNULL + while(p->next != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p->next == NULL || j > i - 1) { + return ERROR; + } + + *e = p->next->data; + + return OK; +} + +/* + * + * + * ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 1; // iijֵΪ1Ԫصλ + p = L->next; // pijֵΪ1Ԫصָ + + while(p != NULL && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != NULL) { + return i; + } else { + return 0; + } +} + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(LinkList L, ElemType cur_e, ElemType* pre_e) { + LinkList pre, next; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return ERROR; + } + + // ָ1Ԫ + pre = L->next; + + // 1Ԫûǰ + if(pre->data == cur_e) { + return ERROR; + } + + // ָ2Ԫ + next = pre->next; + + // ӵ2Ԫؿʼcur_eλ + while(next != NULL && next->data != cur_e) { + pre = next; + next = next->next; + } + + // ûҵԪcur_eʧܣERROR + if(next == NULL) { + return ERROR; + } + + *pre_e = pre->data; + + return OK; +} + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(LinkList L, ElemType cur_e, ElemType* next_e) { + LinkList pre; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return ERROR; + } + + // ָ1Ԫ + pre = L->next; + + // ӵ1Ԫؿʼcur_eλãұ֤ýĺ̲ΪNULL + while(pre->next != NULL && pre->data != cur_e) { + pre = pre->next; + } + + // ûҵcur_eҵˣûк̣ERROR + if(pre->next == NULL) { + return ERROR; + } + + *next_e = pre->next->data; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 㷨2.10 + * + * ɾ + * + * ɾiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(LinkList L, int i, ElemType* e) { + LinkList p, q; + int j; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ýĺ̲ΪNULL + while(p->next != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p->next == NULL || j > i - 1) { + return ERROR; + } + + // ɾi + q = p->next; + p->next = q->next; + *e = q->data; + free(q); + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * 㷨2.11 + * + * ͷ巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + * ̲е㷨õͷ巨Դ˴ʵּ˺׺_Head + */ +Status CreateList_Head(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p; + ElemType e; + + // ͷ + *L = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1; i <= n; ++i) { + // ɹȡ + if(ReadData(fp, "%d", &e) == 1) { + // ½ + p = (LinkList) malloc(sizeof(LNode)); + if(p == NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // ݣ뵽 + p->data = e; + p->next = (*L)->next; + (*L)->next = p; + } else { + fclose(fp); + return ERROR; + } + } + + fclose(fp); + + return OK; +} + +/* + * β巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + */ +Status CreateList_Tail(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p, q; + ElemType e; + + // ͷ + *L = (LinkList) malloc(sizeof(LNode)); + if(*L==NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1, q = *L; i <= n; ++i) { + // ɹȡ + if(ReadData(fp, "%d", &e) == 1) { + p = (LinkList) malloc(sizeof(LNode)); + if(p==NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // ݣ뵽 + p->data = e; + q->next = p; + q = q->next; + } else { + fclose(fp); + return ERROR; + } + } + + q->next = NULL; + + fclose(fp); + + return OK; +} diff --git a/Dev-C++/CourseBook/0204_LinkList/LinkList.dev b/Dev-C++/CourseBook/0204_LinkList/LinkList.dev new file mode 100644 index 0000000..8098a54 --- /dev/null +++ b/Dev-C++/CourseBook/0204_LinkList/LinkList.dev @@ -0,0 +1,100 @@ +[Project] +FileName=LinkList.dev +Name=LinkList +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=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit4] +FileName=TestData_Head.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit5] +FileName=TestData_Tail.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0204_LinkList/LinkList.h b/Dev-C++/CourseBook/0204_LinkList/LinkList.h new file mode 100644 index 0000000..6e7e06a --- /dev/null +++ b/Dev-C++/CourseBook/0204_LinkList/LinkList.h @@ -0,0 +1,168 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(LinkList* L); + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(LinkList L); + +/* + * п + * + * жǷЧݡ + * + * ֵ + * TRUE : Ϊ + * FALSE: Ϊ + */ +Status ListEmpty(LinkList L); + +/* + * + * + * ЧԪص + */ +int ListLength(LinkList L); + +/* + * 㷨2.8 + * + * ȡֵ + * + * ȡеiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(LinkList L, int i, ElemType* e); + +/* + * + * + * ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(LinkList L, ElemType cur_e, ElemType* pre_e); + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(LinkList L, ElemType cur_e, ElemType* next_e); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 㷨2.10 + * + * ɾ + * + * ɾiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(LinkList L, int i, ElemType* e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +/* + * 㷨2.11 + * + * ͷ巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + * ̲е㷨õͷ巨Դ˴ʵּ˺׺_Head + */ +Status CreateList_Head(char path[], LinkList* L, int n); + +/* + * β巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡ + */ +Status CreateList_Tail(char path[], LinkList* L, int n); + +#endif diff --git a/Dev-C++/CourseBook/0204_LinkList/TestData_Head.txt b/Dev-C++/CourseBook/0204_LinkList/TestData_Head.txt new file mode 100644 index 0000000..4820e7d --- /dev/null +++ b/Dev-C++/CourseBook/0204_LinkList/TestData_Head.txt @@ -0,0 +1 @@ +9 7 5 3 1 \ No newline at end of file diff --git a/Dev-C++/CourseBook/0204_LinkList/TestData_Tail.txt b/Dev-C++/CourseBook/0204_LinkList/TestData_Tail.txt new file mode 100644 index 0000000..e2b34ca --- /dev/null +++ b/Dev-C++/CourseBook/0204_LinkList/TestData_Tail.txt @@ -0,0 +1 @@ +2 4 6 8 10 \ No newline at end of file diff --git a/Dev-C++/CourseBook/0205_MergeList/LinkList.cpp b/Dev-C++/CourseBook/0205_MergeList/LinkList.cpp new file mode 100644 index 0000000..1fc32b4 --- /dev/null +++ b/Dev-C++/CourseBook/0205_MergeList/LinkList.cpp @@ -0,0 +1,138 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * 㷨2.11 + * + * ͷ巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + * ̲е㷨õͷ巨Դ˴ʵּ˺׺_Head + */ +Status CreateList_Head(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p; + ElemType e; + + // ͷ + *L = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1; i <= n; ++i) { + // ɹȡ + if(ReadData(fp, "%d", &e) == 1) { + // ½ + p = (LinkList) malloc(sizeof(LNode)); + if(p == NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // ݣ뵽 + p->data = e; + p->next = (*L)->next; + (*L)->next = p; + } else { + fclose(fp); + return ERROR; + } + } + + fclose(fp); + + return OK; +} + +/* + * β巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + */ +Status CreateList_Tail(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p, q; + ElemType e; + + // ͷ + *L = (LinkList) malloc(sizeof(LNode)); + if(*L==NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1, q = *L; i <= n; ++i) { + // ɹȡ + if(ReadData(fp, "%d", &e) == 1) { + p = (LinkList) malloc(sizeof(LNode)); + if(p==NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // ݣ뵽 + p->data = e; + q->next = p; + q = q->next; + } else { + fclose(fp); + return ERROR; + } + } + + q->next = NULL; + + fclose(fp); + + return OK; +} diff --git a/Dev-C++/CourseBook/0205_MergeList/LinkList.h b/Dev-C++/CourseBook/0205_MergeList/LinkList.h new file mode 100644 index 0000000..02a6994 --- /dev/null +++ b/Dev-C++/CourseBook/0205_MergeList/LinkList.h @@ -0,0 +1,61 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +/* + * 㷨2.11 + * + * ͷ巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + * ̲е㷨õͷ巨Դ˴ʵּ˺׺_Head + */ +Status CreateList_Head(char path[], LinkList* L, int n); + +/* + * β巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡ + */ +Status CreateList_Tail(char path[], LinkList* L, int n); + +#endif diff --git a/Dev-C++/CourseBook/0205_MergeList/MergeList-main.cpp b/Dev-C++/CourseBook/0205_MergeList/MergeList-main.cpp new file mode 100644 index 0000000..fbf6614 --- /dev/null +++ b/Dev-C++/CourseBook/0205_MergeList/MergeList-main.cpp @@ -0,0 +1,31 @@ +#include +#include "MergeList.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + LinkList La, Lb, Lc; + + int m = 5; + + printf("ΪʾLa趨Ϊ %d Lb趨Ϊ %d LaLb...\n", m, m); + + CreateList_Head("TestData_Head.txt", &La, m); + printf("La = "); + ListTraverse(La, PrintElem); + + CreateList_Tail("TestData_Tail.txt", &Lb, m); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + printf("鲢LaLbΪLc = "); + MergeList(&La, &Lb, &Lc); + ListTraverse(Lc, PrintElem); + + return 0; +} + diff --git a/Dev-C++/CourseBook/0205_MergeList/MergeList.cpp b/Dev-C++/CourseBook/0205_MergeList/MergeList.cpp new file mode 100644 index 0000000..95f6062 --- /dev/null +++ b/Dev-C++/CourseBook/0205_MergeList/MergeList.cpp @@ -0,0 +1,45 @@ +/*=============== + * 鲢ǽ + * + * 㷨: 2.12 + ================*/ + +#include "MergeList.h" //**02 Ա**// + +/* + * 㷨2.12 + * + * ǵݼ鲢C=A+B + * + * AB鲢ΪCұԪλò䡣 + * LcLaͷ㣬LbнLcС + */ +void MergeList(LinkList* La, LinkList* Lb, LinkList* Lc) { + LinkList pa, pb, pc; + + pa = (*La)->next; + pb = (*Lb)->next; + pc = *Lc = *La; // LaͷΪLcͷ + + // LaLb + while(pa && pb) { + if(pa->data <= pb->data) { + pc->next = pa; + pc = pa; + pa = pa->next; + } else { + pc->next = pb; + pc = pb; + pb = pb->next; + } + } + + // ʣ + pc->next = pa ? pa : pb; + + // ͷLbͷռڴ + free(*Lb); + + *La = NULL; + *Lb = NULL; +} diff --git a/Dev-C++/CourseBook/0205_MergeList/MergeList.dev b/Dev-C++/CourseBook/0205_MergeList/MergeList.dev new file mode 100644 index 0000000..d114afe --- /dev/null +++ b/Dev-C++/CourseBook/0205_MergeList/MergeList.dev @@ -0,0 +1,120 @@ +[Project] +FileName=MergeList.dev +Name=MergeList +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=7 + +[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=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit5] +FileName=MergeList-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=MergeList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit4] +FileName=MergeList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit6] +FileName=TestData_Head.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit7] +FileName=TestData_Tail.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0205_MergeList/MergeList.h b/Dev-C++/CourseBook/0205_MergeList/MergeList.h new file mode 100644 index 0000000..4a7a263 --- /dev/null +++ b/Dev-C++/CourseBook/0205_MergeList/MergeList.h @@ -0,0 +1,24 @@ +/*=============== + * 鲢ǽ + * + * 㷨: 2.12 + ================*/ + +#ifndef MERGELIST_H +#define MERGELIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "LinkList.h" //**02 Ա**// + +/* + * 㷨2.12 + * + * ǵݼ鲢C=A+B + * + * AB鲢ΪCұԪλò䡣 + * LcLaͷ㣬LbнLcС + */ +void MergeList(LinkList* La, LinkList* Lb, LinkList* Lc); + +#endif diff --git a/Dev-C++/CourseBook/0205_MergeList/TestData_Head.txt b/Dev-C++/CourseBook/0205_MergeList/TestData_Head.txt new file mode 100644 index 0000000..4820e7d --- /dev/null +++ b/Dev-C++/CourseBook/0205_MergeList/TestData_Head.txt @@ -0,0 +1 @@ +9 7 5 3 1 \ No newline at end of file diff --git a/Dev-C++/CourseBook/0205_MergeList/TestData_Tail.txt b/Dev-C++/CourseBook/0205_MergeList/TestData_Tail.txt new file mode 100644 index 0000000..e2b34ca --- /dev/null +++ b/Dev-C++/CourseBook/0205_MergeList/TestData_Tail.txt @@ -0,0 +1 @@ +2 4 6 8 10 \ No newline at end of file diff --git a/Dev-C++/CourseBook/0206_SLinkList/SLinkList-main.cpp b/Dev-C++/CourseBook/0206_SLinkList/SLinkList-main.cpp new file mode 100644 index 0000000..c9fb486 --- /dev/null +++ b/Dev-C++/CourseBook/0206_SLinkList/SLinkList-main.cpp @@ -0,0 +1,152 @@ +#include +#include "Status.h" +#include "SLinkList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SLinkList space; // ÿռ + int S; // ̬ͷ + + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼ S ...\n"); + InitList(space, &S); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + ListEmpty(space, S) ? printf(" S Ϊգ\n") : printf(" S Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" S %d λò \"%d\" ...\n", i, 2 * i); + ListInsert(space, S, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" S еԪΪS = "); + ListTraverse(space, S, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + printf(" S ijΪ %d \n", ListLength(space, S)); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأS = "); + ListTraverse(space, S, PrintElem); + + printf(" ɾ S е 6 Ԫ...\n"); + + if(ListDelete(space, S, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأS = "); + ListTraverse(space, S, PrintElem); + } + PressEnterToContinue(); + + + printf(" GetElem \n"); + { + GetElem(space, S, 4, &e); + printf(" S е 4 λõԪΪ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + i = LocateElem(space, S, 7, CmpGreater); + GetElem(space, S, i, &e); + printf(" S еһԪֵ \"7\" Ԫ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(space, S, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(space, S, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" S ǰ"); + ListEmpty(space, S) ? printf(" S Ϊգ\n") : printf(" S Ϊգ\n"); + + ClearList(space, S); + + printf(" S "); + ListEmpty(space, S) ? printf(" S Ϊգ\n") : printf(" S Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" S ǰ"); + S!=0 ? printf(" S ڣ\n") : printf(" S ڣ\n"); + + DestroyList(space, &S); + + printf(" S "); + S!=0 ? printf(" S ڣ\n") : printf(" S ڣ\n"); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/Dev-C++/CourseBook/0206_SLinkList/SLinkList.cpp b/Dev-C++/CourseBook/0206_SLinkList/SLinkList.cpp new file mode 100644 index 0000000..8884b59 --- /dev/null +++ b/Dev-C++/CourseBook/0206_SLinkList/SLinkList.cpp @@ -0,0 +1,470 @@ +/*================================= + * ̬ + * + * 㷨: 2.132.142.152.16 + ==================================*/ + +#include "SLinkList.h" + +/* + * ʾ + * + * кβУ + * spaceָʾÿռ + * S ָʾ̬ͷ + */ + +/* ÿռ */ + +/* + * 㷨2.14 + * + * ʼÿռ + * + * ÿռΪ̬ṩõڴ档 + */ +void InitSpace(SLinkList space) { + int i; + + for(i = 0; i < MAXSIZE - 1; ++i) { + space[i].cur = i + 1; + } + + space[MAXSIZE - 1].cur = 0; +} + +/* + * 㷨2.15 + * + * ռ + * + * Ϊ̬ӱÿռռ䣬 + * ɹؿÿռ + * ʧʱ0 + */ +int Malloc(SLinkList space) { + int i = space[0].cur; + + if(i != 0) { + // 뵽Ŀռӱÿռɾȥ + space[0].cur = space[i].cur; + } + + // ± + return i; +} + +/* + * 㷨2.16 + * + * տռ + * + * kĽռԹ̬ã + * շʽǽýռӾ̬Ƴ + * ӵÿռбС + */ +void Free(SLinkList space, int k) { + space[k].cur = space[0].cur; + space[0].cur = k; +} + + +/* ̬ */ + +/* + * ʼ + * + * ȳʼÿռ䣬ӱÿռͷĿռ䣬ɾ̬ijʼ + * ʼɹʹS洢ͷҷOK򷵻ERROR + */ +Status InitList(SLinkList space, int* S) { + int index; + + // ʼÿռ + InitSpace(space); + + // ͷռ + index = Malloc(space); + + if(index == 0) { + return ERROR; + } + + space[index].cur = 0; + + *S = index; + + return OK; +} + +/* + * (ṹ) + * + * ͷž̬ռڴ棬̬нռ뱸ÿռбС + */ +Status DestroyList(SLinkList space, int* S) { + int cur; + + // ȷ̬ + if(S == NULL || *S == 0) { + return ERROR; + } + + while(*S != 0) { + // ݴһ + cur = space[*S].cur; + // յǰռռ + Free(space, *S); + // ǰһ + *S = cur; + } + + return OK; +} + +/* + * ÿ() + * + * Ҫͷž̬зͷ㴦Ŀռ䡣 + */ +Status ClearList(SLinkList space, int S) { + int P; + int cur; + + // ȷ̬ + if(S == 0) { + return ERROR; + } + + // ȡ̬׸ + P = space[S].cur; + + while(P != 0) { + // ݴһ + cur = space[P].cur; + // յǰռռ + Free(space, P); + // ǰһ + P = cur; + } + + space[S].cur = 0; + + return OK; +} + +/* + * п + * + * жϾ̬ǷЧݡ + * + * ֵ + * TRUE : ̬Ϊ + * FALSE: ̬Ϊ + */ +Status ListEmpty(SLinkList space, int S) { + // ֻͷľ̬Ϊձ + if(S != 0 && space[S].cur == 0) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * + * + * ؾ̬ЧԪص + */ +int ListLength(SLinkList space, int S) { + int count; + + // ̬ڣ̬Ϊʱ0 + if(S == 0 || space[S].cur == 0) { + return 0; + } + + // ȡ̬׸Ԫص + S = space[S].cur; + count = 0; + + while(S != 0) { + count++; + S = space[S].cur; + } + + return count; +} + +/* + * ȡֵ + * + * ȡ̬еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SLinkList space, int S, int i, ElemType* e) { + int count; + + // ȷ̬ҲΪ + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // ȡ̬׸Ԫص + S = space[S].cur; + count = 0; + + while(S != 0 && count < i - 1) { + count++; + S = space[S].cur; + } + + if(S == 0 || count > i - 1) { + return ERROR; + } + + *e = space[S].data; + + return OK; +} + +/* + * 㷨2.13 + * + * + * + * ؾ̬׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * 1.ԪeCompareڶβ + * 2.ʵ̲ϵ㷨2.13ͬԭμġע⡱Ϣ + */ +int LocateElem(SLinkList space, int S, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + int p; + + // ȷ̬ҲΪ + if(S == 0 || space[S].cur == 0) { + return 0; + } + + i = 1; // iijֵΪ1Ԫصλ + p = space[S].cur; // pijֵΪ1Ԫص + + while(p != 0 && !Compare(space[p].data, e)) { + i++; + p = space[p].cur; + } + + if(p != 0) { + return i; + } else { + return 0; + } +} + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(SLinkList space, int S, ElemType cur_e, ElemType* pre_e) { + int pre, next; + + // ȷ̬ҲΪ + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // ָ1Ԫ + pre = space[S].cur; + + // 1Ԫûǰ + if(space[pre].data == cur_e) { + return ERROR; + } + + // ָ2Ԫ + next = space[pre].cur; + + // ӵ2Ԫؿʼcur_eλ + while(next != 0 && space[next].data != cur_e) { + pre = next; + next = space[next].cur; + } + + // ûҵԪcur_eʧܣERROR + if(next == 0) { + return ERROR; + } + + *pre_e = space[pre].data; + + return OK; +} + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(SLinkList space, int S, ElemType cur_e, ElemType* next_e) { + int pre; + + // ȷ̬ҲΪ + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // ָ1Ԫ + pre = space[S].cur; + + // ӵ1Ԫؿʼcur_eλãұ֤ýĺ̴ + while(space[pre].cur != 0 && space[pre].data != cur_e) { + pre = space[pre].cur; + } + + // ûҵcur_eҵˣûк̣ERROR + if(space[pre].cur == 0) { + return ERROR; + } + + *next_e = space[space[pre].cur].data; + + return OK; +} + +/* + * + * + * ̬iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SLinkList space, int S, int i, ElemType e) { + int p, s; + int j; + + // ȷ̬ + if(S == 0) { + return ERROR; + } + + p = S; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾 + while(p != 0 && j < i - 1) { + p = space[p].cur; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == 0 || j > i - 1) { + return ERROR; + } + + // ½ + s = Malloc(space); + space[s].data = e; + space[s].cur = space[p].cur; + space[p].cur = s; + + return OK; +} + +/* + * ɾ + * + * ɾ̬iλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(SLinkList space, int S, int i, ElemType* e) { + int p, q; + int j; + + // ȷ̬ + if(S == 0) { + return ERROR; + } + + p = S; + j = 0; + + // Ѱҵi-1㣬ұ֤ýĺ̴ + while(space[p].cur != 0 && j < i - 1) { + p = space[p].cur; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(space[p].cur == 0 || j > i - 1) { + return ERROR; + } + + // ɾi + q = space[p].cur; + space[p].cur = space[q].cur; + *e = space[q].data; + Free(space, q); + + return OK; +} + +/* + * + * + * visitʾ̬S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)) { + int p; + + // ȷ + if(S == 0 || space[S].cur == 0) { + return; + } + + p = space[S].cur; + + while(p != 0) { + Visit(space[p].data); + p = space[p].cur; + } + + printf("\n"); +} + + +/* ͼλ */ + +// ͼλʽǰṹڲʹ +void PrintGraph(SLinkList space, int S) { + int i = 0; + + printf("==== ÿռ ====\n"); + while(i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } + + printf("==== ̬ ====\n"); + i = S; + while(i>0 && i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } +} + diff --git a/Dev-C++/CourseBook/0206_SLinkList/SLinkList.dev b/Dev-C++/CourseBook/0206_SLinkList/SLinkList.dev new file mode 100644 index 0000000..3dc6ffd --- /dev/null +++ b/Dev-C++/CourseBook/0206_SLinkList/SLinkList.dev @@ -0,0 +1,82 @@ +[Project] +FileName=SLinkList.dev +Name=SLinkList +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 + +[Unit3] +FileName=SLinkList-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit1] +FileName=SLinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=SLinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0206_SLinkList/SLinkList.h b/Dev-C++/CourseBook/0206_SLinkList/SLinkList.h new file mode 100644 index 0000000..c511f6c --- /dev/null +++ b/Dev-C++/CourseBook/0206_SLinkList/SLinkList.h @@ -0,0 +1,208 @@ +/*================================= + * ̬ + * + * 㷨: 2.132.142.152.16 + ==================================*/ + +#ifndef SLINKLIST_H +#define SLINKLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define MAXSIZE 1000 // ÿռھ̬󳤶 + +/* ̬ԪͶ */ +typedef int ElemType; + +/* + * ̬ṹ + * + * ע̬һ飬ռÿռͿпռ + */ +typedef struct SLinkNode { + ElemType data; + int cur; // curαָ꣬ãһ㣨±꣩ +} SLinkList[MAXSIZE]; // ռ + + +/* + * ʾ + * + * кβУ + * spaceָʾÿռ + * S ָʾ̬ͷ + */ + +/* + * ע + * + * ̲㷨2.13㷨2.14~2.17ж漰̬IJ + * 㷨Ԥݽṹȴͬ + * + * 㷨2.13Ԥ鶼Ǿ̬() + * 㷨2.14~2.17ֻǽԤΪÿռ䣬 + * ̬ռǻڱÿռͷŵ() + * + * ʵֵĴУ㷨2.14~2.17ԤݽṹΪ׼ + * ԣ㷨2.13ʵֻн̲ͬ + */ + + +/* ÿռ */ + +/* + * 㷨2.14 + * + * ʼÿռ + * + * ÿռΪ̬ṩõڴ档 + */ +void InitSpace(SLinkList space); + +/* + * 㷨2.15 + * + * ռ + * + * Ϊ̬ӱÿռռ䣬 + * ɹؿÿռ + * ʧʱ0 + */ +int Malloc(SLinkList space); + +/* + * 㷨2.16 + * + * տռ + * + * kĽռԹ̬ã + * շʽǽýռӾ̬Ƴ + * ӵÿռбС + */ +void Free(SLinkList space, int k); + + +/* ̬ */ + +/* + * ʼ + * + * ȳʼÿռ䣬ӱÿռͷĿռ䣬ɾ̬ijʼ + * ʼɹʹS洢ͷҷOK򷵻ERROR + */ +Status InitList(SLinkList space, int* S); + +/* + * (ṹ) + * + * ͷž̬ռڴ棬̬нռ뱸ÿռбС + */ +Status DestroyList(SLinkList space, int* S); + +/* + * ÿ() + * + * Ҫͷž̬зͷ㴦Ŀռ䡣 + */ +Status ClearList(SLinkList space, int S); + +/* + * п + * + * жϾ̬ǷЧݡ + * + * ֵ + * TRUE : ̬Ϊ + * FALSE: ̬Ϊ + */ +Status ListEmpty(SLinkList space, int S); + +/* + * + * + * ؾ̬ЧԪص + */ +int ListLength(SLinkList space, int S); + +/* + * ȡֵ + * + * ȡ̬еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SLinkList space, int S, int i, ElemType* e); + +/* + * 㷨2.13 + * + * + * + * ؾ̬׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * 1.ԪeCompareڶβ + * 2.ʵ̲ϵ㷨2.13ͬԭμġע⡱Ϣ + */ +int LocateElem(SLinkList space, int S, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(SLinkList space, int S, ElemType cur_e, ElemType* pre_e); + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(SLinkList space, int S, ElemType cur_e, ElemType* next_e); + +/* + * + * + * ̬iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SLinkList space, int S, int i, ElemType e); + +/* + * ɾ + * + * ɾ̬iλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(SLinkList space, int S, int i, ElemType* e); + +/* + * + * + * visitʾ̬S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)); + + +/* ͼλ */ + +// ͼλʽǰṹڲʹ +void PrintGraph(SLinkList space, int S); + +#endif diff --git a/Dev-C++/CourseBook/0207_Difference/Difference-main.cpp b/Dev-C++/CourseBook/0207_Difference/Difference-main.cpp new file mode 100644 index 0000000..f4a0208 --- /dev/null +++ b/Dev-C++/CourseBook/0207_Difference/Difference-main.cpp @@ -0,0 +1,19 @@ +#include +#include "Difference.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SLinkList space; // ÿռ + int S; // ̬ + + printf("S = (A-B)(B-A) = "); + difference("TestData.txt", space, &S); + ListTraverse(space, S, PrintElem); + + return 0; +} diff --git a/Dev-C++/CourseBook/0207_Difference/Difference.cpp b/Dev-C++/CourseBook/0207_Difference/Difference.cpp new file mode 100644 index 0000000..3327485 --- /dev/null +++ b/Dev-C++/CourseBook/0207_Difference/Difference.cpp @@ -0,0 +1,95 @@ +/*=============== + * ̬ȥ + * + * 㷨: 2.17 + ================*/ + +#include "Difference.h" + +/* + * 㷨2.17 + * + * S = (A-B)(B-A) + * + * ԼAͼB(A-B)(B-A)㣬뾲̬S + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + */ +void difference(char path[], SLinkList space, int* S) { + FILE* fp; + int m, n; // AͼBԪ + int j; // ѭ + int R; // ָ̬һ + int i, k, p; + int b; // ʱ洢ӼBж + + // ʼÿռ + InitSpace(space); + + // ȡ̬ͷ + *S = Malloc(space); + + // Rִо̬Ľ + R = *S; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + exit(ERROR); + } + + // ȡAͼBԪظ + ReadData(fp, "%d%d", &m, &n); + + // ¼뼯A + for(j = 1; j <= m; ++j) { + // + i = Malloc(space); + + // 뼯AԪֵ + ReadData(fp, "%d", &space[i].data); + + // ½뵽β + space[R].cur = i; + R = i; + } + + // βָÿ + space[R].cur = 0; + + // ¼뼯B + for(j = 1; j <= n; ++j) { + // 뼯BԪֵ + ReadData(fp, "%d", &b); + + p = *S; // ָ̬ͷ㣬ָkǰһλ + k = space[*S].cur; // ָ̬е׸Ԫ + + // ڵǰ̬вǷbԪ + while(k != space[R].cur && space[k].data != b) { + p = k; + k = space[k].cur; + } + + // Ԫزڣ뾲̬ + if(k == space[R].cur) { + i = Malloc(space); + space[i].data = b; + space[i].cur = space[R].cur; + space[R].cur = i; + + // ԪѴڣҪƳ + } else { + space[p].cur = space[k].cur; + Free(space, k); + if(R == k) { + R = p; + } + } + } + + fclose(fp); +} \ No newline at end of file diff --git a/Dev-C++/CourseBook/0207_Difference/Difference.dev b/Dev-C++/CourseBook/0207_Difference/Difference.dev new file mode 100644 index 0000000..6d16bee --- /dev/null +++ b/Dev-C++/CourseBook/0207_Difference/Difference.dev @@ -0,0 +1,111 @@ +[Project] +FileName=Difference.dev +Name=Difference +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=6 + +[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 + +[Unit3] +FileName=Difference-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit1] +FileName=Difference.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit4] +FileName=SLinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=Difference.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit5] +FileName=SLinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit6] +FileName=TestData.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0207_Difference/Difference.h b/Dev-C++/CourseBook/0207_Difference/Difference.h new file mode 100644 index 0000000..b7d9164 --- /dev/null +++ b/Dev-C++/CourseBook/0207_Difference/Difference.h @@ -0,0 +1,28 @@ +/*=============== + * ̬ȥ + * + * 㷨: 2.17 + ================*/ + +#ifndef DIFFERENCE_H +#define DIFFERENCE_H + +#include +#include "Status.h" //**01 **// +#include "SLinkList.h" //**02 Ա**// + +/* + * 㷨2.17 + * + * S = (A-B)(B-A) + * + * ԼAͼB(A-B)(B-A)㣬뾲̬S + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + */ +void difference(char path[], SLinkList space, int* S); + +#endif diff --git a/Dev-C++/CourseBook/0207_Difference/SLinkList.cpp b/Dev-C++/CourseBook/0207_Difference/SLinkList.cpp new file mode 100644 index 0000000..624e0ea --- /dev/null +++ b/Dev-C++/CourseBook/0207_Difference/SLinkList.cpp @@ -0,0 +1,116 @@ +/*================================= + * ̬ + * + * 㷨: 2.132.142.152.16 + ==================================*/ + +#include "SLinkList.h" + +/* + * ʾ + * + * кβУ + * spaceָʾÿռ + * S ָʾ̬ͷ + */ + +/* ÿռ */ + +/* + * 㷨2.14 + * + * ʼÿռ + * + * ÿռΪ̬ṩõڴ档 + */ +void InitSpace(SLinkList space) { + int i; + + for(i = 0; i < MAXSIZE - 1; ++i) { + space[i].cur = i + 1; + } + + space[MAXSIZE - 1].cur = 0; +} + +/* + * 㷨2.15 + * + * ռ + * + * Ϊ̬ӱÿռռ䣬 + * ɹؿÿռ + * ʧʱ0 + */ +int Malloc(SLinkList space) { + int i = space[0].cur; + + if(i != 0) { + // 뵽Ŀռӱÿռɾȥ + space[0].cur = space[i].cur; + } + + // ± + return i; +} + +/* + * 㷨2.16 + * + * տռ + * + * kĽռԹ̬ã + * շʽǽýռӾ̬Ƴ + * ӵÿռбС + */ +void Free(SLinkList space, int k) { + space[k].cur = space[0].cur; + space[0].cur = k; +} + + +/* ̬ */ + +/* + * + * + * visitʾ̬S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)) { + int p; + + // ȷ + if(S == 0 || space[S].cur == 0) { + return; + } + + p = space[S].cur; + + while(p != 0) { + Visit(space[p].data); + p = space[p].cur; + } + + printf("\n"); +} + + +/* ͼλ */ + +// ͼλʽǰṹڲʹ +void PrintGraph(SLinkList space, int S) { + int i = 0; + + printf("==== ÿռ ====\n"); + while(i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } + + printf("==== ̬ ====\n"); + i = S; + while(i>0 && i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } +} diff --git a/Dev-C++/CourseBook/0207_Difference/SLinkList.h b/Dev-C++/CourseBook/0207_Difference/SLinkList.h new file mode 100644 index 0000000..d92bdf6 --- /dev/null +++ b/Dev-C++/CourseBook/0207_Difference/SLinkList.h @@ -0,0 +1,89 @@ +/*================================= + * ̬ + * + * 㷨: 2.132.142.152.16 + ==================================*/ + +#ifndef SLINKLIST_H +#define SLINKLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define MAXSIZE 1000 // ÿռھ̬󳤶 + +/* ̬ԪͶ */ +typedef int ElemType; + +/* + * ̬ṹ + * + * ע̬һ飬ռÿռͿпռ + */ +typedef struct SLinkLNode { + ElemType data; + int cur; // curαָ꣬ãһ㣨±꣩ +} SLinkList[MAXSIZE]; // ռ + + +/* + * ʾ + * + * кβУ + * spaceָʾÿռ + * S ָʾ̬ͷ + */ + + +/* ÿռ */ + +/* + * 㷨2.14 + * + * ʼÿռ + * + * ÿռΪ̬ṩõڴ档 + */ +void InitSpace(SLinkList space); + +/* + * 㷨2.15 + * + * ռ + * + * Ϊ̬ӱÿռռ䣬 + * ɹؿÿռ + * ʧʱ0 + */ +int Malloc(SLinkList space); + +/* + * 㷨2.16 + * + * տռ + * + * kĽռԹ̬ã + * շʽǽýռӾ̬Ƴ + * ӵÿռбС + */ +void Free(SLinkList space, int k); + + +/* ̬ */ + +/* + * + * + * visitʾ̬S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)); + + +/* ͼλ */ + +// ͼλʽǰṹڲʹ +void PrintGraph(SLinkList space, int S); + +#endif diff --git a/Dev-C++/CourseBook/0207_Difference/TestData.txt b/Dev-C++/CourseBook/0207_Difference/TestData.txt new file mode 100644 index 0000000..93de27f --- /dev/null +++ b/Dev-C++/CourseBook/0207_Difference/TestData.txt @@ -0,0 +1,4 @@ +Aijȣ3 +Bijȣ5 +AԪأ2 3 4 +BԪأ1 3 4 6 7 \ No newline at end of file diff --git a/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList-main.cpp b/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList-main.cpp new file mode 100644 index 0000000..90cbb4f --- /dev/null +++ b/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList-main.cpp @@ -0,0 +1,149 @@ +#include +#include "Status.h" +#include "DuLinkList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + DuLinkList L; + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼ˫ѭ L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" L %d λò \"%d\" ...\n", i, 2 * i); + ListInsert(L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + printf(" L ijΪ %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأL = "); + ListTraverse(L, PrintElem); + + printf(" ɾ L е 6 Ԫ...\n"); + + if(ListDelete(L, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" GetElem \n"); + { + GetElem(L, 4, &e); + printf(" L е 4 λõԪΪ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + GetElem(L, i, &e); + printf(" L еһԪֵ \"7\" Ԫ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" L ǰ"); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + + ClearList(L); + + printf(" L "); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" L ǰ"); + L ? printf(" L ڣ\n") : printf(" L ڣ\n"); + + DestroyList(&L); + + printf(" L "); + L ? printf(" L ڣ\n") : printf(" L ڣ\n"); + } + PressEnterToContinue(); + + return 0; +} diff --git a/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.cpp b/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.cpp new file mode 100644 index 0000000..b8ff6b8 --- /dev/null +++ b/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.cpp @@ -0,0 +1,402 @@ +/*===================== + * ˫ѭ + * + * 㷨: 2.182.19 + ======================*/ + +#include "DuLinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(DuLinkList* L) { + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + // ǰͺָ̾ + (*L)->next = (*L)->prior = *L; + + return OK; +} + +/* + * (ṹ) + * + * ͷ˫ѭռڴ档 + */ +Status DestroyList(DuLinkList* L) { + // ȷṹ + if(L == NULL || *L == NULL) { + return ERROR; + } + + ClearList(*L); + + free(*L); + + *L = NULL; + + return OK; +} + +/* + * ÿ() + * + * Ҫͷ˫ѭзͷ㴦Ŀռ䡣 + */ +Status ClearList(DuLinkList L) { + DuLinkList p, q; + + if(L == NULL) { + return ERROR; + } + + p = L->next; + + while(p != L) { + q = p->next; + free(p); + p = q; + } + + L->next = L->prior = L; + + return OK; +} + +/* + * п + * + * ж˫ѭǷЧݡ + * + * ֵ + * TRUE : ˫ѭΪ + * FALSE: ˫ѭΪ + */ +Status ListEmpty(DuLinkList L) { + if(L != NULL && L->next == L && L->prior == L) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * + * + * ˫ѭЧԪص + */ +int ListLength(DuLinkList L) { + DuLinkList p; + int i; + + if(L == NULL || L->next == L || L->prior == L) { + return 0; + } + + i = 0; + p = L->next; + + // н + while(p != L) { + i++; + p = p->next; + } + + return i; +} + +/* + * ȡֵ + * + * ȡ˫ѭеiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(DuLinkList L, int i, ElemType* e) { + DuLinkList p; + int j; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ýĺ̲ΪL + while(p->next != L && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p->next == L || j > i - 1) { + return ERROR; + } + + *e = p->next->data; + + return OK; +} + +/* + * + * + * ˫ѭ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(DuLinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return 0; + } + + i = 1; // iijֵΪ1Ԫصλ + p = L->next; // pijֵΪ1Ԫصָ + + while(p != L && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != L) { + return i; + } else { + return 0; + } +} + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(DuLinkList L, ElemType cur_e, ElemType* pre_e) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // ָ1Ԫ + p = L->next; + + // 1Ԫûǰ + if(p->data == cur_e) { + return ERROR; + } + + // ָ2Ԫ + p = p->next; + + // ӵ2Ԫؿʼcur_eλ + while(p != L && p->data != cur_e) { + p = p->next; + } + + // ûҵԪcur_eʧܣERROR + if(p == L) { + return ERROR; + } + + *pre_e = p->prior->data; + + return OK; +} + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(DuLinkList L, ElemType cur_e, ElemType* next_e) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // ָ1Ԫ + p = L->next; + + // ӵ1Ԫؿʼcur_eλãұ֤ýĺ̲ΪL + while(p->next != L && p->data != cur_e) { + p = p->next; + } + + // ûҵcur_eҵˣûк̣ERROR + if(p->next == L) { + return ERROR; + } + + *next_e = p->next->data; + + return OK; +} + +/* + * 㷨2.18 + * + * + * + * ˫ѭiλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(DuLinkList L, int i, ElemType e) { + DuLinkList p, s; + + // ȷ˫ѭڣΪձ + if(L == NULL) { + return ERROR; + } + + // ҵiλãã + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // ½ + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // s뵽pǰ棬Ϊi + s->prior = p->prior; + p->prior->next = s; + s->next = p; + p->prior = s; + + return OK; +} + +/* + * 㷨2.19 + * + * ɾ + * + * ɾ˫ѭiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(DuLinkList L, int i, ElemType* e) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // ҵiλãã + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // p==L˵ɾԪǵlen+1ԪأϹ + if(p == L) { + return ERROR; + } + + *e = p->data; + + // Ƴp + p->prior->next = p->next; + p->next->prior = p->prior; + + free(p); + + return OK; +} + +/* + * + * + * visit˫ѭL + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return; + } + + p = L->next; + + while(p != L) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * ȡѭLϵiԪص + * + * ע + * 1.staticĺǵǰֻDuLinkListʹãᱻļ + * 2.ΪlenҪȡlen+1ԪصʱѭԷصͷ + */ +static DuLinkList GetElemP(DuLinkList L, int i) { + DuLinkList p; + int count; + + // ȷ˫ѭڣΪձ + if(L == NULL) { + return NULL; + } + + // λòϹ + if(i < 1) { + return NULL; + } + + p = L; + count = 0; + + // ԲҵiԪ + while(p->next != L && count < i) { + p = p->next; + ++count; + } + + // ǡҵiԪ + if(count == i) { + return p; + } + + // ˣ˵p->next==LʱҪжiǷ + if(count + 1 < i) { + return NULL; + } + + // ˣ˵Ҫlen+1λϲԪ + return L; +} diff --git a/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.dev b/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.dev new file mode 100644 index 0000000..d065633 --- /dev/null +++ b/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.dev @@ -0,0 +1,82 @@ +[Project] +FileName=DuLinkList.dev +Name=DuLinkList +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 + +[Unit3] +FileName=DuLinkList-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit1] +FileName=DuLinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=DuLinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.h b/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.h new file mode 100644 index 0000000..0f8810d --- /dev/null +++ b/Dev-C++/CourseBook/0208_DuLinkList/DuLinkList.h @@ -0,0 +1,153 @@ +/*===================== + * ˫ѭ + * + * 㷨: 2.182.19 + ======================*/ + +#ifndef DULINKLIST_H +#define DULINKLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ˫ѭԪͶ */ +typedef int ElemType; + +/* + * ˫ѭṹ + * + * ע˫ѭͷ + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // ǰ + struct DuLNode* next; // +} DuLNode; + +// ָ˫ѭָ +typedef DuLNode* DuLinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(DuLinkList* L); + +/* + * (ṹ) + * + * ͷ˫ѭռڴ档 + */ +Status DestroyList(DuLinkList* L); + +/* + * ÿ() + * + * Ҫͷ˫ѭзͷ㴦Ŀռ䡣 + */ +Status ClearList(DuLinkList L); + +/* + * п + * + * ж˫ѭǷЧݡ + * + * ֵ + * TRUE : ˫ѭΪ + * FALSE: ˫ѭΪ + */ +Status ListEmpty(DuLinkList L); + +/* + * + * + * ˫ѭЧԪص + */ +int ListLength(DuLinkList L); + +/* + * ȡֵ + * + * ȡ˫ѭеiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(DuLinkList L, int i, ElemType* e); + +/* + * + * + * ˫ѭ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(DuLinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(DuLinkList L, ElemType cur_e, ElemType* pre_e); + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(DuLinkList L, ElemType cur_e, ElemType* next_e); + +/* + * 㷨2.18 + * + * + * + * ˫ѭiλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(DuLinkList L, int i, ElemType e); + +/* + * 㷨2.19 + * + * ɾ + * + * ɾ˫ѭiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(DuLinkList L, int i, ElemType* e); + +/* + * + * + * visit˫ѭL + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)); + +/* + * ȡѭLϵiԪص + * + * ע + * 1.staticĺǵǰֻDuLinkListʹãᱻļ + * 2.ΪlenҪȡlen+1ԪصʱѭԷصͷ + */ +static DuLinkList GetElemP(DuLinkList L, int i); + +#endif diff --git a/Dev-C++/CourseBook/0209_ELinkList/ELinkList-main.cpp b/Dev-C++/CourseBook/0209_ELinkList/ELinkList-main.cpp new file mode 100644 index 0000000..7d37082 --- /dev/null +++ b/Dev-C++/CourseBook/0209_ELinkList/ELinkList-main.cpp @@ -0,0 +1,224 @@ +#include +#include "ELinkList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ELinkList L; + Link p, q, s; + Position r; + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼչ L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" L %d λò \"%d\" ...\n", i, 2 * i); + ListInsert(&L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + printf(" L ijΪ %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأL = "); + ListTraverse(L, PrintElem); + + printf(" ɾ L е 6 Ԫ...\n"); + + if(ListDelete(&L, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + r = LocateElem(L, 7, CmpGreater); + printf(" L еһԪֵ \"7\" Ԫ \"%d\" \n", r->data); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + Position pre = PriorPos(L, r); + + if(pre !=NULL) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", r->data, pre->data); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", r->data); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + Position next = NextPos(L, r); + + if(next !=NULL) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", r->data, next->data); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", r->data); + } + } + PressEnterToContinue(); + + + printf(" MakeNode \n"); + { + printf(" \"100\" ...\n"); + MakeNode(&p, 100); + printf(" \"200\" ...\n"); + MakeNode(&q, 200); + printf(" \"300\" ...\n"); + MakeNode(&s, 300); + } + PressEnterToContinue(); + + + printf(" InsFirst \n"); + { + printf(" Ԫ \"%d\" 뵽Ԫ \"%d\" ֮...\n", s->data, r->data); + InsFirst(&L, r, s); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" DelFirst \n"); + { + printf(" ɾԪ \"%d\" ֮Ԫ...\n", r->data); + DelFirst(&L, r, &s); + printf(" ɾԪΪ\"%d\"\n", s->data); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" InsBefore \n"); + { + Link t = r; + + printf(" Ԫ \"%d\" 뵽Ԫ \"%d\" ֮ǰ...\n", p->data, t->data); + InsBefore(&L, &t, p); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" InsAfter \n"); + { + Link t = r; + + printf(" Ԫ \"%d\" 뵽Ԫ \"%d\" ֮...\n", q->data, t->data); + InsAfter(&L, &t, q); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" Append \n"); + { + printf(" \"400\" ...\n"); + MakeNode(&s, 400); + + printf(" Ԫ %d 뵽...\n", s->data); + Append(&L, s); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" Remove \n"); + { + printf(" ɾԪ...\n"); + Remove(&L, &s); + printf(" ɾԪΪ\"%d\"\n", s->data); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" L ǰ"); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + + ClearList(&L); + + printf(" L "); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" L ǰ"); + L.head != NULL && L.tail != NULL ? printf(" L ڣ\n") : printf(" L ڣ\n"); + + DestroyList(&L); + + printf(" L "); + L.head != NULL && L.tail != NULL ? printf(" L ڣ\n") : printf(" L ڣ\n"); + + } + PressEnterToContinue(); + + return 0; +} + diff --git a/Dev-C++/CourseBook/0209_ELinkList/ELinkList.cpp b/Dev-C++/CourseBook/0209_ELinkList/ELinkList.cpp new file mode 100644 index 0000000..c77bc91 --- /dev/null +++ b/Dev-C++/CourseBook/0209_ELinkList/ELinkList.cpp @@ -0,0 +1,630 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#include "ELinkList.h" //**02 Ա**// + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // ռ + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // û˳򣬶Ƿشʾ + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // ͷ + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // ֻͷʱλαָ + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(ELinkList* L) { + + // ʱûҪ + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + ClearList(L); + + free((*L).head); + + (*L).head = (*L).tail = NULL; + + return OK; +} + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(ELinkList* L) { + Link p, q; + + // ûЧԪʱҪ + if(L == NULL || (*L).head == NULL || (*L).len <= 0) { + return ERROR; + } + + // ָ1Ԫ + p = (*L).head->next; + + // ͷԪռڴ + while(p != NULL) { + q = p->next; + free(p); + p = q; + } + + (*L).head->next = NULL; + (*L).tail = (*L).head; + (*L).len = 0; + + return OK; +} + +/* + * п + * + * жǷЧݡ + * + * ֵ + * TRUE : Ϊ + * FALSE: Ϊ + */ +Status ListEmpty(ELinkList L) { + if(L.len <= 0) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * + * + * ЧԪص + */ +int ListLength(ELinkList L) { + return L.len; +} + +/* + * + * + * ׸eCompareϵԪá + * Ԫأ򷵻NULL + * + *ע + * 1.ԪeCompareڶβ + * 2.ķֵĿԪصãλ + */ +Position LocateElem(ELinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + Position p; + + if(L.len <= 0) { + return NULL; + } + + // ָ1Ԫ + p = L.head->next; + + while(p != NULL && !Compare(p->data, e)) { + p = p->next; + } + + return p; +} + +/* + * 㷨2.20 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.9ĸд + */ +Status ListInsert(ELinkList* L, int i, ElemType e) { + Link h, s; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // ȷiֵϹ[1, len+1] + if(i < 1 || i > (*L).len + 1) { + return ERROR; + } + + // ҵi-1Ԫصã洢h + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // ½s + if(MakeNode(&s, e) == ERROR) { + return ERROR; + } + + // s뵽h棬Ϊhĵһ + if(InsFirst(L, h, s) == ERROR) { + return ERROR; + } + + return OK; +} + +/* + * ɾ + * + * ɾiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.10ĸд + */ +Status ListDelete(ELinkList* L, int i, ElemType* e) { + Link h, q; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // ȷiֵϹ[1, len] + if(i < 1 || i > (*L).len) { + return ERROR; + } + + // ҵi-1Ԫصã洢h + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // ɾhĵһ㣬q洢ɾ + if(DelFirst(L, h, &q) == ERROR) { + return ERROR; + } + + // ±ɾԪصֵ + *e = q->data; + + // ͷűɾĿռ + FreeNode(&q); + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)) { + Link p; + + if(L.len <= 0) { + return; + } + + // ָ1Ԫ + p = L.head->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p) { + if(p == NULL) { + return INT_MIN; + } + + return p->data; +} + +/* + * ֵ + * + * ΪpԪֵ + */ +Status SetCurElem(Link p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + p->data = e; + + return OK; +} + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * β + * + * ȡβá + */ +Position GetLast(ELinkList L) { + return L.tail; +} + +/* + * ǰ + * + * ȡpǰڣ򷵻NULL + */ +Position PriorPos(ELinkList L, Link p) { + Link pre; + + // ȷ(ͷ) + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + // ָͷ + pre = L.head; + + // һǰ + if(pre->next == p) { + return NULL; + } + + // Pǰ + while(pre != NULL && pre->next != p) { + pre = pre->next; + } + + return pre; +} + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p) { + + // ȷ(ͷ) + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * + * + * Lеi(Ϊ0)㣬ôpҷOK + * iֵϹ棬򷵻ERROR + * رע⣬iΪ0ʱp洢ͷ + */ +Status LocatePos(ELinkList L, int i, Link* p) { + int j; + Link r; + + // עiΪ0 + if(i < 0 || i > L.len) { + return ERROR; + } + + // ֤(ͷ) + if(L.head == NULL) { + return ERROR; + } + + // iΪ0ʱȡͷ + if(i == 0) { + *p = L.head; + return OK; + } + + j = 0; // + r = L.head; // ָͷ + + while(r != NULL && j < i) { + j++; + r = r->next; + } + + if(r == NULL) { + return ERROR; + } + + *p = r; + + return OK; +} + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // hΪβ㣬Ҫβ + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // ûнɾشϢ + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // ɾɹĽ + (*q)->next = NULL; + + // hֻһ㣬βָ + if(h->next == NULL) { + (*L).tail = h; + } + + // ͷűɾռռ + (*L).len--; + + return OK; +} + +/* + * ǰ + * + * s뵽p֮ǰpָ½ + */ +Status InsBefore(ELinkList* L, Link* p, Link s) { + Link pre; + + if(L == NULL || (*L).head == NULL || p == NULL || s == NULL) { + return ERROR; + } + + // ָͷ + pre = (*L).head; + + // pĹǰڵһԪأǰΪͷ + while(pre != NULL && pre->next != (*p)) { + pre = pre->next; + } + + // ûҵǰ + if(pre == NULL) { + return ERROR; + } + + s->next = *p; + pre->next = s; + *p = s; + + (*L).len++; //޸lenõ*L + + return OK; +} + +/* + * + * + * s뵽p֮ǰpָ½ + */ +Status InsAfter(ELinkList* L, Link* p, Link s) { + Link r; + + if(L == NULL || (*L).head == NULL || p == NULL || s == NULL) { + return ERROR; + } + + r = (*L).head; + + while(r != NULL && r != (*p)) { + r = r->next; + } + + // δҵpشϢ + if(r == NULL) { + return ERROR; + } + + // pָһ㣬Ҫβָ + if(*p == (*L).tail) { + (*L).tail = s; + } + + s->next = (*p)->next; + (*p)->next = s; + *p = s; + + (*L).len++; + + return OK; +} + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // ȷµβλ + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} + +/* + * βƳ + * + * βƳƳĽô洢q + */ +Status Remove(ELinkList* L, Link* q) { + Link p; + + if(L == NULL || (*L).head == NULL || q == NULL) { + return ERROR; + } + + // ûԪؿɹƳ + if((*L).len == 0) { + *q = NULL; + return ERROR; + } + + *q = (*L).tail; + + // ȷµβλ + p = (*L).head; + while(p->next != (*L).tail) { + p = p->next; + } + p->next = NULL; + (*L).tail = p; + + (*L).len--; + + return OK; +} diff --git a/Dev-C++/CourseBook/0209_ELinkList/ELinkList.dev b/Dev-C++/CourseBook/0209_ELinkList/ELinkList.dev new file mode 100644 index 0000000..c72b172 --- /dev/null +++ b/Dev-C++/CourseBook/0209_ELinkList/ELinkList.dev @@ -0,0 +1,82 @@ +[Project] +FileName=ELinkList.dev +Name=ELinkList +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 + +[Unit3] +FileName=ELinkList-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit1] +FileName=ELinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=ELinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0209_ELinkList/ELinkList.h b/Dev-C++/CourseBook/0209_ELinkList/ELinkList.h new file mode 100644 index 0000000..e988542 --- /dev/null +++ b/Dev-C++/CourseBook/0209_ELinkList/ELinkList.h @@ -0,0 +1,253 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩһЩ޳ +#include "Status.h" //**01 **// + +/* + * ע + * + * ̲еΪLinkList + * Ϊ뵥֣ʽΪELinkList + * ɶͨһչ + */ + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עͷ + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* άͷβָ뼰Ϣ */ +typedef struct { + Link head, tail; // ֱָеͷβ + int len; // ָʾԪصĸ +} ELinkList; + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e); + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p); + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L); + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(ELinkList* L); + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(ELinkList* L); + +/* + * п + * + * жǷЧݡ + * + * ֵ + * TRUE : Ϊ + * FALSE: Ϊ + */ +Status ListEmpty(ELinkList L); + +/* + * + * + * ЧԪص + */ +int ListLength(ELinkList L); + +/* + * + * + * ׸eCompareϵԪá + * Ԫأ򷵻NULL + * + *ע + * 1.ԪeCompareڶβ + * 2.ķֵĿԪصãλ + */ +Position LocateElem(ELinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 㷨2.20 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.9ĸд + */ +Status ListInsert(ELinkList* L, int i, ElemType e); + +/* + * ɾ + * + * ɾiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.10ĸд + */ +Status ListDelete(ELinkList* L, int i, ElemType* e); + +/* + * + * + * visitL + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)); + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p); + +/* + * ֵ + * + * ΪpԪֵ + */ +Status SetCurElem(Link p, ElemType e); + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L); + +/* + * β + * + * ȡβá + */ +Position GetLast(ELinkList L); + +/* + * ǰ + * + * ȡpǰڣ򷵻NULL + */ +Position PriorPos(ELinkList L, Link p); + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p); + +/* + * + * + * Lеi(Ϊ0)㣬ôpҷOK + * iֵϹ棬򷵻ERROR + * رע⣬iΪ0ʱp洢ͷ + */ +Status LocatePos(ELinkList L, int i, Link* p); + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * ǰ + * + * s뵽p֮ǰpָ½ + */ +Status InsBefore(ELinkList* L, Link* p, Link s); + +/* + * + * + * s뵽p֮ǰpָ½ + */ +Status InsAfter(ELinkList* L, Link* p, Link s); + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s); + +/* + * βƳ + * + * βƳƳĽô洢q + */ +Status Remove(ELinkList* L, Link* q); + +#endif diff --git a/Dev-C++/CourseBook/0210_MergeEList/ELinkList.cpp b/Dev-C++/CourseBook/0210_MergeEList/ELinkList.cpp new file mode 100644 index 0000000..fe46f87 --- /dev/null +++ b/Dev-C++/CourseBook/0210_MergeEList/ELinkList.cpp @@ -0,0 +1,324 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#include "ELinkList.h" //**02 Ա**// + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // ռ + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // û˳򣬶Ƿشʾ + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // ͷ + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // ֻͷʱλαָ + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * 㷨2.20 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.9ĸд + */ +Status ListInsert(ELinkList* L, int i, ElemType e) { + Link h, s; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // ȷiֵϹ[1, len+1] + if(i < 1 || i > (*L).len + 1) { + return ERROR; + } + + // ҵi-1Ԫصã洢h + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // ½s + if(MakeNode(&s, e) == ERROR) { + return ERROR; + } + + // s뵽h棬Ϊhĵһ + if(InsFirst(L, h, s) == ERROR) { + return ERROR; + } + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)) { + Link p; + + if(L.len <= 0) { + return; + } + + // ָ1Ԫ + p = L.head->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p) { + if(p == NULL) { + return INT_MIN; + } + + return p->data; +} + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p) { + + // ȷ(ͷ) + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * + * + * Lеi(Ϊ0)㣬ôpҷOK + * iֵϹ棬򷵻ERROR + * رע⣬iΪ0ʱp洢ͷ + */ +Status LocatePos(ELinkList L, int i, Link* p) { + int j; + Link r; + + // עiΪ0 + if(i < 0 || i > L.len) { + return ERROR; + } + + // ֤(ͷ) + if(L.head == NULL) { + return ERROR; + } + + // iΪ0ʱȡͷ + if(i == 0) { + *p = L.head; + return OK; + } + + j = 0; // + r = L.head; // ָͷ + + while(r != NULL && j < i) { + j++; + r = r->next; + } + + if(r == NULL) { + return ERROR; + } + + *p = r; + + return OK; +} + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // hΪβ㣬Ҫβ + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // ûнɾشϢ + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // ｫɾɹĽ + (*q)->next = NULL; + + // hֻһ㣬βָ + if(h->next == NULL) { + (*L).tail = h; + } + + // ͷűɾռռ + (*L).len--; + + return OK; +} + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // ȷµβλ + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} diff --git a/Dev-C++/CourseBook/0210_MergeEList/ELinkList.h b/Dev-C++/CourseBook/0210_MergeEList/ELinkList.h new file mode 100644 index 0000000..1bfb4e6 --- /dev/null +++ b/Dev-C++/CourseBook/0210_MergeEList/ELinkList.h @@ -0,0 +1,155 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩһЩ޳ +#include "Status.h" //**01 **// + +/* + * ע + * + * ̲еΪLinkList + * Ϊ뵥֣ʽΪELinkList + * ɶͨһչ + */ + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עͷ + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* άͷβָ뼰Ϣ */ +typedef struct { + Link head, tail; // ֱָеͷβ + int len; // ָʾԪصĸ +} ELinkList; + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e); + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p); + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L); + +/* + * 㷨2.20 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.9ĸд + */ +Status ListInsert(ELinkList* L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)); + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p); + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L); + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p); + +/* + * + * + * Lеi(Ϊ0)㣬ôpҷOK + * iֵϹ棬򷵻ERROR + * رע⣬iΪ0ʱp洢ͷ + */ +Status LocatePos(ELinkList L, int i, Link* p); + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s); + +#endif diff --git a/Dev-C++/CourseBook/0210_MergeEList/MergeEList-main.cpp b/Dev-C++/CourseBook/0210_MergeEList/MergeEList-main.cpp new file mode 100644 index 0000000..b5fbcd5 --- /dev/null +++ b/Dev-C++/CourseBook/0210_MergeEList/MergeEList-main.cpp @@ -0,0 +1,71 @@ +#include +#include "MergeEList.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + +/* + * Ƚ + * + * Ƚe1e2ĴСֵ£ + * < 0e1 < e2 + * = 0e1 = e2 + * > 0e1 > e2 + */ +int Cmp(ElemType e1, ElemType e2) { + return e1 - e2; +} + +/* + * β巨 + * + *ע + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļfpжȡݡ + */ +void CreateList_Tail(char path[], ELinkList* L) { + FILE* fp; + int i, n; + ElemType e; + + fp = fopen(path, "r"); + if(fp == NULL) { + printf("ļʧ...\n"); + exit(ERROR); + } + + // ȡָԪص + ReadData(fp, "%d", &n); + + InitList(L); + + for(i = 1; i <= n; i++) { + ReadData(fp, "%d", &e); + ListInsert(L, i, e); + } + + fclose(fp); +} + + +int main(int argc, char** argv) { + ELinkList La, Lb, Lc; + + printf("LaLbԴ...\n"); + + CreateList_Tail("TestData_La.txt", &La); + printf("La= "); + ListTraverse(La, PrintElem); + + CreateList_Tail("TestData_Lb.txt", &Lb); + printf("Lb= "); + ListTraverse(Lb, PrintElem); + + MergeEList(&La, &Lb, &Lc, Cmp); + printf("ϲLaLbΪ Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} diff --git a/Dev-C++/CourseBook/0210_MergeEList/MergeEList.cpp b/Dev-C++/CourseBook/0210_MergeEList/MergeEList.cpp new file mode 100644 index 0000000..e445d32 --- /dev/null +++ b/Dev-C++/CourseBook/0210_MergeEList/MergeEList.cpp @@ -0,0 +1,75 @@ +/*=============== + * 鲢ǽ + * + * 㷨: 2.21 + ================*/ + +#include "MergeEList.h" + +Status MergeEList(ELinkList* La, ELinkList* Lb, ELinkList* Lc, int(Compare)(ElemType, ElemType)){ + Link ha, hb, pa, pb, q; + ElemType a, b; + + if(InitList(Lc) == ERROR) { + return ERROR; + } + + ha = GetHead(*La); // ָLaͷ + hb = GetHead(*Lb); // ָLbͷ + + // ֤LaLbЧпǿձ + if(ha == NULL || hb ==NULL) { + return ERROR; + } + + pa = NextPos(*La, ha); // ָLa1Ԫ + pb = NextPos(*La, hb); // ָLb1Ԫ + + // LaLbѡСԪأμ뵽Lc + while(pa !=NULL && pb!=NULL){ + a = GetCurElem(pa); + b = GetCurElem(pb); + + // La<=Lb + if(Compare(a, b)<=0) { + // ժLa׸Ԫ + DelFirst(La, ha, &q); + + // ժµԪ׷ӵLc + Append(Lc, q); + + // ȻǻȡLaе1Ԫ + pa = NextPos(*La, ha); + } else { + // ժLb׸Ԫ + DelFirst(Lb, hb, &q); + + // ժµԪ׷ӵLc + Append(Lc, q); + + // ȻǻȡLaе1Ԫ + pb = NextPos(*Lb, hb); + } + } + + // Laʣ + if(pa!=NULL) { + Append(Lc, pa); + } else { + Append(Lc, pb); + } + + // ͷLaͷ㡣̲Ƕha޷ÿLaͷָ룬޸ + FreeNode(&(La->head)); + + // ͷLbͷ㡣̲Ƕhb޷ÿLbͷָ룬޸ + FreeNode(&(Lb->head)); + + La->tail = NULL; + Lb->tail = NULL; + + La->len = 0; + Lb->len = 0; + + return OK; +} \ No newline at end of file diff --git a/Dev-C++/CourseBook/0210_MergeEList/MergeEList.dev b/Dev-C++/CourseBook/0210_MergeEList/MergeEList.dev new file mode 100644 index 0000000..08e0308 --- /dev/null +++ b/Dev-C++/CourseBook/0210_MergeEList/MergeEList.dev @@ -0,0 +1,120 @@ +[Project] +FileName=MergeEList.dev +Name=MergeEList +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=7 + +[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=ELinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit5] +FileName=MergeEList-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=MergeEList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=ELinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit4] +FileName=MergeEList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit6] +FileName=TestData_La.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit7] +FileName=TestData_Lb.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0210_MergeEList/MergeEList.h b/Dev-C++/CourseBook/0210_MergeEList/MergeEList.h new file mode 100644 index 0000000..5137f17 --- /dev/null +++ b/Dev-C++/CourseBook/0210_MergeEList/MergeEList.h @@ -0,0 +1,36 @@ +/*=============== + * 鲢ǽ + * + * 㷨: 2.21 + ================*/ + +#ifndef MERGEELIST_H +#define MERGEELIST_H + +#include +#include "Status.h" //**01 **// +#include "ELinkList.h" //**02 Ա**// + +/* + * ע + * + * Ϊ֮ǰĹ鲢㷨֣ｫ㷨ΪMergeEList(̲еMergeList_L) + */ + +/* + * 㷨2.21 + * + * ǵݼ鲢C=A+B + * + * AB鲢ΪCұԪλò䡣 + * 鲢󣬻LaLb + */ +Status MergeEList(ELinkList* La, ELinkList* Lb, ELinkList* Lc, int(Compare)(ElemType, ElemType)); + +/* +(01)㷨2.21LaLbǵݼУ鲢ΪһǵݼеĵLc +*/ + + + +#endif diff --git a/Dev-C++/CourseBook/0210_MergeEList/TestData_La.txt b/Dev-C++/CourseBook/0210_MergeEList/TestData_La.txt new file mode 100644 index 0000000..dc09018 --- /dev/null +++ b/Dev-C++/CourseBook/0210_MergeEList/TestData_La.txt @@ -0,0 +1,2 @@ +Aijȣ6 +La = 1 2 3 5 7 8 \ No newline at end of file diff --git a/Dev-C++/CourseBook/0210_MergeEList/TestData_Lb.txt b/Dev-C++/CourseBook/0210_MergeEList/TestData_Lb.txt new file mode 100644 index 0000000..df78f0a --- /dev/null +++ b/Dev-C++/CourseBook/0210_MergeEList/TestData_Lb.txt @@ -0,0 +1,2 @@ +Bijȣ7 +Lb = 2 4 5 8 10 11 13 \ No newline at end of file diff --git a/Dev-C++/CourseBook/0211_Polynomial/ELinkList.cpp b/Dev-C++/CourseBook/0211_Polynomial/ELinkList.cpp new file mode 100644 index 0000000..65ecb40 --- /dev/null +++ b/Dev-C++/CourseBook/0211_Polynomial/ELinkList.cpp @@ -0,0 +1,338 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#include "ELinkList.h" //**02 Ա**// + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // ռ + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // û˳򣬶Ƿشʾ + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // ͷ + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // ֻͷʱλαָ + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(ELinkList* L) { + + // ʱûҪ + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + ClearList(L); + + free((*L).head); + + (*L).head = (*L).tail = NULL; + + return OK; +} + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(ELinkList* L) { + Link p, q; + + // ûЧԪʱҪ + if(L == NULL || (*L).head == NULL || (*L).len <= 0) { + return ERROR; + } + + // ָ1Ԫ + p = (*L).head->next; + + // ͷԪռڴ + while(p != NULL) { + q = p->next; + free(p); + p = q; + } + + (*L).head->next = NULL; + (*L).tail = (*L).head; + (*L).len = 0; + + return OK; +} + +/* + * + * + * ЧԪص + */ +int ListLength(ELinkList L) { + return L.len; +} + +/* + * + * + * Һ봫ͳİ汾һ + * ȻԪeCompare()==0Ԫأҵʹq洢ãTrue + * ã׸ԪeCompare()>0ԪصǰFALSE + * еԪؾeq洢ͷá + * еԪؾСeq洢βá + * £Ὣqÿա + * + *ע + * 1.ԪeCompareڶβ + */ +Status LocateElem(ELinkList L, ElemType e, Position* q, Status(Compare)(ElemType, ElemType)) { + Position pre, p; + + *q = NULL; + + // ڣشϢ + if(L.head == NULL) { + return FALSE; + } + + pre = L.head; + p = pre->next; + + while(p != NULL && Compare(p->data, e) < 0) { + pre = p; + p = p->next; + } + + // ҵe""Ԫ + if(p != NULL && Compare(p->data, e) == 0) { + *q = p; + return TRUE; + } + + // ԪؾСepԪشeֻΪձ + *q = pre; + + return FALSE; +} + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p) { + ElemType e; + + if(p == NULL) { + e.coef = 0.0f; + e.expn = -1; + return e; + } + + return p->data; +} + +/* + * ֵ + * + * ΪpԪֵ + */ +Status SetCurElem(Link p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + p->data = e; + + return OK; +} + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p) { + + // ȷ(ͷ) + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // hΪβ㣬Ҫβ + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // ûнɾشϢ + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // ɾɹĽ + (*q)->next = NULL; + + // hֻһ㣬βָ + if(h->next == NULL) { + (*L).tail = h; + } + + // ͷűɾռռ + (*L).len--; + + return OK; +} + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // ȷµβλ + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} diff --git a/Dev-C++/CourseBook/0211_Polynomial/ELinkList.h b/Dev-C++/CourseBook/0211_Polynomial/ELinkList.h new file mode 100644 index 0000000..44da806 --- /dev/null +++ b/Dev-C++/CourseBook/0211_Polynomial/ELinkList.h @@ -0,0 +1,175 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩһЩ޳ +#include "Status.h" //**01 **// + +/* + * ע + * + * ̲еΪLinkList + * Ϊ뵥֣ʽΪELinkList + * ɶͨһչ + */ + +/* + * ԪͶ + * ڶʽУõ˽ṹ͵Ԫ + */ +typedef struct { + float coef; // ʽϵ + int expn; // ʽָ +} ElemType; // ¶չԱԪ + +/* + * ṹ + * + * עͷ + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* άͷβָ뼰Ϣ */ +typedef struct { + Link head, tail; // ֱָеͷβ + int len; // ָʾԪصĸ +} ELinkList; + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e); + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p); + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L); + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(ELinkList* L); + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(ELinkList* L); + +/* + * + * + * ЧԪص + */ +int ListLength(ELinkList L); + +/* + * + * + * Һ봫ͳİ汾һ + * ȻԪeCompare()==0Ԫأҵʹq洢ãTrue + * ã׸ԪeCompare()>0ԪصǰFALSE + * еԪؾeq洢ͷá + * еԪؾСeq洢βá + * £Ὣqÿա + * + *ע + * 1.ԪeCompareڶβ + */ +Status LocateElem(ELinkList L, ElemType e, Position* q, Status(Compare)(ElemType, ElemType)); + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p); + +/* + * ֵ + * + * ΪpԪֵ + */ +Status SetCurElem(Link p, ElemType e); + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L); + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p); + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s); + +#endif diff --git a/Dev-C++/CourseBook/0211_Polynomial/Polynomial-main.cpp b/Dev-C++/CourseBook/0211_Polynomial/Polynomial-main.cpp new file mode 100644 index 0000000..ab64e6e --- /dev/null +++ b/Dev-C++/CourseBook/0211_Polynomial/Polynomial-main.cpp @@ -0,0 +1,79 @@ +#include "Polynomial.h" //**02 Ա**// + +int main(int argc, char **argv) { + Polynomial Pa, Pb; + int m, n; + + m = 5; + n = 6; + + printf(" CreatPolyn \n"); + { + printf(" ΪʾΪ %d ĶʽPa...\n", m); + CreatPolyn("TestData_Pa.txt", &Pa, m); + + printf(" ΪʾΪ %d ĶʽPb...\n", n); + CreatPolyn("TestData_Pb.txt", &Pb, n); + } + PressEnterToContinue(); + + + printf(" PrintPolyn \n"); + { + printf(" һԪʽ Pa = "); + PrintPolyn(Pa); + + printf(" һԪʽ Pb = "); + PrintPolyn(Pb); + } + PressEnterToContinue(); + + + printf(" PolynLength \n"); + { + printf(" La Ϊ %d Lb Ϊ %d\n", PolynLength(Pa), PolynLength(Pb)); + } + PressEnterToContinue(); + + + printf(" AddPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + AddPolyn(&Pa, &Pb); + + printf(" Pa = Pa + Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + + printf(" SubtractPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + SubtractPolyn(&Pa, &Pb); + + printf(" Pa = Pa - Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + + printf(" MultiplyPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + MultiplyPolyn(&Pa, &Pb); + + printf(" Pa = Pa * Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/Dev-C++/CourseBook/0211_Polynomial/Polynomial.cpp b/Dev-C++/CourseBook/0211_Polynomial/Polynomial.cpp new file mode 100644 index 0000000..b575b3f --- /dev/null +++ b/Dev-C++/CourseBook/0211_Polynomial/Polynomial.cpp @@ -0,0 +1,397 @@ +/*======================== + * һԪʽ() + * + * 㷨: 2.222.23 + =========================*/ + +#include "Polynomial.h" + + +/* һԪʽ */ + +/* + * 㷨2.22 + * + * + * + * ϵָΪmһԪʽ + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡ + */ +void CreatPolyn(char path[], Polynomial* P, int m) { + FILE* fp; + int i; + ElemType e; + Position h, q; + Link s; + + // ʼһһԪʽ + InitList(P); + + // ȡʽͷָ + h = GetHead(*P); + + // Ϊͷ + e.coef = 0.0f; + e.expn = -1; + SetCurElem(h, e); + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + exit(ERROR); + } + + // ¼mЧ + for(i = 1; i <= m; i++) { + // ȡϵָϢʱe + ReadData(fp, "%f%d", &(e.coef), &(e.expn)); + + // ǰвڸָ + if(LocateElem(*P, e, &q, Cmp) == FALSE && q != NULL) { + // ½ + if(MakeNode(&s, e) == OK) { + // q֮s + InsFirst(P, q, s); + } + } + } + + fclose(fp); +} + +/* + * + * + * һԪʽ + */ +void DestroyPolyn(Polynomial* P) { + DestroyList(P); +} + +/* + * + * + * һԪʽ + */ +int PolynLength(Polynomial P) { + return ListLength(P); +} + +/* + * 㷨2.23 + * + * ӷ + * + * һԪʽӷPa=Pa+Pb + * ɺ󣬼浽PaУPb١ + */ +void AddPolyn(Polynomial* Pa, Polynomial* Pb) { + Position ha, hb; + Position qa, qb; + ElemType a, b; + float sum; + + // hahbֱָPaPbͷ + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // qaqbֱָPaPbĵǰ + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + + // qaqbǿ + while(qa && qb) { + // abΪеǰȽԪ + a = GetCurElem(qa); + b = GetCurElem(qb); + + //ȽϵǰԪصָС + switch(Cmp(a, b)) { + // ʽPaеǰֵָС + case -1: { + ha = qa; + qa = NextPos(*Pa, qa); + } + break; + + // ֵ + case 0: { + sum = a.coef + b.coef; + + // ӲܵʱPaϵֵ + if(sum != 0.0) { + // SetCurElem()ʣֱӸֵ + qa->data.coef = sum; + // ha + ha = qa; + + //ӵʱɾPaеǰ + } else { + // ɾhaĽ㣨ʵɾľqa + DelFirst(Pa, ha, &qa); + // ͷűɾռռ + FreeNode(&qa); + } + + // ɾPbɨĽ + DelFirst(Pb, hb, &qb); + // ͷűɾռռ + FreeNode(&qb); + + // qaqb + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + + // ʽPbеǰֵָС + case 1: { + // ժPbǰ + DelFirst(Pb, hb, &qb); + + // ժ½Pa + InsFirst(Pa, ha, qb); + + ha = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + }//switch + }//while + + // Pbδɨ꣬ʣӵPa + if(qb != NULL) { + Append(Pa, qb); + } + + // ͷPbͷ + FreeNode(&hb); + + // PbΪ״̬ + (*Pb).head = (*Pb).tail = NULL; + (*Pb).len = 0; +} + +/* + * + * + * һԪʽPa=Pa-Pb + * ɺ󣬼浽PaУPb١ + */ +void SubtractPolyn(Polynomial* Pa, Polynomial* Pb) { + Position ha, hb; + Position qa, qb; + Position r; + ElemType a, b; + float sum; + + // hahbֱָPaPbͷ + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // qaqbֱָPaPbĵǰ + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + + // qaqbǿ + while(qa && qb) { + // abΪеǰȽԪ + a = GetCurElem(qa); + b = GetCurElem(qb); + + // ȽϵǰԪصָС + switch(Cmp(a, b)) { + // ʽPaеǰֵָС + case -1: { + ha = qa; + qa = NextPos(*Pa, ha); + } + break; + + // ֵ + case 0: { + sum = a.coef - b.coef; + + // ܵʱPaϵֵ + if(sum != 0.0) { + // ϵ + qa->data.coef = sum; + // ha + ha = qa; + + // ʱɾPaеǰ + } else { + // ɾhaĽ㣨ʵɾľqa + DelFirst(Pa, ha, &qa); + // ͷűɾռռ + FreeNode(&qa); + } + + // ɾPbɨĽ + DelFirst(Pb, hb, &qb); + // ͷűɾռռ + FreeNode(&qb); + + // qaqb + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + + // ʽPbеǰֵָС + case 1: { + // ժPbǰ + DelFirst(Pb, hb, &qb); + + // ı䵱ǰ + qb->data.coef = -qb->data.coef; + + // ժ½Pa + InsFirst(Pa, ha, qb); + + ha = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + }//switch + }//while + + // Pbδɨ꣬ʣϵȡӵPa + if(qb != NULL) { + // ıʣķ + for(r = qb = 0; r != NULL; r = r->next) { + r->data.coef = -r->data.coef; + } + + Append(Pa, qb); + } + + // ͷPbͷ + FreeNode(&hb); + + // PbΪ״̬ + (*Pb).head = (*Pb).tail = NULL; + (*Pb).len = 0; +} + +/* + * ˷ + * + * һԪʽ˷Pa=Pa*Pb + * ɺ󣬼浽PaУPb١ + */ +void MultiplyPolyn(Polynomial* Pa, Polynomial* Pb) { + Polynomial Pc, Ptmp; + int i, j, la, lb; + Position ha, hb; + Position qa, qb; + Link s; + ElemType e; + + // ȡʽij + la = PolynLength(*Pa); + lb = PolynLength(*Pb); + + // hahbֱָPaPbͷ + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // ۼӼ + InitList(&Pc); + + // PaеԪ + for(i = 1; i <= la; i++) { + // 洢ʱ + InitList(&Ptmp); + + // ժPaеĽ + DelFirst(Pa, ha, &qa); + + // Pbн㣬PaժµĽ + for(j = 1, qb = NextPos(*Pb, hb); j <= lb; j++, qb = NextPos(*Pb, qb)) { + e.coef = qa->data.coef * qb->data.coef; //ϵ + e.expn = qa->data.expn + qb->data.expn; //ָ + + // ½洢 + MakeNode(&s, e); + + // ӵʱʽ + Append(&Ptmp, s); + } + + // µĶʽۼӵPc + AddPolyn(&Pc, &Ptmp); + } + + // нӵPa + AddPolyn(Pa, &Pc); + + // ٶʽPb + DestroyPolyn(Pb); +} + + +/* */ + +/* + * + * + * ӡһԪʽ + */ +void PrintPolyn(Polynomial P) { + int i; + Link p; + + p = P.head->next; + for(i = 1; i <= P.len; i++) { + if(p->data.coef == 0.0f) { + continue; + } + + if(i == 1) { + printf("%g", p->data.coef); + } else { + if(p->data.coef > 0) { + printf(" + "); + printf("%g", p->data.coef); + } else { + printf(" - "); + printf("%g", -p->data.coef); + } + } + + if(p->data.expn) { + printf("x"); + + if(p->data.expn != 1) { + printf("^%d", p->data.expn); + } + } + + p = p->next; + } + + printf("\n"); +} + +/* + * Ƚ + * + * Ƚc1c2ָС + */ +int Cmp(ElemType c1, ElemType c2) { + // ָ + int i = c1.expn - c2.expn; + + if(i < 0) { + return -1; + } else if(i == 0) { + return 0; + } else { + return 1; + } +} diff --git a/Dev-C++/CourseBook/0211_Polynomial/Polynomial.dev b/Dev-C++/CourseBook/0211_Polynomial/Polynomial.dev new file mode 100644 index 0000000..03c66c5 --- /dev/null +++ b/Dev-C++/CourseBook/0211_Polynomial/Polynomial.dev @@ -0,0 +1,120 @@ +[Project] +FileName=Polynomial.dev +Name=Polynomial +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=7 + +[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=ELinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit5] +FileName=Polynomial-main.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=ELinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=Polynomial.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit4] +FileName=Polynomial.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit6] +FileName=TestData_Pa.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit7] +FileName=TestData_Pb.txt +Folder= +Compile=0 +Link=0 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/CourseBook/0211_Polynomial/Polynomial.h b/Dev-C++/CourseBook/0211_Polynomial/Polynomial.h new file mode 100644 index 0000000..8a6204a --- /dev/null +++ b/Dev-C++/CourseBook/0211_Polynomial/Polynomial.h @@ -0,0 +1,91 @@ +/*======================== + * һԪʽ() + * + * 㷨: 2.222.23 + =========================*/ + +#ifndef POLYNOMIAL_H +#define POLYNOMIAL_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "ELinkList.h" //**02 Ա**// + +/* һԪʽͶ */ +typedef ELinkList Polynomial; + + +/* һԪʽ */ + +/* + * 㷨2.22 + * + * + * + * ϵָΪmһԪʽ + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡ + */ +void CreatPolyn(char path[], Polynomial *P, int m); + +/* + * + * + * һԪʽ + */ +void DestroyPolyn(Polynomial *P); + +/* + * + * + * һԪʽ + */ +int PolynLength(Polynomial P); + +/* + * 㷨2.23 + * + * ӷ + * + * һԪʽӷPa=Pa+Pb + * ɺ󣬼浽PaУPb١ + */ +void AddPolyn(Polynomial *Pa, Polynomial *Pb); + +/* + * + * + * һԪʽPa=Pa-Pb + * ɺ󣬼浽PaУPb١ + */ +void SubtractPolyn(Polynomial *Pa, Polynomial *Pb); + +/* + * ˷ + * + * һԪʽ˷Pa=Pa*Pb + * ɺ󣬼浽PaУPb١ + */ +void MultiplyPolyn(Polynomial *Pa, Polynomial *Pb); + + +/* */ + +/* + * + * + * ӡһԪʽ + */ +void PrintPolyn(Polynomial P); + +/* + * Ƚ + * + * Ƚc1c2ָС + */ +int Cmp(ElemType c1, ElemType c2); + +#endif diff --git a/Dev-C++/CourseBook/0211_Polynomial/TestData_Pa.txt b/Dev-C++/CourseBook/0211_Polynomial/TestData_Pa.txt new file mode 100644 index 0000000..e72f216 --- /dev/null +++ b/Dev-C++/CourseBook/0211_Polynomial/TestData_Pa.txt @@ -0,0 +1 @@ +Pa = (2.1 , 1) (5.3 , 7) (4.0 , 3) (2.5 , 9) (-3.12 , 5) \ No newline at end of file diff --git a/Dev-C++/CourseBook/0211_Polynomial/TestData_Pb.txt b/Dev-C++/CourseBook/0211_Polynomial/TestData_Pb.txt new file mode 100644 index 0000000..2940e87 --- /dev/null +++ b/Dev-C++/CourseBook/0211_Polynomial/TestData_Pb.txt @@ -0,0 +1 @@ +Pb = (0.5 , 12) (-3.17 , 4) (3.4 , 2) (-2.5 , 9) (4.1 , 5) (1.8 , 8) \ No newline at end of file diff --git a/Dev-C++/ExerciseBook/01.16/01.16.cpp b/Dev-C++/ExerciseBook/01.16/01.16.cpp new file mode 100644 index 0000000..e47616f --- /dev/null +++ b/Dev-C++/ExerciseBook/01.16/01.16.cpp @@ -0,0 +1,53 @@ +#include + +/* + * 1.16 + * + * 3ӴС˳ + */ +void Algo_1_16(int *x, int *y, int *z); + + +int main(int argc, char* argv[]) { + int x, y, z; + + x = 3; + y = 7; + z = 1; + + printf("Ϊʾ趨Ϊ%d %d %d...\n", x, y, z); + + // + Algo_1_16(&x, &y, &z); + + printf("ӴСΪ%d %d %d...\n", x, y, z); + + return 0; +} + + +// 3ӴС˳ +void Algo_1_16(int *x, int *y, int *z) { + int tmp; + + // ȷx>=y + if(*x < *y) { + tmp = *x; + *x = *y; + *y = tmp; + } + + // ȷz>=y + if(*y < *z) { + tmp = *y; + *y = *z; + *z = tmp; + } + + // ȷx>=z + if(*x < *z) { + tmp = *x; + *x = *z; + *z = tmp; + } +} diff --git a/Dev-C++/ExerciseBook/01.16/01.16.dev b/Dev-C++/ExerciseBook/01.16/01.16.dev new file mode 100644 index 0000000..1bad763 --- /dev/null +++ b/Dev-C++/ExerciseBook/01.16/01.16.dev @@ -0,0 +1,62 @@ +[Project] +FileName=01.16.dev +Name=01.16 +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=01.16.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/01.17/01.17.cpp b/Dev-C++/ExerciseBook/01.17/01.17.cpp new file mode 100644 index 0000000..0959239 --- /dev/null +++ b/Dev-C++/ExerciseBook/01.17/01.17.cpp @@ -0,0 +1,86 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* + * 1.171ݹ㷨 + * + * k쳲еmֵ + * + * עintͣʱ + */ +int Algo_1_17_1(int k, int m); + +/* + * 1.172()㷨 + * + * k쳲еmֵ + * + * עintͣʱ + */ +int Algo_1_17_2(int k, int m); + + +int main(int argc, char* argv[]) { + int k, m; + + k = 3; + m = 20; + + printf("Ϊʾ %d 쳲е %d ֵΪ%d \n", k, m, Algo_1_17_1(k, m)); + + printf("Ϊʾ %d 쳲е %d ֵΪ%d \n", k, m, Algo_1_17_2(k, m)); + + return 0; +} + + +// k쳲еmֵ +int Algo_1_17_1(int k, int m) { + int i, value; + + if(k < 2 || m < 0) { + exit(OVERFLOW); + } + + if(m < k - 1) { + return 0; + } else if(m == k - 1) { + return 1; + } else { + for(i = 1, value = 0; i <= k; i++) { + value += Algo_1_17_1(k, m - i); + } + + return value; + } +} + +// k쳲еmֵ +int Algo_1_17_2(int k, int m) { + int i, j; + int* fib; + + if(k < 1 || m < 0) { + exit(OVERFLOW); + } + + // fib + fib = (int*) malloc((m + 1) * sizeof(int)); + + // ʼǰk-1Ϊ0 + for(i = 0; i < k - 1 ;i++) { + fib[i] = 0; + } + + fib[k-1] = 1; + + for(i = k; i <= m; ++i) { + // ۼǰk + for(j = i - 1, fib[i] = 0; j >= i - k; j--) { + fib[i] += fib[j]; + } + } + + return fib[m]; +} diff --git a/Dev-C++/ExerciseBook/01.17/01.17.dev b/Dev-C++/ExerciseBook/01.17/01.17.dev new file mode 100644 index 0000000..c13b9dd --- /dev/null +++ b/Dev-C++/ExerciseBook/01.17/01.17.dev @@ -0,0 +1,62 @@ +[Project] +FileName=01.17.dev +Name=01.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=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=01.17.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/01.19/01.19.cpp b/Dev-C++/ExerciseBook/01.19/01.19.cpp new file mode 100644 index 0000000..31d5b91 --- /dev/null +++ b/Dev-C++/ExerciseBook/01.19/01.19.cpp @@ -0,0 +1,55 @@ +#include +#include // ṩINT_MAX +#include "Status.h" //**01 **// + +/* 궨 */ +#define arrsize 20 //鳤 +#define maxint INT_MAX // + +/* + * 1.17 + * + * i!*2^iֵa[i-1]i[1, arrsize] + * + * i!*2^i = (i-1)!*2^(i-1) * i * 2 + */ +Status Algo_1_19(int i, int a[]); + + +int main(int argc, char* argv[]) { + int i, a[arrsize]; + + i = 5; + + printf("i!*2^i...\n"); + + if(Algo_1_19(i, a) == OK) { + printf("Ϊʾ㵱i = %d ʱa[i-1] = %d\n", i, a[i - 1]); + } + + return 0; +} + + +// i!*2^iֵ +Status Algo_1_19(int i, int a[]) { + int j; + + if(i < 1 || i > arrsize) { + return ERROR; + } + + // i==1ʱ + a[0] = 2; + + // i>1ʱ + for(j = 2; j <= i; j++) { + if(maxint / (2 * j) < a[j - 2]) { + return OVERFLOW; + } + + a[j - 1] = a[j - 2] * j * 2; + } + + return OK; +} diff --git a/Dev-C++/ExerciseBook/01.19/01.19.dev b/Dev-C++/ExerciseBook/01.19/01.19.dev new file mode 100644 index 0000000..daeb82a --- /dev/null +++ b/Dev-C++/ExerciseBook/01.19/01.19.dev @@ -0,0 +1,62 @@ +[Project] +FileName=01.19.dev +Name=01.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=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=01.19.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/01.20/01.20.cpp b/Dev-C++/ExerciseBook/01.20/01.20.cpp new file mode 100644 index 0000000..1d1c8b3 --- /dev/null +++ b/Dev-C++/ExerciseBook/01.20/01.20.cpp @@ -0,0 +1,34 @@ +#include +#include //ṩpowԭ + +/* + * 1.20 + * + * ʽPn(Xo)ֵ + */ +double Algo_1_20(int a[], int x, int n); + + +int main(int argc, char* argv[]) { + int a[5] = {-2, 3, 6, -8, 7}; + int n = 5; + int Xo = 3; + + printf("Ϊʾ趨n = 5Xo = 3Pn(Xo)...\n"); + printf("P%d(%d) = %f\n", n, Xo, Algo_1_20(a, Xo, n)); + + return 0; +} + + +// ʽPn(Xo)ֵ +double Algo_1_20(int a[], int x, int n) { + int i; + double tmp; + + for(i = 1, tmp = 0; i <= n; i++) { + tmp += a[i - 1] * pow(x, i - 1); + } + + return tmp; +} \ No newline at end of file diff --git a/Dev-C++/ExerciseBook/01.20/01.20.dev b/Dev-C++/ExerciseBook/01.20/01.20.dev new file mode 100644 index 0000000..b8ea5b6 --- /dev/null +++ b/Dev-C++/ExerciseBook/01.20/01.20.dev @@ -0,0 +1,62 @@ +[Project] +FileName=01.20.dev +Name=01.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=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=01.20.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.10/02.10.cpp b/Dev-C++/ExerciseBook/02.10/02.10.cpp new file mode 100644 index 0000000..76b985f --- /dev/null +++ b/Dev-C++/ExerciseBook/02.10/02.10.cpp @@ -0,0 +1,68 @@ +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.10 + * + * ɾ˳дӵiԪkԪ + * ikֵϹ棬˳б仯 + */ +Status Algo_2_10(SqList* a, int i, int k); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // ʼ˳ + InitList(&L); + + // ֵ + for(i = 1; i <= 15; i++) { + ListInsert(&L, i, i); + } + + printf("ɾǰL = "); + ListTraverse(L, PrintElem); + + printf("ɾ 6 Ԫ 5 Ԫ...\n"); + Algo_2_10(&L, 6, 5); + + printf("ɾL = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// ɾ˳дӵiԪkԪ +Status Algo_2_10(SqList* a, int i, int k) { + int j; + + // ȷ˳ + if(a == NULL || a->elem == NULL) { + return ERROR; + } + + // ±Խ + if(i < 1 || i > (*a).length || k < 0 || i + k - 1 > (*a).length) { + return ERROR; + } + + for(j = i; j <= i + k - 1; j++) { + (*a).elem[j - 1] = (*a).elem[j + k - 1]; + } + + (*a).length -= k; + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.10/02.10.dev b/Dev-C++/ExerciseBook/02.10/02.10.dev new file mode 100644 index 0000000..e24bfad --- /dev/null +++ b/Dev-C++/ExerciseBook/02.10/02.10.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.10.dev +Name=02.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=02.10.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.10/SqList.cpp b/Dev-C++/ExerciseBook/02.10/SqList.cpp new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/Dev-C++/ExerciseBook/02.10/SqList.cpp @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.10/SqList.h b/Dev-C++/ExerciseBook/02.10/SqList.h new file mode 100644 index 0000000..a7b6e55 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.10/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.11/02.11.cpp b/Dev-C++/ExerciseBook/02.11/02.11.cpp new file mode 100644 index 0000000..716a9a0 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.11/02.11.cpp @@ -0,0 +1,92 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.11 + * + * x뵽va + */ +Status Algo_2_11(SqList* va, ElemType x); + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // ʼ˳ + InitList(&L); + + // ֵ + for(i = 1; i <= 5; i++) { + ListInsert(&L, i, 2 * i); + } + + printf("ǰL = "); + ListTraverse(L, PrintElem); + + printf("Ԫ\"5\"뵽˳...\n"); + Algo_2_11(&L, 5); + + printf("L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// x뵽va +Status Algo_2_11(SqList* va, ElemType x) { + int i, j; + ElemType* newbase; + + // ȷ˳ + if(va == NULL || va->elem == NULL) { + return ERROR; + } + + // 洢ռ迪¿ռ + if((*va).length == (*va).listsize) { + newbase = (ElemType*) realloc((*va).elem, ((*va).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + exit(OVERFLOW); + } + + (*va).elem = newbase; + (*va).listsize += LISTINCREMENT; + } + + // ˳׸ԪxԪλλxҪλ + i = LocateElem(*va, x, CmpGreater); + if(i == 0) { + // Ҫ뵽˳ + i = (*va).length + 1; + } + + // Ԫغƣڳλáעjλ򣬼1֮ + for(j=(*va).length + 1; j>i; j--){ + (*va).elem[j-1] = (*va).elem[j-2]; + } + + (*va).elem[j-1] = x; + (*va).length++; + + return OK; +} + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.11/02.11.dev b/Dev-C++/ExerciseBook/02.11/02.11.dev new file mode 100644 index 0000000..91eeeb5 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.11/02.11.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.11.dev +Name=02.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=02.11.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.11/SqList.cpp b/Dev-C++/ExerciseBook/02.11/SqList.cpp new file mode 100644 index 0000000..0d96ded --- /dev/null +++ b/Dev-C++/ExerciseBook/02.11/SqList.cpp @@ -0,0 +1,142 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // ȷ˳ṹ + if(L.elem == NULL) { + return ERROR; + } + + /* + * iijֵΪ1Ԫصλ + * + * ʵȻдǽiʼΪ1Ԫص + * ڽ̲ǰλģдλ + */ + i = 1; + + // pijֵΪ1ԪصĴ洢λ + p = L.elem; + + // ˳ + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.11/SqList.h b/Dev-C++/ExerciseBook/02.11/SqList.h new file mode 100644 index 0000000..4de6606 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.11/SqList.h @@ -0,0 +1,74 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.12/02.12.cpp b/Dev-C++/ExerciseBook/02.12/02.12.cpp new file mode 100644 index 0000000..bc988c7 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.12/02.12.cpp @@ -0,0 +1,86 @@ +#include +#include "SqList.h" //**02 Ա**// + +/* + * 2.12 + * + * Ƚ˳СȽϲǴұ˳ + * ׶ԲͬԪʱݸԪصĴСϵȷ˳ĴСϵ + * + * ֵ-101ֱAB + */ +int Algo_2_12(SqList A, SqList B); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + int i, mark; + SqList A, B; + + int a[7] = {1, 2, 3, 4, 5, 9, 12}; + int b[7] = {1, 2, 3, 4, 5, 11, 12}; + + // ʼ + InitList(&A); + InitList(&B); + + // ֵ + for(i = 1; i <= 7; i++) { + ListInsert(&A, i, a[i - 1]); + ListInsert(&B, i, b[i - 1]); + } + + printf("A = "); + ListTraverse(A, PrintElem); + + printf("B = "); + ListTraverse(B, PrintElem); + + mark = Algo_2_12(A, B); + if(mark < 0) { + printf("==> A 1) { + printf("==> A>B\n"); + } else { + printf("A==B\n"); + } + + return 0; +} + + +// Ƚ˳С +int Algo_2_12(SqList A, SqList B) { + int i = 0; + + // ɨ˳AB + while(i < A.length && i < B.length) { + if(A.elem[i] > B.elem[i]) { + return 1; + } else if(A.elem[i] < B.elem[i]) { + return -1; + } else { + i++; //ʱȽһԪ + } + } + + // Aʣ࣬A + if(i < A.length) { + return 1; + + // Bʣ࣬B + } else if(i < B.length) { + return -1; + + // ͬʱɨ꣬ + } else { + return 0; + } +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.12/02.12.dev b/Dev-C++/ExerciseBook/02.12/02.12.dev new file mode 100644 index 0000000..20caaa9 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.12/02.12.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.12.dev +Name=02.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=02.12.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.12/SqList.cpp b/Dev-C++/ExerciseBook/02.12/SqList.cpp new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/Dev-C++/ExerciseBook/02.12/SqList.cpp @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.12/SqList.h b/Dev-C++/ExerciseBook/02.12/SqList.h new file mode 100644 index 0000000..cd00561 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.12/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.13/02.13.cpp b/Dev-C++/ExerciseBook/02.13/02.13.cpp new file mode 100644 index 0000000..44ca935 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.13/02.13.cpp @@ -0,0 +1,60 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.13 + * + * ѰԪxLеλá + * 0˵xڡ + */ +int Algo_2_13(LinkList L, ElemType x); + +// жdata==eǷ +Status Equals(ElemType data, ElemType e); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // ʼ˳ + InitList(&L); + + // ֵ + for(i = 1; i <= 10; i++) { + ListInsert(L, i, 2 * i); + } + + // ˳ + printf("L = "); + ListTraverse(L, PrintElem); + + printf("Ԫ \"12\" LеλΪ %d \n", Algo_2_13(L, 12)); + + return 0; +} + + +// ѰԪxLеλ +int Algo_2_13(LinkList L, ElemType x) { + // ֱӵIJҺ + return LocateElem(L, x, Equals); +} + +// жdata==eǷ +Status Equals(ElemType data, ElemType e) { + if(data == e) { + return TRUE; + } else { + return FALSE; + } +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.13/02.13.dev b/Dev-C++/ExerciseBook/02.13/02.13.dev new file mode 100644 index 0000000..62cb267 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.13/02.13.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.13.dev +Name=02.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=02.13.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.13/LinkList.cpp b/Dev-C++/ExerciseBook/02.13/LinkList.cpp new file mode 100644 index 0000000..2e75ab5 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.13/LinkList.cpp @@ -0,0 +1,125 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * + * + * ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 1; // iijֵΪ1Ԫصλ + p = L->next; // pijֵΪ1Ԫصָ + + while(p != NULL && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != NULL) { + return i; + } else { + return 0; + } +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.13/LinkList.h b/Dev-C++/ExerciseBook/02.13/LinkList.h new file mode 100644 index 0000000..93b4faa --- /dev/null +++ b/Dev-C++/ExerciseBook/02.13/LinkList.h @@ -0,0 +1,68 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * + * + * ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.14/02.14.cpp b/Dev-C++/ExerciseBook/02.14/02.14.cpp new file mode 100644 index 0000000..6660205 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.14/02.14.cpp @@ -0,0 +1,46 @@ +#include +#include "LinkList.h" //**02 Ա**// + +/* + * 2.14 + * + * ȡ˳Lijȡ + */ +int Algo_2_14(LinkList L); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // ʼ˳ + InitList(&L); + + // ֵ + for(i = 1; i <= 15; i++) { + ListInsert(L, i, 2 * i); + } + + // ˳ + printf("L = "); + ListTraverse(L, PrintElem); + + printf("LijΪ %d \n", Algo_2_14(L)); + + return 0; +} + + +// ȡ˳Lij +int Algo_2_14(LinkList L) { + // ֱӵļ + return ListLength(L); +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.14/02.14.dev b/Dev-C++/ExerciseBook/02.14/02.14.dev new file mode 100644 index 0000000..9d87b27 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.14/02.14.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.14.dev +Name=02.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=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=02.14.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.14/LinkList.cpp b/Dev-C++/ExerciseBook/02.14/LinkList.cpp new file mode 100644 index 0000000..de7f136 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.14/LinkList.cpp @@ -0,0 +1,118 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * + * + * ЧԪص + */ +int ListLength(LinkList L) { + LinkList p; + int i; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 0; + p = L->next; + + // н + while(p != NULL) { + i++; + p = p->next; + } + + return i; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.14/LinkList.h b/Dev-C++/ExerciseBook/02.14/LinkList.h new file mode 100644 index 0000000..5911e04 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.14/LinkList.h @@ -0,0 +1,64 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * + * + * ЧԪص + */ +int ListLength(LinkList L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.15/02.15.cpp b/Dev-C++/ExerciseBook/02.15/02.15.cpp new file mode 100644 index 0000000..4b62d2e --- /dev/null +++ b/Dev-C++/ExerciseBook/02.15/02.15.cpp @@ -0,0 +1,90 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.15 + * + * hahb洢hcС + */ +Status Algo_2_15(LinkList* ha, LinkList* hb, LinkList* hc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList ha, hb, hc = NULL; + int i; + + // ʼ + InitList(&ha); + InitList(&hb); + + // ֵ + for(i = 1; i <= 5; i++) { + ListInsert(ha, i, 2 * i - 1); + ListInsert(hb, i, 2 * i); + } + + printf("ha = "); + ListTraverse(ha, PrintElem); + + printf("hb = "); + ListTraverse(hb, PrintElem); + + // hahb + Algo_2_15(&ha, &hb, &hc); + + printf("hc = "); + ListTraverse(hc, PrintElem); + + return 0; +} + + +// hahb洢hc +Status Algo_2_15(LinkList* ha, LinkList* hb, LinkList* hc) { + LinkList pa, pb; + + *hc = NULL; + + // ȷhahb + if(ha == NULL || *ha == NULL || hb == NULL || *hb == NULL) { + return ERROR; + } + + pa = *ha; + pb = *hb; + + // ΪЧʣҪȱͬIJ + while(pa->next != NULL && pb->next != NULL) { + pa = pa->next; + pb = pb->next; + } + + // haѾͷˣhbʣ + if(pa->next == NULL && pb->next != NULL) { + *hc = *ha; + pa->next = (*hb)->next; + free(*hb); + } + + // hbѾͷˣhaʣ࣬Ҳû + if(pb->next == NULL) { + *hc = *hb; + pb->next = (*ha)->next; + free(*ha); + } + + // ha/hbͷ + *ha = NULL; + *hb = NULL; + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.15/02.15.dev b/Dev-C++/ExerciseBook/02.15/02.15.dev new file mode 100644 index 0000000..4d2785e --- /dev/null +++ b/Dev-C++/ExerciseBook/02.15/02.15.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.15.dev +Name=02.15 +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=02.15.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.15/LinkList.cpp b/Dev-C++/ExerciseBook/02.15/LinkList.cpp new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.15/LinkList.cpp @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.15/LinkList.h b/Dev-C++/ExerciseBook/02.15/LinkList.h new file mode 100644 index 0000000..d3b16d7 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.15/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.16-02.18/02.16-02.18.cpp b/Dev-C++/ExerciseBook/02.16-02.18/02.16-02.18.cpp new file mode 100644 index 0000000..c9bb25a --- /dev/null +++ b/Dev-C++/ExerciseBook/02.16-02.18/02.16-02.18.cpp @@ -0,0 +1,296 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵûСͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * 2.16 + * + * ɾlaеiλlenԪأӵlbjλ֮ǰ + */ +Status Algo_2_16(LinkList* la, LinkList* lb, int i, int j, int len); + +/* + * 2.17 + * + * Ԫb뵽LiλϣiԪصλ򣬴1ʼ + */ +Status Algo_2_17(LinkList* L, int i, ElemType b); + +/* + * 2.18 + * + * ɾLĵi㣬iԪصλ򣬴1ʼ + */ +Status Algo_2_18(LinkList* L, int i); + +// ʼͷL +void InitList(LinkList* L); + +// ͷеԪ +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + int i; + LinkList la, lb; + + InitList(&la); + InitList(&lb); + + printf(" 2.17 ֤...\n"); + for(i = 1; i <= 10; i++) { + Algo_2_17(&la, i, 2 * i - 1); + Algo_2_17(&lb, i, 2 * i); + } + printf(" ͷ\n"); + printf(" la = "); + Output(la); + printf(" lb = "); + Output(lb); + PressEnterToContinue(); + + printf(" 2.16 ֤...\n"); + printf(" laдӵ25뵽lbĵ6֮ǰ...\n"); + Algo_2_16(&la, &lb, 2, 6, 5); + printf(" la = "); + Output(la); + printf(" lb = "); + Output(lb); + PressEnterToContinue(); + + printf(" 2.18 ֤...\n"); + printf(" ɾlb65...\n"); + for(i = 1; i <= 5; i++) { + Algo_2_18(&lb, 6); + } + printf(" ɾɺlb = "); + Output(lb); + + return 0; +} + + +// ɾlaеiλlenԪأӵlbjλ֮ǰ +Status Algo_2_16(LinkList* la, LinkList* lb, int i, int j, int len) { + LinkList p; // ָlaеi-1 + LinkList q; // ָlaеi+len-1 + LinkList r; // ָqĽ + LinkList s; // ָlbеj-1 + int k; + + if(i <= 0 || j <= 0 || len <= 0) { + return ERROR; + } + + // ȷlaнժ + if(la == NULL || *la == NULL) { + return ERROR; + } + + + // ȷpλ + k = 1; + p = *la; + + if(i == 1) { + p = NULL; + } else { + // laеi-1㣬ұ̴֤ + while(p->next != NULL && k < i - 1) { + ++k; + p = p->next; + } + + // δҵʵλ + if(p->next == NULL) { + return ERROR; + } + } + + + // ȷqλ + if(p == NULL) { + q = *la; + } else { + q = p->next; + } + k = i; + + while(q != NULL && k < i + len - 1) { + ++k; + q = q->next; + } + + if(q == NULL) { + return ERROR; + } + + // ȷrλ + r = q->next; + + + if(lb == NULL) { + return ERROR; + } + + // ȷsλ + k = 1; + s = *lb; + + // 뵽lbһλ֮ǰ + if(j == 1) { + q->next = *lb; + + if(p == NULL) { + *lb = *la; + *la = r; + } else { + *lb = p->next; + p->next = r; + } + } else { + // lbеj-1㣬ұ̴֤ + while(s->next != NULL && k < j - 1) { + ++k; + s = s->next; + } + + // δҵʵλ + if(s->next == NULL) { + return ERROR; + } + + q->next = s->next; + + if(p == NULL) { + *lb = *la; + *la = r; + } else { + s->next = p->next; + p->next = r; + } + } + + return OK; +} + +// Ԫb뵽Liλ +Status Algo_2_17(LinkList* L, int i, ElemType b) { + LinkList p, s; + int j; + + if(L == NULL) { + return ERROR; + } + + // i1ʼ + if(i <= 0) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = b; + + j = 1; + p = *L; + + // + if(i == 1) { + s->next = p; + *L = s; + } else { + // ҵi-1㣬ұ֤ + while(p != NULL && j < i - 1) { + ++j; + p = p->next; + } + + // δҵʵλ + if(p == NULL) { + return ERROR; + } + + s->next = p->next; + p->next = s; + } + + return OK; +} + +// ɾLĵi +Status Algo_2_18(LinkList* L, int i) { + LinkList p, q; + int j; + + // ȷнɾ + if(L == NULL || *L == NULL) { + return ERROR; + } + + // i1ʼ + if(i <= 0) { + return ERROR; + } + + j = 1; + p = *L; + + // + if(i == 1) { + *L = p->next; + free(p); + } else { + // ҵi-1㣬ұ̴֤ + while(p->next != NULL && j < i - 1) { + ++j; + p = p->next; + } + + // δҵʵλ + if(p->next == NULL) { + return ERROR; + } + + q = p->next; + p->next = q->next; + free(q); + } + + return OK; +} + +// ʼͷL +void InitList(LinkList* L) { + *L = NULL; +} + +// ͷеԪ +void Output(LinkList L) { + while(L != NULL) { + printf("%2d ", L->data); + L = L->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.16-02.18/02.16-02.18.dev b/Dev-C++/ExerciseBook/02.16-02.18/02.16-02.18.dev new file mode 100644 index 0000000..60dd968 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.16-02.18/02.16-02.18.dev @@ -0,0 +1,62 @@ +[Project] +FileName=02.16-02.18.dev +Name=02.16-02.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=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=02.16-02.18.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.19-02.20/02.19-02.20.cpp b/Dev-C++/ExerciseBook/02.19-02.20/02.19-02.20.cpp new file mode 100644 index 0000000..c36a97f --- /dev/null +++ b/Dev-C++/ExerciseBook/02.19-02.20/02.19-02.20.cpp @@ -0,0 +1,194 @@ +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.19һ + * + * ɾԱԪֵ(mink, maxk)֮Ľ㡣 + */ +Status Algo_2_19_1(LinkList L, int mink, int maxk); + +/* + * 2.19 + * + * ɾԱԪֵ(mink, maxk)֮Ľ㡣 + */ +Status Algo_2_19_2(LinkList L, int mink, int maxk); + +/* + * 2.20 + * + * ԷǵݼԱȥأظԪأһ + */ +Status Algo_2_20(LinkList L); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int mink1, mink2, maxk1, maxk2, i; + int a[] = {1, 2, 2, 3, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 9, 9, 10, 11, 12, 12}; + + mink1 = 2; + maxk1 = 4; + + mink2 = 5; + maxk2 = 8; + + InitList(&L); + + for(i = 1; i <= 20; i++) { + ListInsert(L, i, a[i - 1]); + } + + printf(" L = "); + ListTraverse(L, PrintElem); + + printf(" 2.19 ֤...\n"); + printf(" ɾ (%d, %d) ΧڵԪ֮", mink1, maxk1); + Algo_2_19_1(L, mink1, maxk1); + printf("L = "); + ListTraverse(L, PrintElem); + + printf(" ɾ (%d, %d) ΧڵԪ֮", mink2, maxk2); + Algo_2_19_2(L, mink2, maxk2); + printf("L = "); + ListTraverse(L, PrintElem); + + printf(" 2.20 ֤...\n"); + printf(" Էǵݼȥ֮"); + Algo_2_20(L); + printf("L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// ɾԱԪֵ(mink, maxk)֮Ľ +Status Algo_2_19_1(LinkList L, int mink, int maxk) { + LinkList p, q; + int flag; // Ч + + // ȷ + if(L == NULL) { + return ERROR; + } + + // Χ趨 + if(mink >= maxk) { + return ERROR; + } + + // Ϊգֱӷ + if(L->next == NULL) { + return OK; + } + + p = L; // ָͷ + flag = 0; // δ(mink, maxk)ΧڵԪ + + while(p->next != NULL) { + q = p->next; + + // ҪɾĽ + if(q->data > mink && q->data < maxk) { + // (mink, maxk)ΧڵԪ + flag = 1; + p->next = q->next; + free(q); + } else { + // ˵ʣԪؾ>=maxkٱ + if(flag == 1) { + break; + } + p = q; + } + } + + return OK; +} + +// ɾԱԪֵ(mink, maxk)֮Ľ +Status Algo_2_19_2(LinkList L, int mink, int maxk) { + LinkList p, q; + + // ȷ + if(L == NULL) { + return ERROR; + } + + // Χ趨 + if(mink >= maxk) { + return ERROR; + } + + // Ϊգֱӷ + if(L->next == NULL) { + return OK; + } + + p = L; // ָͷ + + // + while(p->next != NULL && p->next->data <= mink) { + p = p->next; + } + + // + if(p->next == NULL) { + return OK; + } + + // ޣɾ(mink, maxk)֮IJ + while(p->next != NULL && p->next->data < maxk) { + q = p->next; + p->next = q->next; + free(q); + } + + return OK; +} + +// ԷǵݼԱȥأظԪأһ +Status Algo_2_20(LinkList L) { + LinkList p, q; + + // ȷ + if(L == NULL) { + return ERROR; + } + + // Ϊգֱӷ + if(L->next == NULL) { + return OK; + } + + // ָ1Ԫ + p = L->next; + + while(p->next != NULL) { + q = p->next; + + // ظԪأҪɾһ + if(p->data == q->data) { + p->next = q->next; + free(q); + + // DzͬԪأpǰһ + } else { + p = q; + } + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.19-02.20/02.19-02.20.dev b/Dev-C++/ExerciseBook/02.19-02.20/02.19-02.20.dev new file mode 100644 index 0000000..fc73819 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.19-02.20/02.19-02.20.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.19-02.20.dev +Name=02.19-02.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 + +[Unit1] +FileName=02.19-02.20.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.19-02.20/LinkList.cpp b/Dev-C++/ExerciseBook/02.19-02.20/LinkList.cpp new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.19-02.20/LinkList.cpp @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.19-02.20/LinkList.h b/Dev-C++/ExerciseBook/02.19-02.20/LinkList.h new file mode 100644 index 0000000..d3b16d7 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.19-02.20/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.21/02.21.cpp b/Dev-C++/ExerciseBook/02.21/02.21.cpp new file mode 100644 index 0000000..ee027cc --- /dev/null +++ b/Dev-C++/ExerciseBook/02.21/02.21.cpp @@ -0,0 +1,63 @@ +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.21 + * + * ˳á + */ +Status Algo_2_21(SqList L); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // ׼ + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(&L, i, i); + } + + printf("˳L = "); + ListTraverse(L, PrintElem); + + Algo_2_21(L); + + printf("ãL = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// ˳ +Status Algo_2_21(SqList L) { + int i, mid; + ElemType tmp; + + // ȷ˳ + if(L.elem == NULL) { + return ERROR; + } + + // ֻҪǰһԪؼ + mid = L.length / 2; + + for(i = 1; i <= mid; i++) { + tmp = L.elem[i - 1]; + L.elem[i - 1] = L.elem[L.length - i]; + L.elem[L.length - i] = tmp; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.21/02.21.dev b/Dev-C++/ExerciseBook/02.21/02.21.dev new file mode 100644 index 0000000..834ba8a --- /dev/null +++ b/Dev-C++/ExerciseBook/02.21/02.21.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.21.dev +Name=02.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=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=02.21.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.21/SqList.cpp b/Dev-C++/ExerciseBook/02.21/SqList.cpp new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/Dev-C++/ExerciseBook/02.21/SqList.cpp @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.21/SqList.h b/Dev-C++/ExerciseBook/02.21/SqList.h new file mode 100644 index 0000000..25b1d92 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.21/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.22/02.22.cpp b/Dev-C++/ExerciseBook/02.22/02.22.cpp new file mode 100644 index 0000000..8a8ca81 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.22/02.22.cpp @@ -0,0 +1,62 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.22 + * + * á + */ +Status Algo_2_22(LinkList L); + +// ԺӡԪ +void PrintElem(ElemType e); + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // ׼ + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(L, i, i); + } + + printf("˳L = "); + ListTraverse(L, PrintElem); + + Algo_2_22(L); + + printf("ãL = "); + ListTraverse(L, PrintElem); + + return 0; +} + +// +Status Algo_2_22(LinkList L) { + LinkList p, q; + + // ȷ + if(L==NULL) { + return ERROR; + } + + p = L->next; + L->next = NULL; + + // ͷ巨 + while(p!=NULL){ + q = p->next; + p->next = L->next; + L->next = p; + p = q; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.22/02.22.dev b/Dev-C++/ExerciseBook/02.22/02.22.dev new file mode 100644 index 0000000..5221bbe --- /dev/null +++ b/Dev-C++/ExerciseBook/02.22/02.22.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.22.dev +Name=02.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 + +[Unit1] +FileName=02.22.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.22/LinkList.cpp b/Dev-C++/ExerciseBook/02.22/LinkList.cpp new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.22/LinkList.cpp @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.22/LinkList.h b/Dev-C++/ExerciseBook/02.22/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.22/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.23/02.23.cpp b/Dev-C++/ExerciseBook/02.23/02.23.cpp new file mode 100644 index 0000000..96d6bc4 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.23/02.23.cpp @@ -0,0 +1,147 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.23һLa뵽Lb + * + * ϲ + * ϲɺ󣬽LaLbÿգ١ + */ +Status Algo_2_23_1(LinkList La, LinkList Lb, LinkList* Lc); + +/* + * 2.23LaLbеԪؽ뵽Lc + * + * ϲ + * ϲɺ󣬽LaLbÿգ١ + */ +Status Algo_2_23_2(LinkList La, LinkList Lb, LinkList* Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 5; i++) { + ListInsert(La, i, 2 * i - 1); + ListInsert(Lb, i, 2 * i); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // ϲ +// Algo_2_23_1(La, Lb, &Lc); + Algo_2_23_2(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +// ϲ +Status Algo_2_23_1(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList p, pb; + + // ȷLaLb + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + pb = Lb; + + while(La->next != NULL && pb->next != NULL) { + // Laժ½ + p = La->next; + La->next = p->next; + + // LaժµĽ뵽Lb + p->next = pb->next; + pb->next = p; + + // ǰԭLbһλ + pb = pb->next->next; + } + + // Laʣ࣬ҪȫӵLbβ + if(pb->next == NULL && La->next != NULL) { + pb->next = La->next; + La->next = NULL; + } + + InitList(Lc); + + (*Lc)->next = Lb->next; + Lb->next = NULL; + + return OK; +} + +// ϲ +Status Algo_2_23_2(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList p, pc; + int flag; // ָӲLaеԪػDzLbеԪ + + // ȷLaLb + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + InitList(Lc); + + flag = 0; + pc = *Lc; + + while(La->next!=NULL && Lb->next!=NULL){ + // ҪLaеԪ + if(flag==0) { + // ժLaеԪ + p = La->next; + La->next = p->next; + + flag = 1; + } else { + // ժLaеԪ + p = Lb->next; + Lb->next = p->next; + + flag = 0; + } + + // ժµԪز뵽Lc + pc->next = p; + pc = pc->next; + } + + // Lbʣ + if(La->next==NULL) { + // ժLbеԪ + p = Lb->next; + Lb->next = NULL; + pc->next = p; + + // Laʣ + } else { + // ժLaеԪ + p = La->next; + La->next = NULL; + pc->next = p; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.23/02.23.dev b/Dev-C++/ExerciseBook/02.23/02.23.dev new file mode 100644 index 0000000..1495167 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.23/02.23.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.23.dev +Name=02.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 + +[Unit1] +FileName=02.23.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.23/LinkList.cpp b/Dev-C++/ExerciseBook/02.23/LinkList.cpp new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.23/LinkList.cpp @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.23/LinkList.h b/Dev-C++/ExerciseBook/02.23/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.23/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.24/02.24.cpp b/Dev-C++/ExerciseBook/02.24/02.24.cpp new file mode 100644 index 0000000..dcecc52 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.24/02.24.cpp @@ -0,0 +1,94 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.24 + * + * 鲢Ϊһݼ + * 鲢ǣժLaLbеԪأʹͷ巨뵽Lc + * 鲢ɺ󣬽ԭÿգ١ + */ +Status Algo_2_24(LinkList La, LinkList Lb, LinkList* Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 5; i++) { + ListInsert(La, i, 2 * i - 1); + ListInsert(Lb, i, 2 * i); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 鲢 + Algo_2_24(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +// 鲢Ϊһݼ +Status Algo_2_24(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList pa, pb; + + // ȷLaLb + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + InitList(Lc); + + // LaLb + while(La->next!=NULL && Lb->next!=NULL){ + pa = La->next; + pb = Lb->next; + + // ժLaLbнСԪ + if(pa->data<=pb->data) { + La->next = pa->next; + pa->next = (*Lc)->next; + (*Lc)->next = pa; + } else { + Lb->next = pb->next; + pb->next = (*Lc)->next; + (*Lc)->next = pb; + } + } + + // Laʣ࣬LaʣԪز뵽Lc + while(La->next!=NULL){ + pa = La->next; + La->next = pa->next; + pa->next = (*Lc)->next; + (*Lc)->next = pa; + } + + // Lbʣ࣬LbʣԪز뵽Lc + while(Lb->next!=NULL){ + pb = Lb->next; + Lb->next = pb->next; + pb->next = (*Lc)->next; + (*Lc)->next = pb; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.24/02.24.dev b/Dev-C++/ExerciseBook/02.24/02.24.dev new file mode 100644 index 0000000..d7117f1 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.24/02.24.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.24.dev +Name=02.24 +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=02.24.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.24/LinkList.cpp b/Dev-C++/ExerciseBook/02.24/LinkList.cpp new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.24/LinkList.cpp @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.24/LinkList.h b/Dev-C++/ExerciseBook/02.24/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.24/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.25/02.25.cpp b/Dev-C++/ExerciseBook/02.25/02.25.cpp new file mode 100644 index 0000000..9f0a5df --- /dev/null +++ b/Dev-C++/ExerciseBook/02.25/02.25.cpp @@ -0,0 +1,82 @@ +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.25 + * + * 󽻼C=AB + */ +Status Algo_2_25(SqList La, SqList Lb, SqList* Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 󽻼 + Algo_2_25(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 󽻼C=AB +Status Algo_2_25(SqList La, SqList Lb, SqList* Lc) { + int i, j, k; + + // ȷLaLb + if(La.elem == NULL || Lb.elem == NULL) { + return ERROR; + } + + InitList(Lc); + + i = j = 0; // LaLb + k = 0; // Lc + + // ֻLaLbĹͬ־ + while(i < La.length && j < Lb.length) { + if(La.elem[i] < Lb.elem[j]) { + i++; + } else if(La.elem[i] > Lb.elem[j]) { + j++; + // LaLbеԪ + } else { + // LcԪؿظ + ListInsert(Lc, k+1, La.elem[i]); + k++; + i++; + j++; + } + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.25/02.25.dev b/Dev-C++/ExerciseBook/02.25/02.25.dev new file mode 100644 index 0000000..e1a3687 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.25/02.25.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.25.dev +Name=02.25 +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=02.25.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.25/SqList.cpp b/Dev-C++/ExerciseBook/02.25/SqList.cpp new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/Dev-C++/ExerciseBook/02.25/SqList.cpp @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.25/SqList.h b/Dev-C++/ExerciseBook/02.25/SqList.h new file mode 100644 index 0000000..a7b6e55 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.25/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.26/02.26.cpp b/Dev-C++/ExerciseBook/02.26/02.26.cpp new file mode 100644 index 0000000..f9f4f64 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.26/02.26.cpp @@ -0,0 +1,89 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.26 + * + * 󽻼C=AB + */ +Status Algo_2_26(LinkList La, LinkList Lb, LinkList* Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 󽻼 + Algo_2_26(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 󽻼C=AB +Status Algo_2_26(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList pa, pb, pc, s; + + // ȷLaLb + if(La == NULL || Lb == NULL) { + return ERROR; + } + + InitList(Lc); + + pa = La->next; + pb = Lb->next; + pc = *Lc; + + // ֻLaLbĹͬ־ + while(pa != NULL && pb != NULL) { + if(pa->data < pb->data) { + pa = pa->next; + } else if(pa->data > pb->data) { + pb = pb->next; + } else { + // LcԪؿظ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = pa->data; + s->next = NULL; + + pc->next = s; + + pc = pc->next; + + pa = pa->next; + pb = pb->next; + } + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.26/02.26.dev b/Dev-C++/ExerciseBook/02.26/02.26.dev new file mode 100644 index 0000000..084319e --- /dev/null +++ b/Dev-C++/ExerciseBook/02.26/02.26.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.26.dev +Name=02.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=02.26.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.26/LinkList.cpp b/Dev-C++/ExerciseBook/02.26/LinkList.cpp new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.26/LinkList.cpp @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.26/LinkList.h b/Dev-C++/ExerciseBook/02.26/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.26/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.27/02.27.cpp b/Dev-C++/ExerciseBook/02.27/02.27.cpp new file mode 100644 index 0000000..f575a69 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.27/02.27.cpp @@ -0,0 +1,96 @@ +#include +#include "SqList.h" //**02 Ա**// + +/* + * 2.27 + * + * 󽻼C=AB + * CеԪظCAԭеĿռ䣬A١ + */ +SqList Algo_2_27(SqList* La, SqList Lb); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 󽻼 + Lc = Algo_2_27(&La, Lb); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 󽻼C=AB +SqList Algo_2_27(SqList* La, SqList Lb) { + int i, j, k; + SqList Lc; + + // ȷLaLb + if((*La).elem == NULL || Lb.elem == NULL) { + Lc.elem = NULL; + Lc.length = 0; + Lc.listsize = 0; + return Lc; + } + + i = j = 0; // LaLb + k = 0; // Lc + + Lc.elem = (*La).elem; + Lc.listsize = La->listsize; + + // ֻLaLbĹͬ־ + while(i < (*La).length && j < Lb.length) { + if((*La).elem[i] < Lb.elem[j]) { + i++; + } else if((*La).elem[i] > Lb.elem[j]) { + j++; + // LaLbеԪ + } else { + // ȷLcеԪزظ + if(k == 0 || Lc.elem[k - 1] != (*La).elem[i]) { + Lc.elem[k] = (*La).elem[i]; + k++; + } + + i++; + j++; + } + } + + // Aռ佻Cʹ + (*La).elem = NULL; + (*La).length = 0; + (*La).listsize = 0; + + Lc.length = k; + + return Lc; +} + +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.27/02.27.dev b/Dev-C++/ExerciseBook/02.27/02.27.dev new file mode 100644 index 0000000..fefdbc0 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.27/02.27.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.27.dev +Name=02.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 + +[Unit1] +FileName=02.27.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.27/SqList.cpp b/Dev-C++/ExerciseBook/02.27/SqList.cpp new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/Dev-C++/ExerciseBook/02.27/SqList.cpp @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.27/SqList.h b/Dev-C++/ExerciseBook/02.27/SqList.h new file mode 100644 index 0000000..a7b6e55 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.27/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.28/02.28.cpp b/Dev-C++/ExerciseBook/02.28/02.28.cpp new file mode 100644 index 0000000..3300e69 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.28/02.28.cpp @@ -0,0 +1,92 @@ +#include +#include "LinkList.h" //**02 Ա**// + +/* + * 2.28 + * + * 󽻼C=AB + * CеԪظCAԭеĿռ䣬A١ + */ +LinkList Algo_2_28(LinkList* La, LinkList Lb); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 󽻼 + Lc = Algo_2_28(&La, Lb); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +LinkList Algo_2_28(LinkList* La, LinkList Lb) { + LinkList Lc; + LinkList pa, pb, pc, s; + + // ȷLaLb + if(La == NULL || *La == NULL || Lb == NULL) { + return NULL; + } + + pa = (*La)->next; + pb = Lb->next; + + Lc = *La; + Lc->next = NULL; + pc = Lc; + + // ֻLaLbĹͬ־ + while(pa != NULL && pb != NULL) { + if(pa->data < pb->data) { + s = pa; + pa = pa->next; + free(s); + } else if(pa->data > pb->data) { + pb = pb->next; + } else { + // ȷLcеԪزظ + if(pc == Lc || pc->data != pa->data) { + pc->next = pa; + pc = pc->next; + } + + pa = pa->next; + pb = pb->next; + } + } + + pc->next = NULL; + + + *La = NULL; + + return Lc; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.28/02.28.dev b/Dev-C++/ExerciseBook/02.28/02.28.dev new file mode 100644 index 0000000..ce46ce4 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.28/02.28.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.28.dev +Name=02.28 +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=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit1] +FileName=02.28.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.28/LinkList.cpp b/Dev-C++/ExerciseBook/02.28/LinkList.cpp new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.28/LinkList.cpp @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.28/LinkList.h b/Dev-C++/ExerciseBook/02.28/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.28/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.29/02.29.cpp b/Dev-C++/ExerciseBook/02.29/02.29.cpp new file mode 100644 index 0000000..b132464 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.29/02.29.cpp @@ -0,0 +1,104 @@ +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.29 + * + * A=A-BC + */ +Status Algo_2_29(SqList* La, SqList Lb, SqList Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int b[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int c[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + InitList(&Lc); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + ListInsert(&Lc, i, c[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + + // + Algo_2_29(&La, Lb, Lc); + + printf("La = La-LbLc = "); + ListTraverse(La, PrintElem); + + return 0; +} + +// A=A-BC +Status Algo_2_29(SqList* La, SqList Lb, SqList Lc) { + int i, j, k, count; + + if(La==NULL || (*La).elem==NULL || Lb.elem==NULL || Lc.elem==NULL) { + return ERROR; + } + + i = j = k = 0; + count = 0; + + // ȡBCĽȻAɾ + while(i < (*La).length && j < Lb.length && k < Lc.length) { + if(Lb.elem[j] < Lc.elem[k]) { + j++; + } else if(Lb.elem[j] > Lc.elem[k]) { + k++; + } else { + // AвҽԪ + while(i < (*La).length && (*La).elem[i] < Lb.elem[j]) { + (*La).elem[count] = (*La).elem[i]; + count++; + i++; + } + + // Ԫ + while(i < (*La).length && (*La).elem[i] == Lb.elem[j]) { + i++; + } + + // Aûб + if(i < (*La).length) { + j++; + k++; + } + } + } + + // ʣԪطŵʵλ + while(i < (*La).length) { + (*La).elem[count] = (*La).elem[i]; + count++; + i++; + } + + (*La).length = count; + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.29/02.29.dev b/Dev-C++/ExerciseBook/02.29/02.29.dev new file mode 100644 index 0000000..c7253ce --- /dev/null +++ b/Dev-C++/ExerciseBook/02.29/02.29.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.29.dev +Name=02.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=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=02.29.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=SqList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=SqList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.29/SqList.cpp b/Dev-C++/ExerciseBook/02.29/SqList.cpp new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/Dev-C++/ExerciseBook/02.29/SqList.cpp @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.29/SqList.h b/Dev-C++/ExerciseBook/02.29/SqList.h new file mode 100644 index 0000000..a7b6e55 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.29/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.30/02.30.cpp b/Dev-C++/ExerciseBook/02.30/02.30.cpp new file mode 100644 index 0000000..b4281bf --- /dev/null +++ b/Dev-C++/ExerciseBook/02.30/02.30.cpp @@ -0,0 +1,97 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.30 + * + * A=A-BC + */ +Status Algo_2_30(LinkList La, LinkList Lb, LinkList Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int b[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int c[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + InitList(&Lc); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + ListInsert(Lc, i, c[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + // + Algo_2_30(La, Lb, Lc); + + printf("La = La-LbLc = "); + ListTraverse(La, PrintElem); + + return 0; +} + +// A=A-BC +Status Algo_2_30(LinkList La, LinkList Lb, LinkList Lc) { + LinkList pa, pb, pc, p; + + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + pa = La->next; + pb = Lb->next; + pc = Lc->next; + p = La; + + // ȡBCĽȻAɾ + while(pa != NULL && pb != NULL && pc != NULL) { + if(pb->data < pc->data) { + pb = pb->next; + } else if(pb->data > pc->data) { + pc = pc->next; + } else { + // AвҽԪ + while(pa != NULL && pa->data < pb->data) { + p = pa; + pa = pa->next; + } + + // Ԫ + while(pa != NULL && pa->data == pb->data) { + p->next = pa->next; + free(pa); + pa = p->next; + } + + // Aûб + if(pa != NULL ) { + pb = pb->next; + pc = pc->next; + } + } + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.30/02.30.dev b/Dev-C++/ExerciseBook/02.30/02.30.dev new file mode 100644 index 0000000..b578f5f --- /dev/null +++ b/Dev-C++/ExerciseBook/02.30/02.30.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.30.dev +Name=02.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 + +[Unit1] +FileName=02.30.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=LinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=LinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.30/LinkList.cpp b/Dev-C++/ExerciseBook/02.30/LinkList.cpp new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.30/LinkList.cpp @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.30/LinkList.h b/Dev-C++/ExerciseBook/02.30/LinkList.h new file mode 100644 index 0000000..c61d71a --- /dev/null +++ b/Dev-C++/ExerciseBook/02.30/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/Dev-C++/ExerciseBook/02.31/02.31.cpp b/Dev-C++/ExerciseBook/02.31/02.31.cpp new file mode 100644 index 0000000..0278340 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.31/02.31.cpp @@ -0,0 +1,136 @@ +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +// ѭṹͷ㣩 +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * 2.31 + * + * ɾsǰ + */ +Status Algo_2_31(LinkList* L, LinkList s); + +// ָݴޡͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n); + +// L +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L, s; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + // ׼ + CreatList(&L, a, 10); + printf("L = "); + Output(L); + + s = L->next->next->next->next; + + printf("ɾ %d ǰ...\n", s->data); + Algo_2_31(&L, s); + + printf("L = "); + Output(L); + + return 0; +} + +// ɾsǰ +Status Algo_2_31(LinkList* L, LinkList s) { + LinkList p, pre; + + if(L == NULL || *L == NULL) { + return ERROR; + } + + // ǰ + if(s == NULL || s->next == s) { + return ERROR; + } + + p = s; + + // ʹp->nextָsǰ + while(p->next->next != s) { + p = p->next; + } + + // sǰ + pre = p->next; + + // ɾǰ + p->next = pre->next; + free(pre); + + // ǰ + if(pre == *L) { + *L = s; + } + + return OK; +} + +// ָݴͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + *L = NULL; + + for(i = 0; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + + s->data = elems[i]; + + if(i == 0) { + *L = s; + s->next = *L; // ѭ + r = *L; + } else { + s->next = r->next; + r->next = s; + r = r->next; + } + } + + return OK; +} + +// L +void Output(LinkList L) { + LinkList p; + + if(L == NULL) { + return; + } + + printf("%2d ", L->data); + + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.31/02.31.dev b/Dev-C++/ExerciseBook/02.31/02.31.dev new file mode 100644 index 0000000..275fc76 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.31/02.31.dev @@ -0,0 +1,62 @@ +[Project] +FileName=02.31.dev +Name=02.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=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=02.31.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.32/02.32.cpp b/Dev-C++/ExerciseBook/02.32/02.32.cpp new file mode 100644 index 0000000..55dc484 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.32/02.32.cpp @@ -0,0 +1,134 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +// ˫ѭṹ +typedef struct LNode { + ElemType data; + struct LNode* next; + struct LNode* pre; +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * 2.32 + * + * ѭ޸Ϊ˫ѭ + */ +Status Algo_2_32(LinkList L); + +// ָݴСͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n); + +// +void Output(LinkList L); + +// +void OutputReverse(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L; + ElemType a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + // ׼ݣ + CreatList(&L, a, 10); + printf("L = "); + Output(L); + + // Ϊ˫ + Algo_2_32(L); + + // + printf("L = "); + OutputReverse(L); + + return 0; +} + + +// ѭ޸Ϊ˫ѭ +Status Algo_2_32(LinkList L) { + LinkList r; + + if(L==NULL || L->next==L) { + return ERROR; + } + + for(r = L; r->next != L; r = r->next) { + r->next->pre = r; + } + + L->pre = r; + + return OK; +} + +// ָݴСͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + // ʼͷ + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->pre = NULL; + (*L)->next = *L; + + for(i = 0, r = *L; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + s->pre = NULL; + + s->next = r->next; + r->next = s; + r = r->next; + } + + return OK; +} + +// +void Output(LinkList L) { + LinkList p; + + if(L == NULL || L->next == L) { + return; + } + + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + + printf("\n"); +} + +// +void OutputReverse(LinkList L) { + LinkList p; + + if(L == NULL || L->pre == L) { + return; + } + + for(p = L->pre; p != L; p = p->pre) { + printf("%2d ", p->data); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.32/02.32.dev b/Dev-C++/ExerciseBook/02.32/02.32.dev new file mode 100644 index 0000000..021334c --- /dev/null +++ b/Dev-C++/ExerciseBook/02.32/02.32.dev @@ -0,0 +1,62 @@ +[Project] +FileName=02.32.dev +Name=02.32 +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=02.32.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.33/02.33.cpp b/Dev-C++/ExerciseBook/02.33/02.33.cpp new file mode 100644 index 0000000..6e6160d --- /dev/null +++ b/Dev-C++/ExerciseBook/02.33/02.33.cpp @@ -0,0 +1,174 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩisalphaisdigitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef char ElemType; + +// ѭṹ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * 2.33 + * + * ַ֡ + */ +Status Algo_2_33(LinkList L, LinkList* L_char, LinkList* L_num, LinkList* L_other); + +// ʼһѭ +Status InitList(LinkList* L); + +// ָݴСͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n); + +// +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L, L_char, L_num, L_other; + + ElemType a[20+1] = "2a3@A5e$T*1%s&7pl(o)"; + + // ׼ݣ + CreatList(&L, a, 20); + printf("L = "); + Output(L); + + // + Algo_2_33(L, &L_char, &L_num, &L_other); + + // ֺ + printf("L_char = "); + Output(L_char); + printf("L_num = "); + Output(L_num); + printf("L_other = "); + Output(L_other); + + return 0; +} + + +// ַ֡ +Status Algo_2_33(LinkList L, LinkList* L_char, LinkList* L_num, LinkList* L_other) { + LinkList r, rc, rn, ro, s; + + if(L_char == NULL || L_num == NULL || L_other == NULL) { + return ERROR; + } + + if(L == NULL || L->next == L) { + return ERROR; + } + + InitList(L_char); + InitList(L_num); + InitList(L_other); + + r = L->next; + rc = *L_char; + rn = *L_num; + ro = *L_other; + + while(r != L) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = r->data; + + // ԪΪַ + if(isalpha(r->data)) { + s->next = rc->next; + rc->next = s; + rc = rc->next; + + // ԪΪ + } else if(isdigit(r->data)) { + s->next = rn->next; + rn->next = s; + rn = rn->next; + + // + } else { + s->next = ro->next; + ro->next = s; + ro = ro->next; + } + + r = r->next; + } + + return OK; +} + + +// ʼһѭ +Status InitList(LinkList* L) { + if(L == NULL) { + return ERROR; + } + + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = *L; + + return OK; +} + +// ָݴСͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + // ʼͷ + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = *L; + + for(i = 0, r = *L; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + + s->next = r->next; + r->next = s; + r = r->next; + } + + return OK; +} + +// +void Output(LinkList L) { + LinkList p; + + if(L == NULL || L->next == L) { + return; + } + + for(p = L->next; p != L; p = p->next) { + printf("%c ", p->data); + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.33/02.33.dev b/Dev-C++/ExerciseBook/02.33/02.33.dev new file mode 100644 index 0000000..7c1a3b5 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.33/02.33.dev @@ -0,0 +1,62 @@ +[Project] +FileName=02.33.dev +Name=02.33 +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=02.33.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.34-02.36/02.34-02.36.cpp b/Dev-C++/ExerciseBook/02.34-02.36/02.34-02.36.cpp new file mode 100644 index 0000000..0c20aeb --- /dev/null +++ b/Dev-C++/ExerciseBook/02.34-02.36/02.34-02.36.cpp @@ -0,0 +1,434 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include +#include "Status.h" //**01 **// + +// ָԪ +typedef char XElemType; + +// ָṹ +typedef struct XorNode { + XElemType data; + struct XorNode* LRPtr; +} XorNode; +typedef XorNode* XorPointer; + +// ͷָ˫ͷβָ +typedef struct { + XorPointer Left; // ֱָˣͷָ룩Ҷˣβָ룩 + XorPointer Right; +} XorLinkedList; + + +/* + * 2.34һPriorOrNext + * + * Lmarkʾ01 + */ +void Algo_2_34_1(XorLinkedList L, int mark); + +/* + * 2.34PriorOrNext + * + * Lmarkʾ01 + */ +void Algo_2_34_2(XorLinkedList L, int mark); + +/* + * 2.35 + * + * Ԫe뵽i֮ǰ + */ +Status Algo_2_35(XorLinkedList* L, int i, XElemType e); + +/* + * 2.36 + * + * ɾi(>0)㣬eܽԪֵ + */ +Status Algo_2_36(XorLinkedList* L, int i, char* e); + +// ָָpqֵ㣺p^q +XorPointer XorP(XorPointer p, XorPointer q); + +// ָL +Status Create(XorLinkedList* L, XElemType elems[], int n); + +// ȡǰ(cur)ǰ(mark=0)(mark=1) +XorPointer PriorOrNext(XorLinkedList L, XorPointer cur, int mark); + + +int main(int argc, char** argv) { + XorLinkedList L; + XElemType e; + XElemType* data = "123456789"; + + Create(&L, data, strlen(data)); + printf(" 2.34 ֤...\n"); + printf(" L = "); + Algo_2_34_1(L, 0); + printf(" L = "); + Algo_2_34_1(L, 1); + + printf(" 2.35 ֤...\n"); + Algo_2_35(&L, 5, '*'); + printf(" '*' ΪLĵ5˳...\n"); + printf(" L = "); + Algo_2_34_2(L, 0); + + printf(" 2.36 ֤...\n"); + Algo_2_36(&L, 5, &e); + printf(" ɾLĵ5 '%c' ...\n", e); + printf(" L = "); + Algo_2_34_2(L, 1); + + return 0; +} + + +// 㣺p^q +XorPointer XorP(XorPointer p, XorPointer q) { + // Cļʹõunsigned long + uintptr_t x, y, z; + + x = uintptr_t (p); + y = uintptr_t (q); + + // + z = x ^ y; + + return (XorPointer) z; +} + +// ָL +Status Create(XorLinkedList* L, XElemType elems[], int n) { + int i; + XorPointer pre_l, pre_m, pre_r; // ׼ָ룬ָнڵ + + (*L).Left = NULL; + (*L).Right = NULL; + + pre_l = pre_m = NULL; + + for(i = 0; i < n; i++) { + pre_r = (XorPointer) malloc(sizeof(XorNode)); + if(pre_r == NULL) { + exit(OVERFLOW); + } + pre_r->data = elems[i]; + + // ָ루׽ʱ + if(i == 0) { + L->Left = pre_r; + } + + // ָ룬ָһ + L->Right = pre_r; + + // ½ʱһָҪ޸ + if(pre_m != NULL) { + pre_m->LRPtr = XorP(pre_l, pre_r); + } + + pre_r->LRPtr = XorP(pre_m, NULL); + pre_l = pre_m; + pre_m = pre_r; + } + + return OK; +} + +// ȡǰ(cur)ǰ(mark=0)(mark=1) +XorPointer PriorOrNext(XorLinkedList L, XorPointer cur, int mark) { + XorPointer p_l, p_m, p_r; + + if(mark != 1 && mark != 0) { + return NULL; + } + + // ȷ + if(L.Left == NULL || L.Right == NULL || cur == NULL) { + return NULL; + } + + // ̣ + if(mark == 1) { + p_l = NULL; + p_m = L.Left; + + // ָ벻ƽ + while(p_m != cur) { + p_r = XorP(p_l, p_m->LRPtr); //Ҳһַ + p_l = p_m; + p_m = p_r; + } + + // p_mָcurǰ + p_r = XorP(p_l, p_m->LRPtr); + + return p_r; + + // ǰ + } else { + p_m = L.Right; + p_r = NULL; + + // ָ벻ƽ + while(p_m != cur) { + p_l = XorP(p_m->LRPtr, p_r); //һַ + p_r = p_m; + p_m = p_l; + } + + // p_mָcurĺ + p_l = XorP(p_m->LRPtr, p_r); + + return p_l; + } +} + +// Lmarkʾ01 +void Algo_2_34_1(XorLinkedList L, int mark) { + XorPointer cur; + + if(mark != 1 && mark != 0) { + return; + } + + // ȷ + if(L.Left == NULL || L.Right == NULL) { + return; + } + + // + if(mark == 0) { + cur = L.Left; + do { + printf("%c ", cur->data); + // ȡcurĺ + cur = PriorOrNext(L, cur, 1); + } while(cur != NULL); + + // + } else { + cur = L.Right; + do { + printf("%c ", cur->data); + // ȡcurǰ + cur = PriorOrNext(L, cur, 0); + } while(cur != NULL); + } + + printf("\n"); +} + +// Lmarkʾ01 +void Algo_2_34_2(XorLinkedList L, int mark) { + XorPointer p_l, p_m, p_r; + + if(mark != 1 && mark != 0) { + return; + } + + // ȷ + if(L.Left == NULL || L.Right == NULL) { + return; + } + + // + if(mark == 0) { + p_l = NULL; + p_m = L.Left; + + // p_mΪʱ˵ + while(p_m != NULL) { + printf("%c ", p_m->data); + p_r = XorP(p_l, p_m->LRPtr); // Ҳһַ + p_l = p_m; // ָ벻ƽ + p_m = p_r; + } + + // + } else { + p_m = L.Right; + p_r = NULL; + + // p_mΪʱ˵ + while(p_m != NULL) { + printf("%c ", p_m->data); + p_l = XorP(p_m->LRPtr, p_r); // һַ + p_r = p_m; // ָ벻ǰƽ + p_m = p_l; + } + } + + printf("\n"); +} + +// Ԫe뵽i֮ǰ +Status Algo_2_35(XorLinkedList* L, int i, XElemType e) { + XorPointer pl; // ָi-2 + XorPointer pre; // ָi-1 + XorPointer p; // ָi + XorPointer pr; // ָi+1 + XorPointer s; + int j; + + if(L == NULL) { + return ERROR; + } + + // i>=1 + if(i < 1) { + return ERROR; + } + + // ½ + s = (XorPointer) malloc(sizeof(XorNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // ȴΪյ + if((*L).Left == NULL && (*L).Right == NULL) { + if(i != 1) { + return ERROR; // ΪʱiֻΪ1 + } + + (*L).Left = (*L).Right = s; + s->LRPtr = NULL; + + return OK; + } + + j = 0; + pre = NULL; + p = (*L).Left; + + // ҵi-1㣬preָ + while(j < i - 1 && p != NULL) { + j++; + pr = XorP(pre, p->LRPtr); + pre = p; + p = pr; + } + + // iֵϹ棨 + if(j < i - 1) { + return ERROR; + } + + // Ҫ뵽β + if(p == NULL) { + pl = XorP(pre->LRPtr, p); + pre->LRPtr = XorP(pl, s); + + s->LRPtr = XorP(pre, p); + + (*L).Right = s; + + return OK; + } + + // Ҫ뵽ͷ + if(pre == NULL) { + pr = XorP(pre, p->LRPtr); + p->LRPtr = XorP(s, pr); + + s->LRPtr = XorP(pre, p); + + (*L).Left = s; + + return OK; + } + + // + pl = XorP(pre->LRPtr, p); + pr = XorP(pre, p->LRPtr); + pre->LRPtr = XorP(pl, s); + p->LRPtr = XorP(s, pr); + s->LRPtr = XorP(pre, p); + + return OK; +} + +// ɾi(>0)㣬eܽԪֵ +Status Algo_2_36(XorLinkedList* L, int i, XElemType* e) { + XorPointer pl; // ָi-2 + XorPointer pre; // ָi-1 + XorPointer p; // ָi + XorPointer pr; // ָi+1 + XorPointer prr; // ָi+2 + int j; + + if(L == NULL || (*L).Left == NULL || (*L).Right == NULL) { + return ERROR; + } + + // i>=1 + if(i < 1) { + return ERROR; + } + + // ȴֻһ + if((*L).Left == (*L).Right) { + if(i != 1) { + return ERROR; // ֻһʱiֻΪ1 + } + + *e = (*L).Left->data; + (*L).Left = (*L).Right = NULL; + + return OK; + } + + j = 0; + pre = NULL; + p = (*L).Left; + + // ҵi-1㣬preָ + while(j < i - 1 && p != NULL) { + j++; + pr = XorP(pre, p->LRPtr); + pre = p; + p = pr; + } + + // iֵϹ棨 + if(j < i - 1 || p == NULL) { + return ERROR; + } + + // 洢ɾԪصֵ + *e = p->data; + + /* ˣԪشڣpָɾԪ */ + + pr = XorP(pre, p->LRPtr); + + // ɾͷ + if(pre == NULL) { + // ڴʱ㣬pr!=NULL + prr = XorP(p, pr->LRPtr); + + pr->LRPtr = XorP(pre, prr); + + (*L).Left = pr; + } else { + pl = XorP(pre->LRPtr, p); + pre->LRPtr = XorP(pl, pr); + + // ɾһ + if(pr==NULL) { + (*L).Right = pre; + } else { + prr = XorP(p, pr->LRPtr); + pr->LRPtr = XorP(pre, prr); + } + } + + free(p); + + return OK; +} diff --git a/Dev-C++/ExerciseBook/02.34-02.36/02.34-02.36.dev b/Dev-C++/ExerciseBook/02.34-02.36/02.34-02.36.dev new file mode 100644 index 0000000..f597bfb --- /dev/null +++ b/Dev-C++/ExerciseBook/02.34-02.36/02.34-02.36.dev @@ -0,0 +1,62 @@ +[Project] +FileName=02.34-02.36.dev +Name=02.34-02.36 +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=02.34-02.36.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.37/02.37.cpp b/Dev-C++/ExerciseBook/02.37/02.37.cpp new file mode 100644 index 0000000..2890d7f --- /dev/null +++ b/Dev-C++/ExerciseBook/02.37/02.37.cpp @@ -0,0 +1,73 @@ +#include +#include "Status.h" //**01 **// +#include "DuLinkList.h" //**02 Ա**// + +/* + * 2.37 + * + * żԪλλԪؿǰżλԪؿ + */ +Status Algo_2_37(DuLinkList L); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + DuLinkList L; + int i; + + // ׼ + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(L, i, i); + } + printf("ǰ L = "); + ListTraverse(L, PrintElem); + + Algo_2_37(L); + + printf("ź L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// żԪλλԪؿǰżλԪؿ +Status Algo_2_37(DuLinkList L) { + DuLinkList head, tail, p; + + if(L == NULL || L->prior == NULL || L->next == NULL) { + return ERROR; + } + + head = L->next; // ָףƽ + tail = L->prior; // ָβ̶ + + // headtailмٸһԪ + while(head != tail && head->next != tail) { + // ָԭżλԪ + p = head->next; + + // ժ´żλԪ + p->next->prior = head; + head->next = p->next; + + // Ԫӵԭtail + p->next = tail->next; + p->prior = tail; + tail->next->prior = p; + tail->next = p; + + // ǰһλԪ + head = head->next; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/Dev-C++/ExerciseBook/02.37/02.37.dev b/Dev-C++/ExerciseBook/02.37/02.37.dev new file mode 100644 index 0000000..8a3e63c --- /dev/null +++ b/Dev-C++/ExerciseBook/02.37/02.37.dev @@ -0,0 +1,82 @@ +[Project] +FileName=02.37.dev +Name=02.37 +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=02.37.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=DuLinkList.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit3] +FileName=DuLinkList.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.37/DuLinkList.cpp b/Dev-C++/ExerciseBook/02.37/DuLinkList.cpp new file mode 100644 index 0000000..df3f94d --- /dev/null +++ b/Dev-C++/ExerciseBook/02.37/DuLinkList.cpp @@ -0,0 +1,130 @@ +/*===================== + * ˫ѭ + * + * 㷨: 2.182.19 + ======================*/ + +#include "DuLinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(DuLinkList* L) { + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + // ǰͺָ̾ + (*L)->next = (*L)->prior = *L; + + return OK; +} + +/* + * 㷨2.18 + * + * + * + * ˫ѭiλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(DuLinkList L, int i, ElemType e) { + DuLinkList p, s; + + // ȷ˫ѭڣΪձ + if(L == NULL) { + return ERROR; + } + + // ҵiλãã + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // ½ + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // s뵽pǰ棬Ϊi + s->prior = p->prior; + p->prior->next = s; + s->next = p; + p->prior = s; + + return OK; +} + +/* + * + * + * visit˫ѭL + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return; + } + + p = L->next; + + while(p != L) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * ȡѭLϵiԪص + * + * ע + * 1.staticĺǵǰֻDuLinkListʹãᱻļ + * 2.ΪlenҪȡlen+1ԪصʱѭԷصͷ + */ +static DuLinkList GetElemP(DuLinkList L, int i) { + DuLinkList p; + int count; + + // ȷ˫ѭڣΪձ + if(L == NULL) { + return NULL; + } + + // λòϹ + if(i < 1) { + return NULL; + } + + p = L; + count = 0; + + // ԲҵiԪ + while(p->next != L && count < i) { + p = p->next; + ++count; + } + + // ǡҵiԪ + if(count == i) { + return p; + } + + // ˣ˵p->next==LʱҪжiǷ + if(count + 1 < i) { + return NULL; + } + + // ˣ˵Ҫlen+1λϲԪ + return L; +} diff --git a/Dev-C++/ExerciseBook/02.37/DuLinkList.h b/Dev-C++/ExerciseBook/02.37/DuLinkList.h new file mode 100644 index 0000000..4a0edc2 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.37/DuLinkList.h @@ -0,0 +1,67 @@ +/*===================== + * ˫ѭ + * + * 㷨: 2.182.19 + ======================*/ + +#ifndef DULINKLIST_H +#define DULINKLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ˫ѭԪͶ */ +typedef int ElemType; + +/* + * ˫ѭṹ + * + * ע˫ѭͷ + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // ǰ + struct DuLNode* next; // +} DuLNode; + +// ָ˫ѭָ +typedef DuLNode* DuLinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(DuLinkList* L); + +/* + * 㷨2.18 + * + * + * + * ˫ѭiλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(DuLinkList L, int i, ElemType e); + +/* + * + * + * visit˫ѭL + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)); + +/* + * ȡѭLϵiԪص + * + * ע + * 1.staticĺǵǰֻDuLinkListʹãᱻļ + * 2.ΪlenҪȡlen+1ԪصʱѭԷصͷ + */ +static DuLinkList GetElemP(DuLinkList L, int i); + +#endif diff --git a/Dev-C++/ExerciseBook/02.38/02.38.cpp b/Dev-C++/ExerciseBook/02.38/02.38.cpp new file mode 100644 index 0000000..72a7780 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.38/02.38.cpp @@ -0,0 +1,153 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ˫ѭԪͶ */ +typedef int ElemType; + +/* + * ˫ѭṹһƴ + * + * ע˫ѭͷ + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // ǰ + struct DuLNode* next; // + int freq; // Ƶ +} DuLNode; + +// ָ˫ѭṹָ +typedef DuLNode* DuLinkList; + +/* + * 2.38 + * + * Ԫe״Lгֵλ򣬲Ƶ + */ +DuLinkList Algo_2_38(DuLinkList* L, ElemType e); + +// ˫ѭ +Status CreatList(DuLinkList* L, ElemType elems[], int n); + +// +void Output(DuLinkList L); + + +int main(int argc, char* argv[]) { + DuLinkList L; + int i; + ElemType data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + ElemType visit[10] = {1, 2, 2, 2, 3, 4, 4, 5, 5, 9}; + + CreatList(&L, data, 10); + printf("ǰ L = \n"); + Output(L); + + // ηtmpԤ + for(i = 0; i < 10; i++) { + Algo_2_38(&L, visit[i]); + } + + printf("ʺL = \n"); + Output(L); + + return 0; +} + +// Ԫe״Lгֵλ򣬲Ƶ +DuLinkList Algo_2_38(DuLinkList* L, ElemType e) { + DuLinkList pre, r; + + // ȷ + if(L == NULL || *L == NULL) { + return NULL; + } + + for(pre = *L; pre->next != *L && pre->next->data != e; pre = pre->next) { + // Ԫeǰ + } + + // ûҵԪ + if(pre->next == *L) { + return NULL; + } + + // ժԪe + r = pre->next; + pre->next = r->next; + r->next->prior = pre; + + // Ƶһ + r->freq++; + + for(pre = *L; pre->next != *L && pre->next->freq > r->freq; pre = pre->next) { + // ݷƵȣѰԪeӦòλõǰ + } + + // Ԫe뵽ʵλ + r->next = pre->next; + r->prior = pre; + pre->next->prior = r; + pre->next = r; + + // ָԪe + return r; +} + +// ˫ѭ +Status CreatList(DuLinkList* L, ElemType elems[], int n) { + DuLinkList s, p; + int i; + + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->data = -1; + (*L)->prior = *L; + (*L)->next = *L; + (*L)->freq = 0; + + p = *L; + + for(i = 0; i < n; i++) { + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + s->freq = 0; + + // β + s->next = *L; + (*L)->prior = s; + s->prior = p; + p->next = s; + + p = p->next; + } + + return OK; +} + +// +void Output(DuLinkList L) { + DuLinkList p; + + if(L == NULL || L->next == L || L->prior == NULL) { + return; + } + + printf("ݣ"); + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + printf("\n"); + + printf("Ƶȣ"); + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->freq); + } + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.38/02.38.dev b/Dev-C++/ExerciseBook/02.38/02.38.dev new file mode 100644 index 0000000..82acfae --- /dev/null +++ b/Dev-C++/ExerciseBook/02.38/02.38.dev @@ -0,0 +1,62 @@ +[Project] +FileName=02.38.dev +Name=02.38 +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=02.38.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.39-02.40/02.39-02.40.cpp b/Dev-C++/ExerciseBook/02.39-02.40/02.39-02.40.cpp new file mode 100644 index 0000000..eefde6c --- /dev/null +++ b/Dev-C++/ExerciseBook/02.39-02.40/02.39-02.40.cpp @@ -0,0 +1,184 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩpowԭ +#include "Status.h" //**01 **// + +// ϡʽ˳ṹ +typedef struct { + int coef; //ϵ + int exp; //ָ +} PolyTerm; + +// ʽ˳洢ṹ +typedef struct { + PolyTerm* data; + int last; // ʽ +} SqPoly; + +/* + * 2.39 + * + * ʽֵ + */ +int Algo_2_39(SqPoly P, int x); + +/* + * 2.40 + * + * Pc=Pa-Pb + */ +Status Algo_2_40(SqPoly Pa, SqPoly Pb, SqPoly* Pc); + +// ϡʽ +Status CreatPoly(SqPoly* P, PolyTerm Data[], int n); + +// ϡʽ +void OutputPoly(SqPoly P); + + +int main(int argc, char* argv[]) { + SqPoly Pa, Pb, Pc; + + PolyTerm a[5] = {{-2, 1}, {4, 3}, {11, 5}, {-7, 7}, {8, 9}}; + PolyTerm b[5] = {{3, 2}, {-5, 3}, {12, 4}, {-7, 7}, {6, 11}}; + + // ׼ + CreatPoly(&Pa, a, 5); + CreatPoly(&Pb, b, 5); + printf("Pan(x) = "); + OutputPoly(Pa); + printf("Pbn(x) = "); + OutputPoly(Pb); + + printf("\n"); + + printf(" 2.39 ֤...\n"); + printf(" Pa5(2) = %d", Algo_2_39(Pa, 2)); + printf("\n"); + printf(" Pb5(2) = %d", Algo_2_39(Pb, 2)); + printf("\n\n"); + + printf(" 2.40 ֤...\n"); + Algo_2_40(Pa, Pb, &Pc); + printf(" Pcn(x) = "); + OutputPoly(Pc); + + printf("ʽPcֵ Pc5(2) = %d\n", Algo_2_39(Pc, 2)); + + return 0; +} + + +// ʽֵ +int Algo_2_39(SqPoly P, int x) { + int i, sum; + + for(i = 0, sum = 0; i < P.last; i++) { + sum += P.data[i].coef * (int) (pow(x, P.data[i].exp)); + } + + return sum; +} + +// Pc=Pa-Pb +Status Algo_2_40(SqPoly Pa, SqPoly Pb, SqPoly* Pc) { + int i, j, k, sum; + + (*Pc).data = (PolyTerm*) malloc((Pa.last + Pb.last) * sizeof(PolyTerm)); + if((*Pc).data == NULL) { + exit(OVERFLOW); + } + + i = j = k = 0; + + // PaPbĹ + while(i < Pa.last && j < Pb.last) { + // PaָСPa + if(Pa.data[i].exp < Pb.data[j].exp) { + (*Pc).data[k++] = Pa.data[i]; + i++; + // PaָϴPbֻ򵥸ıϵž + } else if(Pa.data[i].exp > Pb.data[j].exp) { + (*Pc).data[k].coef = -Pb.data[j].coef; //Ÿı + (*Pc).data[k].exp = Pb.data[j].exp; + k++; + j++; + // ָʱҪ + } else { + sum = Pa.data[i].coef - Pb.data[j].coef; + + // ԴЧ + if(sum != 0) { + (*Pc).data[k].coef = sum; + (*Pc).data[k].exp = Pa.data[i].exp; + k++; + } + + i++; + j++; + } + } + + // Paδɨ꣬PbɨˣPaʣಿִ浽Pc + while(i < Pa.last) { + (*Pc).data[k++] = Pa.data[i]; + i++; + } + + // Pbδɨ꣬Ҫϵת浽Pc + while(j < Pb.last) { + (*Pc).data[k].coef = -Pb.data[j].coef; + (*Pc).data[k].exp = Pb.data[j].exp; + k++; + j++; + } + + // ¼ + (*Pc).last = k; + + return OK; +} + +Status CreatPoly(SqPoly* P, PolyTerm Data[], int n) { + int i; + + (*P).data = (PolyTerm*) malloc(n * sizeof(PolyTerm)); + if((*P).data == NULL) { + exit(OVERFLOW); + } + (*P).last = n; + + for(i = 0; i < n; i++) { + (*P).data[i] = Data[i]; + } + + return OK; +} + +void OutputPoly(SqPoly P) { + int i; + + for(i = 0; i < P.last; i++) { + if(i == 0) { + printf("%d", P.data[i].coef); + } else { + if(P.data[i].coef < 0) { + printf(" - "); + printf("%d", -P.data[i].coef); + } else { + printf(" + "); + printf("%d", P.data[i].coef); + } + } + + if(P.data[i].exp) { + printf("x"); + + if(P.data[i].exp != 1) { + printf("^%d", P.data[i].exp); + } + } + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.39-02.40/02.39-02.40.dev b/Dev-C++/ExerciseBook/02.39-02.40/02.39-02.40.dev new file mode 100644 index 0000000..f66199f --- /dev/null +++ b/Dev-C++/ExerciseBook/02.39-02.40/02.39-02.40.dev @@ -0,0 +1,62 @@ +[Project] +FileName=02.39-02.40.dev +Name=02.39-02.40 +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=02.39-02.40.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/ExerciseBook/02.41-02.42/02.41-02.42.cpp b/Dev-C++/ExerciseBook/02.41-02.42/02.41-02.42.cpp new file mode 100644 index 0000000..066e422 --- /dev/null +++ b/Dev-C++/ExerciseBook/02.41-02.42/02.41-02.42.cpp @@ -0,0 +1,215 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +// ϡʽ +typedef struct { + int coef; // ϵ + int exp; // ָ +} PolyTerm; + +// ϡʽʽṹѭṹ +typedef struct PolyNode { + PolyTerm data; + struct PolyNode* next; +} PolyNode; + +typedef PolyNode* PolyLink; +typedef PolyLink LinkedPoly; + + +/* + * 2.41 + * + * ʽĵ + */ +Status Algo_2_41(LinkedPoly P); + +/* + * 2.42 + * + * ָżԲֶʽ + */ +Status Algo_2_42(LinkedPoly* P, LinkedPoly* P_Odd, LinkedPoly* P_Even); + +// ϡʽ +Status CreatPoly(LinkedPoly* P, PolyTerm Data[], int n); + +// ϡʽ +void OutputPoly(LinkedPoly P); + + +int main(int argc, char* argv[]) { + LinkedPoly P1, P2; + PolyTerm a[7] = {{-2, 1}, {4, 2}, {2, 3}, {11, 5}, {-7, 6}, {8, 9}, {-3, 10}}; + + // ׼ + CreatPoly(&P1, a, 7); + CreatPoly(&P2, a, 7); + printf("Pn(x) = "); + OutputPoly(P1); + printf("\n"); + + printf(" 2.41 ֤...\n"); + { + + Algo_2_41(P1); + printf(" ʽĵ֮...\n"); + printf(" Pn(x) = "); + OutputPoly(P1); + printf("\n"); + } + + printf(" 2.42 ֤...\n"); + { + LinkedPoly P_odd, P_even; + Algo_2_42(&P2, &P_odd, &P_even); + printf(" ָżԲֶʽ֮...\n"); + printf(" P_odd = "); + OutputPoly(P_odd); + printf(" ż P_even = "); + OutputPoly(P_even); + } + + return 0; +} + + +// ʽĵ +Status Algo_2_41(LinkedPoly P) { + LinkedPoly r, pre; + + if(P == NULL || P->next == P) { + return ERROR; + } + + pre = P; + r = P->next; + + while(r != P) { + // ڲΪ0ָ + if(r->data.exp != 0) { + r->data.coef *= r->data.exp; // ϵָ + r->data.exp--; // ָһ + pre = r; + + // ָΪ0ʱ󵼺Ϊ0Ҫɾǰ + } else { + pre->next = r->next; + free(r); + } + + r = pre->next; + } + + return OK; +} + +// ָżԲֶʽ +Status Algo_2_42(LinkedPoly* P, LinkedPoly* P_Odd, LinkedPoly* P_Even) { + LinkedPoly r, s, p, q; + + // ͷ + *P_Odd = (LinkedPoly) malloc(sizeof(PolyNode)); + *P_Even = (LinkedPoly) malloc(sizeof(PolyNode)); + if(*P_Odd == NULL || *P_Even == NULL) { + exit(OVERFLOW); + } + (*P_Odd)->next = *P_Odd; + (*P_Even)->next = *P_Even; + + if(P == NULL || *P == NULL) { + return ERROR; + } + + p = *P_Odd; + q = *P_Even; + r = (*P)->next; + + // ʽ + while(r != (*P)) { + s = r; + r = r->next; + + // ָΪ + if(s->data.exp % 2 != 0) { + s->next = p->next; + p->next = s; + p = p->next; + + // ָΪż + } else { + s->next = q->next; + q->next = s; + q = q->next; + } + } + + // ԭĶʽ + free(*P); + *P = NULL; + + return OK; +} + +// ϡʽ +Status CreatPoly(LinkedPoly* P, PolyTerm Data[], int n) { + int i; + LinkedPoly s, r; + + // ͷ + *P = (LinkedPoly) malloc(sizeof(PolyNode)); + if(*P == NULL) { + exit(OVERFLOW); + } + (*P)->next = *P; + + for(i = 0, r = *P; i < n; i++) { + s = (LinkedPoly) malloc(sizeof(PolyNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = Data[i]; + + // ӵʽ + s->next = r->next; + r->next = s; + + r = r->next; + } + + return OK; +} + +// ϡʽ +void OutputPoly(LinkedPoly P) { + LinkedPoly r; + + if(P == NULL || P->next == P) { + return; + } + + for(r = P->next; r != P; r = r->next) { + if(r == P->next) { + printf("%d", r->data.coef); + } else { + if(r->data.coef < 0) { + printf(" - "); + printf("%d", -r->data.coef); + } else { + printf(" + "); + printf("%d", r->data.coef); + } + } + + if(r->data.exp) { + printf("x"); + + if(r->data.exp != 1) { + printf("^%d", r->data.exp); + } + } + } + + printf("\n"); +} diff --git a/Dev-C++/ExerciseBook/02.41-02.42/02.41-02.42.dev b/Dev-C++/ExerciseBook/02.41-02.42/02.41-02.42.dev new file mode 100644 index 0000000..7a1c1db --- /dev/null +++ b/Dev-C++/ExerciseBook/02.41-02.42/02.41-02.42.dev @@ -0,0 +1,62 @@ +[Project] +FileName=02.41-02.42.dev +Name=02.41-02.42 +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=02.41-02.42.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/README.md b/Dev-C++/README.md index aebfc5a..2b7c987 100644 --- a/Dev-C++/README.md +++ b/Dev-C++/README.md @@ -8,3 +8,43 @@ > **Dev-C++** [5.11] > **TDM-GCC** [gcc-4.9.2] + +## 使用说明 + +1. 确保 **Dev-C++** 已安装完毕（安装方式可自行搜索），并选择"TDM-GCC 4.9.2 64-bit Debug"编译选项（别的编译选项也可使用） +![DEV00](image/DEV00.png) + +2. 启动Dev-C++，选择"打开项目"（也可从"文件"菜单中打开） +![DEV01](image/DEV01.png) + +3. 选择目标项目文件*.dev，打开项目 +![DEV02](image/DEV02.png) + +4. 配置"include"目录，使用Status文件夹所在的目录，主要为引入 **Status.h** 文件做准备 + + ![DEV03](image/DEV03.png) + + ![DEV04](image/DEV04.png) + +5. 配置静态库位置（全局），即 **Status.a** 静态库所在的目录 +![DEV05](image/DEV05.png) + +6. 对项目进行"编译"后，选择包含"main"方法的源码"运行"即可，常用的命令如下图 + + ![DEV06](image/DEV06.png) + + ![DEV07](image/DEV07.png) + + + +## 注意事项 + +1. 教材源码CourseBook跟习题集源码ExerciseBook是放在**多个项目**当中的 +2. Dev-C++版本的源码，其文件编码格式使用了GB2312 +3. 由于C语言源码在Dev-C++中存在一些兼容问题（行注释的兼容问题），所以涉及 **.c** 后缀的文件均改成了 **.cpp** 的后缀形式 +4. **Dev-C++也可以用于打开"CFree"版本的源码，所以如果使用CFree遇到兼容性问题，可尝试使用Dev-C++** +5. 上述配置的静态库是全局生效的，也可以对单个项目进行局部配置，配置方式如图： + + ![DEV08](image/DEV08.png) + + ![DEV09](image/DEV09.png) diff --git a/Dev-C++/Status/Status.a b/Dev-C++/Status/Status.a new file mode 100644 index 0000000..10fb643 Binary files /dev/null and b/Dev-C++/Status/Status.a differ diff --git a/Dev-C++/Status/Status.cpp b/Dev-C++/Status/Status.cpp new file mode 100644 index 0000000..6e7dd50 --- /dev/null +++ b/Dev-C++/Status/Status.cpp @@ -0,0 +1,165 @@ +#include +#include +#include // ṩva_listva_startva_argva_end +#include // ṩisprintԭ + +/* + * Զ¼뺯ڴļfpжȡʽ + * fscanf֮ͬڴ˺ֻȡַַ + * + * ע + * 1. ԼиʽΪʽ磺%d%c%sȣ%2d%5s + * 2. ȡַʱոǴӡַֹͣȡ + */ +int ReadData(FILE* fp, char* format, ...) { + int* i; // 洢ȡ + float* f; // 洢ȡĸ + char* ch; // 洢ȡַ + char* s; // 洢ȡַ + + int n; // 洢ַַ + + int len; // ʽformatij + int k; // ʽʱα + + int tmp; // ݴļжȡַ + + va_list ap; // ɱָ룬ָ洢ݵı + + // ۼƳɹȡַ + int count = 0; + + + /* + * ȡʽij + * Ԥʽɼ + */ + len = strlen(format); + + // apָ׸ɱ + va_start(ap, format); + + // ֻΪż¶% + for(k = 1; k <= len; k = k + 2) { + // зַ + while((tmp = getc(fp)) != EOF) { + // ׸ַַ· + if((tmp >= 0 && tmp <= 127)) { + ungetc(tmp, fp); + break; + } + } + + // Ѷļβȡ + if(tmp == EOF) { + break; + } + + // "%c"Ӧöȡַ + if(format[k] == 'c') { + ch = va_arg(ap, char*); + + count += fscanf(fp, "%c", ch); + } + + // "%d"Ӧöȡ + if(format[k] == 'd') { + i = va_arg(ap, int*); + + while((tmp = getc(fp)) != EOF) { + // Ѱ + if((tmp >= '0' && tmp <= '9') || tmp == '-' || tmp == '+') { + ungetc(tmp, fp); + break; + } + } + + if(tmp != EOF) { + count += fscanf(fp, "%d", i); + } + } + + // ȡͣһɴ洢Ϊdouble + if(format[k] == 'f') { + f = va_arg(ap, float*); + + while((tmp = getc(fp)) != EOF) { + if((tmp >= '0' && tmp <= '9') || tmp == '-' || tmp == '+' || tmp == '.') { + ungetc(tmp, fp); + break; + } + } + + if(tmp != EOF) { + count += fscanf(fp, "%f", f); + } + } + + // ȡַ + if(format[k] == 's') { + s = va_arg(ap, char*); + + n = 0; + + // ųոĿɴӡַ + while((tmp = getc(fp)) != EOF && (!isprint(tmp) || tmp == ' ')) { + } + + // δļβ + if(!feof(fp)) { + + // ַ· + ungetc(tmp, fp); + + while((tmp = getc(fp)) != EOF) { + // 洢ųոĿɴӡַ + if(isprint(tmp) && tmp != ' ') { + s[n++] = tmp; + } else { + ungetc(tmp, fp); + break; + } + } + + count++; + } + + // ַһַΪַ + s[n] = '\0'; + } + }// for + + va_end(ap); + + return count; +} + +// »سԼ +void PressEnterToContinue() { + int debug = 1; + + fflush(stdin); + + printf("\nPress Enter to Continue..."); + + // ڲԽ׶ʱdebug=1ԶӻУڲ + if(debug) { + printf("\n"); + + // ʱdebug=0ֶ뻻Уóͣ۲ÿһ + } else { + getchar(); + } + + fflush(stdin); +} + +// ͣһʱ䣬timeʱ +void Wait(long time) { + double i; + + for(i = 0.01; i <= 100000.0 * time; i += 0.01) { + // ѭ + } +} + diff --git a/Dev-C++/Status/Status.dev b/Dev-C++/Status/Status.dev new file mode 100644 index 0000000..52dfc27 --- /dev/null +++ b/Dev-C++/Status/Status.dev @@ -0,0 +1,72 @@ +[Project] +FileName=Status.dev +Name=Status +Type=2 +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=2 + +[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=Status.h +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + +[Unit2] +FileName=Status.cpp +CompileCpp=0 +Folder= +Compile=1 +Link=1 +Priority=1000 +OverrideBuildCmd=0 +BuildCmd= + diff --git a/Dev-C++/Status/Status.h b/Dev-C++/Status/Status.h new file mode 100644 index 0000000..205b695 --- /dev/null +++ b/Dev-C++/Status/Status.h @@ -0,0 +1,46 @@ +/* + * ע + * ޶Ŀİϣȡÿģ鶼Ե + * Statusģᱻģãôܶࡣ + * ֱӽStatusģ鸴ƵģУᵼ̫ظ룬 + * һ̬ģ鹲Ƚϻ + */ + +#ifndef STATUS_H +#define STATUS_H + +#include + +/* ״̬ */ +#define TRUE 1 // / +#define FALSE 0 // / +#define OK 1 // ͨ/ɹ +#define ERROR 0 // /ʧ + +//ϵͳд״̬붨壬Ҫֹͻ +#ifndef OVERFLOW +#define OVERFLOW -2 //ջ +#endif + +//ϵͳд״̬붨壬Ҫֹͻ +#ifndef NULL +#define NULL ((void*)0) +#endif + +/* ״̬ */ +typedef int Status; + + +// ȡ +int ReadData(FILE* fp, char* format, ...); + +// »سԼ +void PressEnterToContinue(); + +// ͣһʱ䣬timeʱ +void Wait(long time); + +#endif + + + diff --git a/Dev-C++/image/DEV00.png b/Dev-C++/image/DEV00.png new file mode 100644 index 0000000..25ef274 Binary files /dev/null and b/Dev-C++/image/DEV00.png differ diff --git a/Dev-C++/image/DEV01.png b/Dev-C++/image/DEV01.png new file mode 100644 index 0000000..ffe9372 Binary files /dev/null and b/Dev-C++/image/DEV01.png differ diff --git a/Dev-C++/image/DEV02.png b/Dev-C++/image/DEV02.png new file mode 100644 index 0000000..5dae3c8 Binary files /dev/null and b/Dev-C++/image/DEV02.png differ diff --git a/Dev-C++/image/DEV03.png b/Dev-C++/image/DEV03.png new file mode 100644 index 0000000..40e0ea1 Binary files /dev/null and b/Dev-C++/image/DEV03.png differ diff --git a/Dev-C++/image/DEV04.png b/Dev-C++/image/DEV04.png new file mode 100644 index 0000000..2dde9a0 Binary files /dev/null and b/Dev-C++/image/DEV04.png differ diff --git a/Dev-C++/image/DEV05.png b/Dev-C++/image/DEV05.png new file mode 100644 index 0000000..7979a07 Binary files /dev/null and b/Dev-C++/image/DEV05.png differ diff --git a/Dev-C++/image/DEV06.png b/Dev-C++/image/DEV06.png new file mode 100644 index 0000000..6896c8b Binary files /dev/null and b/Dev-C++/image/DEV06.png differ diff --git a/Dev-C++/image/DEV07.png b/Dev-C++/image/DEV07.png new file mode 100644 index 0000000..cf4cd65 Binary files /dev/null and b/Dev-C++/image/DEV07.png differ diff --git a/Dev-C++/image/DEV08.png b/Dev-C++/image/DEV08.png new file mode 100644 index 0000000..470a0f5 Binary files /dev/null and b/Dev-C++/image/DEV08.png differ diff --git a/Dev-C++/image/DEV09.png b/Dev-C++/image/DEV09.png new file mode 100644 index 0000000..4f975f8 Binary files /dev/null and b/Dev-C++/image/DEV09.png differ diff --git a/README.md b/README.md index dee93d3..c4f602d 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ ## 项目介绍 -本项目与教材《**数据结构-C语言版**》[严蔚敏,吴伟民版]以及《**数据结构题集-C语言版**》[严蔚敏,吴伟民,米宁版]配套。 +本项目中的源码与教材《**数据结构-C语言版**》[严蔚敏,吴伟民版]以及《**数据结构题集-C语言版**》[严蔚敏,吴伟民,米宁版]配套。 | 数据结构教材 | 数据结构题集 | | :----------------------------: | :----------------------------: | @@ -12,7 +12,7 @@ ## 项目结构 -本项目分为4个版本，分别是：**CFree**、**Dev-C++**、**CLion**、**VisualC++**，其中： +本项目包含了**教材源码**跟**习题源码**，并分为4个版本，分别是：**CFree**、**Dev-C++**、**CLion**、**VisualC++**，其中： - **CFree** 版本是早期上传的完整版本，该版本在CFree这个IDE下测试通过。此版本中的代码虽有瑕疵，但不会再维护，新的更新会在下面三个分支版本中呈现。 - **Dev-C++** 版本是指在Dev-C++这个IDE下测试通过的版本。 @@ -26,12 +26,16 @@ > >> CLion需要掌握一点cmake知识，对笔记本性能要求也略高。不过JetBrains系列的产品，功能优秀没得说，强烈建议尝试。 > ->> Microsoft Visual C++是微软出品，该系列号称地表最强，不过复杂度也是很高，对于新手并不友好，需要耐心琢磨。如果将来不是走C/C++/C#等路线，可以先不使用（注：从2018年开始，计算机二级C语言项目的考试中，已将VC++6换成了Microsoft Visual C++ 2010。所以如果有考级需求的同学，请自行熟悉该IDE） +>> Microsoft Visual C++是微软出品，该系列号称地表最强，不过复杂度也是很高，对于新手并不友好，需要耐心琢磨。如果将来不是走C/C++/C#等路线，可以先不使用。（注：从2018年开始，计算机二级C语言项目的考试中，已将VC++6换成了Microsoft Visual C++ 2010。所以如果有考级需求的同学，请自行熟悉该IDE） + +**习题解析**中存储了《数据结构题集》中非代码题的解析，对于需要写代码解决的问题，参见 **Dev-C++**、**CLion**、**VisualC++** 这三个版本中的源码。 ``` 注： -1. "CFree"是完整版本。"Dev-C++"/"CLion"/"VisualC++"是新增的版本，后续会抽空更新，直到最终取代"CFree"版本。 -2. 这4个版本各自独立，没有任何依赖关系，可单独运行/测试。 +1. "CFree"是完整版本。"Dev-C++"/"CLion"/"VisualC++"是新增的版本，这三个版本最终会取代"CFree"版本。 +2. "CFree"版本既可以用CFree直接打开，也支持用Dev-C++打开，所以当使用CFree遇到兼容问题时，可尝试用Dev-C++。 +3. 上述四个版本各自独立，没有任何依赖关系，可单独运行/测试。 +4. 对所有版本的代码均未充分测试，所以如有BUG请到Issues反馈。 ``` @@ -39,10 +43,12 @@ 总的目标是保障正确性，提高可读性，降低学习难度，具体来说包含以下几点： -1. 修复一些已知/潜在的BUG -2. 简化源码之间的引用关系，争取每个模块都可以单独运行测试 -3. 修剪被引用源码中的次要内容，使得焦点更聚集，重点更突出 -4. 增加注释与帮助信息，使源码展示更友好 +1. 项目工程化★★ +2. 修复一些已知/潜在的BUG +3. 简化源码之间的引用关系，争取每个模块都可以单独运行测试 +4. 修剪被引用源码中的次要内容，使得焦点更聚集，重点更突出 +5. 增加注释与帮助信息，使源码展示更友好 +6. 出自教材中的算法，会尽量使其代码与教材一致，如有改动，会在注释中提示。其它算法会视情形书写，不唯一 ## 使用方式 @@ -87,5 +93,17 @@ Commit信息中的`emoji`参考来源： ## 附：教材源码目录 -| 章 | 节 | 内容 | 包含算法 | 备注 | -| :-- | :-- | :-- | :------ | :-- | +| 章 | 节 | 内容 | 包含算法 | 备注 | +| :------- | :---------- | :----------- | :-------------------- | :------------------- | +| 01 绪论 | | | | 定义一些共享常量和函数 | +| 02 线性表 | SqList | 顺序表 | 2.3、2.4、2.5、2.6 | | +| | Union | A=A∪B | 2.1 | | +| | MergeSqList | C=A+B | 2.2、2.7 | 归并顺序表 | +| | LinkList | 链表 | 2.8、2.9、2.10、2.11 | | +| | MergeList | C=A+B | 2.12 | 归并链表 | +| | SLinkList | 静态链表 | 2.13、2.14、2.15、2.16 | | +| | Difference | (A-B)∪(B-A) | 2.17 | | +| | DuLinkList | 双向循环链表 | 2.18、2.19 | | +| | ELinkList | 扩展的线性链表 | 2.20 | | +| | MergeEList | C=A+B | 2.21 | 归并扩展的线性链表 | +| | Polynomial | 一元多项式 | 2.22、2.23 | | diff --git a/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj b/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj new file mode 100644 index 0000000..e252679 --- /dev/null +++ b/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + + + + + + + + {4DDF7C1A-9DF8-4983-B478-1B8928B8A239} + My0201_SqList + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj.filters b/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj.filters new file mode 100644 index 0000000..2a3720a --- /dev/null +++ b/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 头文件 + + + + + 源文件 + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj.user b/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0201_SqList/0201_SqList.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0201_SqList/SqList-main.c b/VisualC++/CourseBook/0201_SqList/SqList-main.c new file mode 100644 index 0000000..340e16e --- /dev/null +++ b/VisualC++/CourseBook/0201_SqList/SqList-main.c @@ -0,0 +1,170 @@ +#include +#include "SqList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SqList L; // ˳ + + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼ˳ L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + if(ListEmpty(L) == TRUE) { + printf(" L Ϊգ\n"); + } else { + printf(" L Ϊգ\n"); + } + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" Ϊʾ L %d λò \"%d\"...\n", i, 2 * i); + ListInsert(&L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + i = ListLength(L); + printf(" L ijΪ %d \n", i); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأL = "); + ListTraverse(L, PrintElem); + + printf(" ɾ L е 6 Ԫ...\n"); + + if(ListDelete(&L, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" GetElem \n"); + { + GetElem(L, 4, &e); + printf(" L е 4 λõԪΪ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + printf(" L еһԪֵ \"7\" Ԫ \"%d\" \n", L.elem[i - 1]); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" L ǰ"); + if(ListEmpty(L) == TRUE) { + printf(" L Ϊգ\n"); + } else { + printf(" L Ϊգ\n"); + } + + ClearList(&L); + + printf(" L "); + if(ListEmpty(L) == TRUE) { + printf(" L Ϊգ\n"); + } else { + printf(" L Ϊգ\n"); + } + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" L ǰ"); + if(L.elem != NULL) { + printf(" L ڣ\n"); + } else { + printf(" L ڣ\n"); + } + + DestroyList(&L); + + printf(" L "); + if(L.elem != NULL) { + printf(" L ڣ\n"); + } else { + printf(" L ڣ\n"); + } + } + PressEnterToContinue(); + + + return 0; +} diff --git a/VisualC++/CourseBook/0201_SqList/SqList.c b/VisualC++/CourseBook/0201_SqList/SqList.c new file mode 100644 index 0000000..f797103 --- /dev/null +++ b/VisualC++/CourseBook/0201_SqList/SqList.c @@ -0,0 +1,337 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * (ṹ) + * + * ͷ˳ռڴ档 + */ +Status DestroyList(SqList* L) { + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // ͷ˳ڴ + free((*L).elem); + + // ͷڴÿָ + (*L).elem = NULL; + + // ˳ȸ + (*L).length = 0; + (*L).listsize = 0; + + return OK; +} + +/* + * ÿ() + * + * ֻ˳д洢ݣͷ˳ռڴ档 + */ +Status ClearList(SqList* L) { + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + (*L).length = 0; + + return OK; +} + +/* + * п + * + * ж˳ǷЧݡ + * + * ֵ + * TRUE : ˳Ϊ + * FALSE: ˳Ϊ + */ +Status ListEmpty(SqList L) { + return L.length == 0 ? TRUE : FALSE; +} + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e) { + // ΪiĺλãϷΧǣ[1, length] + if(i < 1 || i > L.length) { + return ERROR; //iֵϷ + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // ȷ˳ṹ + if(L.elem == NULL) { + return ERROR; + } + + /* + * iijֵΪ1Ԫصλ + * + * ʵȻдǽiʼΪ1Ԫص + * ڽ̲ǰλģдλ + */ + i = 1; + + // pijֵΪ1ԪصĴ洢λ + p = L.elem; + + // ˳ + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(SqList L, ElemType cur_e, ElemType* pre_e) { + int i; + + // ȷ˳ṹڣٰԪ + if(L.elem == NULL || L.length < 2) { + return ERROR; + } + + // iʼΪ1Ԫصġ + i = 0; + + // ӵ1Ԫؿʼcur_eλ + while(i < L.length && L.elem[i] != cur_e) { + ++i; + } + + // cur_e׸Ԫ(ûǰ)ûҵԪcur_eERROR + if(i==0 || i >= L.length) { + return ERROR; + } + + // 洢cur_eǰ + *pre_e = L.elem[i - 1]; + + return OK; +} + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(SqList L, ElemType cur_e, ElemType* next_e) { + int i; + + // ȷ˳ṹڣٰԪ + if(L.elem == NULL || L.length < 2) { + return ERROR; + } + + // iʼΪ1Ԫصġ + i = 0; + + // ӵ1Ԫؿʼcur_eλ + while(i < L.length-1 && L.elem[i] != cur_e) { + ++i; + } + + // cur_e1Ԫ(ûǰ)ûҵԪcur_eERROR + if(i >= L.length-1) { + return ERROR; + } + + // 洢cur_eǰ + *next_e = L.elem[i + 1]; + + return OK; +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * 㷨2.5 + * + * ɾ + * + * ɾ˳iλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(SqList* L, int i, ElemType* e) { + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length) { + return ERROR; + } + + // pΪɾԪصλ + p = &(*L).elem[i - 1]; + + // 1.ȡɾԪ + *e = *p; + + // βԪλ + q = (*L).elem + (*L).length - 1; + + // 2.ԪأɾԪصλϻԪؽ + for(++p; p <= q; ++p) { + *(p - 1) = *p; + } + + // 3.1 + (*L).length--; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/CourseBook/0201_SqList/SqList.h b/VisualC++/CourseBook/0201_SqList/SqList.h new file mode 100644 index 0000000..602ec4e --- /dev/null +++ b/VisualC++/CourseBook/0201_SqList/SqList.h @@ -0,0 +1,149 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * (ṹ) + * + * ͷ˳ռڴ档 + */ +Status DestroyList(SqList* L); + +/* + * ÿ() + * + * ֻ˳д洢ݣͷ˳ռڴ档 + */ +Status ClearList(SqList* L); + +/* + * п + * + * ж˳ǷЧݡ + * + * ֵ + * TRUE : ˳Ϊ + * FALSE: ˳Ϊ + */ +Status ListEmpty(SqList L); + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L); + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(SqList L, ElemType cur_e, ElemType* pre_e); + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(SqList L, ElemType cur_e, ElemType* next_e); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * 㷨2.5 + * + * ɾ + * + * ɾ˳iλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(SqList* L, int i, ElemType* e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj b/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj new file mode 100644 index 0000000..51b8a83 --- /dev/null +++ b/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj @@ -0,0 +1,78 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + + + + + + + + + + {5C53EFFE-EE74-42B8-875C-CFB7B2659917} + My0202_Union + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj.filters b/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj.filters new file mode 100644 index 0000000..24fc099 --- /dev/null +++ b/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj.filters @@ -0,0 +1,36 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 头文件 + + + 头文件 + + + + + 源文件 + + + 源文件 + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj.user b/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0202_Union/0202_Union.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0202_Union/SqList.c b/VisualC++/CourseBook/0202_Union/SqList.c new file mode 100644 index 0000000..ada375f --- /dev/null +++ b/VisualC++/CourseBook/0202_Union/SqList.c @@ -0,0 +1,172 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e) { + // ΪiĺλãϷΧǣ[1, length] + if(i < 1 || i > L.length) { + return ERROR; //iֵϷ + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // ȷ˳ṹ + if(L.elem == NULL) { + return ERROR; + } + + /* + * iijֵΪ1Ԫصλ + * + * ʵȻдǽiʼΪ1Ԫص + * ڽ̲ǰλģдλ + */ + i = 1; + + // pijֵΪ1ԪصĴ洢λ + p = L.elem; + + // ˳ + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/CourseBook/0202_Union/SqList.h b/VisualC++/CourseBook/0202_Union/SqList.h new file mode 100644 index 0000000..b2569e4 --- /dev/null +++ b/VisualC++/CourseBook/0202_Union/SqList.h @@ -0,0 +1,93 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L); + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/CourseBook/0202_Union/Union-main.c b/VisualC++/CourseBook/0202_Union/Union-main.c new file mode 100644 index 0000000..b155295 --- /dev/null +++ b/VisualC++/CourseBook/0202_Union/Union-main.c @@ -0,0 +1,43 @@ +#include +#include "Union.h" //**02 Ա**// +#include "SqList.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ElemType a[5] = {5, 2, 1, 3, 9}; + ElemType b[7] = {7, 2, 6, 9, 11, 3, 10}; + SqList La, Lb; + int i; + + // ʼLa + InitList(&La); + for(i = 1; i <= 5; i++) { + ListInsert(&La, i, a[i - 1]); + } + + // ʼLb + InitList(&Lb); + for(i = 1; i <= 7; i++) { + ListInsert(&Lb, i, b[i - 1]); + } + + // La + printf("La = "); + ListTraverse(La, PrintElem); + + // Lb + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // ±La + printf("La = LaLb = "); + Union(&La, Lb); + ListTraverse(La, PrintElem); + + return 0; +} diff --git a/VisualC++/CourseBook/0202_Union/Union.c b/VisualC++/CourseBook/0202_Union/Union.c new file mode 100644 index 0000000..e240db2 --- /dev/null +++ b/VisualC++/CourseBook/0202_Union/Union.c @@ -0,0 +1,45 @@ +/*============== + * 󲢼 + * + * 㷨: 2.1 + ===============*/ + +#include "Union.h" //**02 Ա**// + +/* + * 㷨2.1 + * + * A=AB + * + * LaLbIJء + * ɵIJƴLaϣLaΪָ͡ + */ +void Union(SqList* La, SqList Lb) { + int La_len, Lb_len; + int i; + ElemType e; + + // ˳ + La_len = ListLength(*La); + Lb_len = ListLength(Lb); + + for(i = 1; i <= Lb_len; i++) { + // ȡLbеiԪظe + GetElem(Lb, i, &e); + + // eLa + if(!LocateElem(*La, e, equal)) { + ListInsert(La, ++La_len, e); + } + } +} + +/* + * е + * + * жԪǷȡ + * ȣ򷵻TRUE򣬷FALSE + */ +Status equal(ElemType e1, ElemType e2) { + return e1 == e2 ? TRUE : FALSE; +} diff --git a/VisualC++/CourseBook/0202_Union/Union.h b/VisualC++/CourseBook/0202_Union/Union.h new file mode 100644 index 0000000..cef4815 --- /dev/null +++ b/VisualC++/CourseBook/0202_Union/Union.h @@ -0,0 +1,33 @@ +/*============== + * 󲢼 + * + * 㷨: 2.1 + ===============*/ + +#ifndef UNION_H +#define UNION_H + +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + + +/* + * 㷨2.1 + * + * A=AB + * + * LaLbIJء + * ɵIJƴLaϣLaΪָ͡ + */ +void Union(SqList* La, SqList Lb); + +/* + * е + * + * жԪǷȡ + * ȣ򷵻TRUE򣬷FALSE + */ +Status equal(ElemType e1, ElemType e2); + +#endif diff --git a/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj b/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj new file mode 100644 index 0000000..0e335e6 --- /dev/null +++ b/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj @@ -0,0 +1,78 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + + + + + + + + + + {D3309A60-3384-4EB0-9392-BEB5BF9934BF} + My0203_MergeSqList + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj.filters b/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj.filters new file mode 100644 index 0000000..9b20ca4 --- /dev/null +++ b/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj.filters @@ -0,0 +1,36 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + 源文件 + + + + + 头文件 + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj.user b/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0203_MergeSqList/0203_MergeSqList.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0203_MergeSqList/MergeSqList-main.c b/VisualC++/CourseBook/0203_MergeSqList/MergeSqList-main.c new file mode 100644 index 0000000..f6834fa --- /dev/null +++ b/VisualC++/CourseBook/0203_MergeSqList/MergeSqList-main.c @@ -0,0 +1,49 @@ +#include +#include "SqList.h" +#include "MergeSqList.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ElemType a[4] = {3, 5, 8, 11}; + ElemType b[7] = {2, 6, 8, 9, 11, 15, 20}; + + SqList La, Lb, Lc1, Lc2; + int i; + + // ʼLa + InitList(&La); + for(i = 1; i <= 4; i++) { + ListInsert(&La, i, a[i - 1]); + } + + // ʼLb + InitList(&Lb); + for(i = 1; i <= 7; i++) { + ListInsert(&Lb, i, b[i - 1]); + } + + // La + printf("La = "); + ListTraverse(La, PrintElem); + + // Lb + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 鲢˳LaLb㷨2.2 + MergeSqList_1(La, Lb, &Lc1); + printf("鲢LaLbΪLc1 = "); + ListTraverse(Lc1, PrintElem); + + // 鲢˳LaLb㷨2.7 + MergeSqList_2(La, Lb, &Lc2); + printf("鲢LaLbΪLc2 = "); + ListTraverse(Lc2, PrintElem); + + return 0; +} diff --git a/VisualC++/CourseBook/0203_MergeSqList/MergeSqList.c b/VisualC++/CourseBook/0203_MergeSqList/MergeSqList.c new file mode 100644 index 0000000..4df7d41 --- /dev/null +++ b/VisualC++/CourseBook/0203_MergeSqList/MergeSqList.c @@ -0,0 +1,104 @@ +/*================== + * 鲢ǽ˳ + * + * 㷨: 2.22.7 + ===================*/ + +#include "MergeSqList.h" //**02 Ա**// + + +/* + * 㷨2.2 + * + * ǵݼ鲢C=A+B + * + * 鲢˳LaLbµ˳Lc + * УLaLbLcΪǵݼС + */ +void MergeSqList_1(SqList La, SqList Lb, SqList* Lc) { + int La_len, Lb_len; + int i, j, k; + ElemType ai, bj; + + i = j = 1; + k = 0; + + // ʼLc + InitList(Lc); + + // ȡLaLbij + La_len = ListLength(La); + Lb_len = ListLength(Lb); + + // LaLbδ + while(i <= La_len && j <= Lb_len) { + GetElem(La, i, &ai); + GetElem(Lb, j, &bj); + + // ȽϱԪأȽȽСԪؼ˳Lc + if(ai <= bj) { + ListInsert(Lc, ++k, ai); + i++; + } else { + ListInsert(Lc, ++k, bj); + j++; + } + } + + // Lbѱ꣬Laδ꣬LaʣԪؼLc + while(i <= La_len) { + GetElem(La, i++, &ai); + ListInsert(Lc, ++k, ai); + } + + // Laѱ꣬Lbδ꣬LbʣԪؼLc + while(j <= Lb_len) { + GetElem(Lb, j++, &bj); + ListInsert(Lc, ++k, bj); + } +} + +/* + * 㷨2.7 + * + * ǵݼ鲢C=A+B + * + * 鲢˳LaLbµ˳Lc + * УLaLbLcΪǵݼС + */ +void MergeSqList_2(SqList La, SqList Lb, SqList* Lc) { + ElemType* pa, * pb, * pc; + ElemType* pa_last, * pb_last; + + pa = La.elem; // ָLaһԪ + pb = Lb.elem; // ָLbһԪ + + // ûʹInitListLc + (*Lc).listsize = (*Lc).length = La.length + Lb.length; + pc = (*Lc).elem = (ElemType*) malloc((*Lc).listsize * sizeof(ElemType)); + if(pc == NULL) { + exit(OVERFLOW); + } + + pa_last = La.elem + La.length - 1; // ָLaһԪ + pb_last = Lb.elem + Lb.length - 1; // ָLbһԪ + + // LaLbδ + while(pa <= pa_last && pb <= pb_last) { + if(*pa <= *pb) { + *pc++ = *pa++; + } else { + *pc++ = *pb++; + } + } + + // Lbѱ꣬Laδ꣬LaʣԪؼLc + while(pa <= pa_last) { + *pc++ = *pa++; + } + + // Laѱ꣬Lbδ꣬LbʣԪؼLc + while(pb <= pb_last) { + *pc++ = *pb++; + } +} \ No newline at end of file diff --git a/VisualC++/CourseBook/0203_MergeSqList/MergeSqList.h b/VisualC++/CourseBook/0203_MergeSqList/MergeSqList.h new file mode 100644 index 0000000..12704b0 --- /dev/null +++ b/VisualC++/CourseBook/0203_MergeSqList/MergeSqList.h @@ -0,0 +1,35 @@ +/*================== + * 鲢ǽ˳ + * + * 㷨: 2.22.7 + ===================*/ + +#ifndef MERGESQLIST_H +#define MERGESQLIST_H + +#include +#include +#include "SqList.h" //**02 Ա**// + + +/* + * 㷨2.2 + * + * ǵݼ鲢C=A+B + * + * 鲢˳LaLbµ˳Lc + * УLaLbLcΪǵݼС + */ +void MergeSqList_1(SqList La, SqList Lb, SqList* Lc); + +/* + * 㷨2.7 + * + * ǵݼ鲢C=A+B + * + * 鲢˳LaLbµ˳Lc + * УLaLbLcΪǵݼС + */ +void MergeSqList_2(SqList La, SqList Lb, SqList* Lc); + +#endif diff --git a/VisualC++/CourseBook/0203_MergeSqList/SqList.c b/VisualC++/CourseBook/0203_MergeSqList/SqList.c new file mode 100644 index 0000000..93b7b2c --- /dev/null +++ b/VisualC++/CourseBook/0203_MergeSqList/SqList.c @@ -0,0 +1,129 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L) { + return L.length; +} + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e) { + // ΪiĺλãϷΧǣ[1, length] + if(i < 1 || i > L.length) { + return ERROR; //iֵϷ + } + + *e = L.elem[i - 1]; + + return OK; +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/CourseBook/0203_MergeSqList/SqList.h b/VisualC++/CourseBook/0203_MergeSqList/SqList.h new file mode 100644 index 0000000..a90a6f3 --- /dev/null +++ b/VisualC++/CourseBook/0203_MergeSqList/SqList.h @@ -0,0 +1,80 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * + * + * ˳ЧԪص + */ +int ListLength(SqList L); + +/* + * ȡֵ + * + * ȡ˳еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SqList L, int i, ElemType* e); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj b/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj new file mode 100644 index 0000000..55e4763 --- /dev/null +++ b/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj @@ -0,0 +1,80 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + + + + + + + + + + + + {8818D7C5-70C7-4649-9690-ACB30147C37B} + My0204_LinkList + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj.filters b/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj.filters new file mode 100644 index 0000000..a04fab9 --- /dev/null +++ b/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj.filters @@ -0,0 +1,38 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + + + 资源文件 + + + 资源文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj.user b/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0204_LinkList/0204_LinkList.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0204_LinkList/LinkList-main.c b/VisualC++/CourseBook/0204_LinkList/LinkList-main.c new file mode 100644 index 0000000..c2790e2 --- /dev/null +++ b/VisualC++/CourseBook/0204_LinkList/LinkList-main.c @@ -0,0 +1,170 @@ +#include +#include "Status.h" +#include "LinkList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + LinkList L; + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼ L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" L %d λò \"%d\" ...\n", i, 2 * i); + ListInsert(L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + printf(" L ijΪ %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأL = "); + ListTraverse(L, PrintElem); + + printf(" ɾ L е 6 Ԫ...\n"); + + if(ListDelete(L, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" GetElem \n"); + { + GetElem(L, 4, &e); + printf(" L е 4 λõԪΪ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + GetElem(L, i, &e); + printf(" L еһԪֵ \"7\" Ԫ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" L ǰ"); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + + ClearList(L); + + printf(" L "); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" L ǰ"); + L ? printf(" L ڣ\n") : printf(" L ڣ\n"); + + DestroyList(&L); + + printf(" L "); + L ? printf(" L ڣ\n") : printf(" L ڣ\n"); + } + PressEnterToContinue(); + + + printf(" CreateList_Head \n"); + { + LinkList L; + printf(" ͷ巨 L = "); + CreateList_Head("TestData_Head.txt", &L, 5); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" CreateList_Tail \n"); + { + LinkList L; + printf(" β巨 L = "); + CreateList_Tail("TestData_Tail.txt", &L, 5); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/VisualC++/CourseBook/0204_LinkList/LinkList.c b/VisualC++/CourseBook/0204_LinkList/LinkList.c new file mode 100644 index 0000000..d87e5b5 --- /dev/null +++ b/VisualC++/CourseBook/0204_LinkList/LinkList.c @@ -0,0 +1,488 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * (ṹ) + * + * ͷռڴ棬ͷҲᱻ + */ +Status DestroyList(LinkList* L) { + LinkList p; + + // ȷṹ + if(L == NULL || *L == NULL) { + return ERROR; + } + + p = *L; + + while(p != NULL) { + p = (*L)->next; + free(*L); + (*L) = p; + } + + *L = NULL; + + return OK; +} + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(LinkList L) { + LinkList pre, p; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L->next; + + // ͷнռڴ + while(p != NULL) { + pre = p; + p = p->next; + free(pre); + } + + L->next = NULL; + + return OK; +} + +/* + * п + * + * жǷЧݡ + * + * ֵ + * TRUE : Ϊ + * FALSE: Ϊ + */ +Status ListEmpty(LinkList L) { + // ֻͷʱΪΪ + if(L != NULL && L->next == NULL) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * + * + * ЧԪص + */ +int ListLength(LinkList L) { + LinkList p; + int i; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 0; + p = L->next; + + // н + while(p != NULL) { + i++; + p = p->next; + } + + return i; +} + +/* + * 㷨2.8 + * + * ȡֵ + * + * ȡеiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(LinkList L, int i, ElemType* e) { + LinkList p; + int j; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ýĺ̲ΪNULL + while(p->next != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p->next == NULL || j > i - 1) { + return ERROR; + } + + *e = p->next->data; + + return OK; +} + +/* + * + * + * ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 1; // iijֵΪ1Ԫصλ + p = L->next; // pijֵΪ1Ԫصָ + + while(p != NULL && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != NULL) { + return i; + } else { + return 0; + } +} + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(LinkList L, ElemType cur_e, ElemType* pre_e) { + LinkList pre, next; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return ERROR; + } + + // ָ1Ԫ + pre = L->next; + + // 1Ԫûǰ + if(pre->data == cur_e) { + return ERROR; + } + + // ָ2Ԫ + next = pre->next; + + // ӵ2Ԫؿʼcur_eλ + while(next != NULL && next->data != cur_e) { + pre = next; + next = next->next; + } + + // ûҵԪcur_eʧܣERROR + if(next == NULL) { + return ERROR; + } + + *pre_e = pre->data; + + return OK; +} + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(LinkList L, ElemType cur_e, ElemType* next_e) { + LinkList pre; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return ERROR; + } + + // ָ1Ԫ + pre = L->next; + + // ӵ1Ԫؿʼcur_eλãұ֤ýĺ̲ΪNULL + while(pre->next != NULL && pre->data != cur_e) { + pre = pre->next; + } + + // ûҵcur_eҵˣûк̣ERROR + if(pre->next == NULL) { + return ERROR; + } + + *next_e = pre->next->data; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * 㷨2.10 + * + * ɾ + * + * ɾiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(LinkList L, int i, ElemType* e) { + LinkList p, q; + int j; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ýĺ̲ΪNULL + while(p->next != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p->next == NULL || j > i - 1) { + return ERROR; + } + + // ɾi + q = p->next; + p->next = q->next; + *e = q->data; + free(q); + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * 㷨2.11 + * + * ͷ巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + * ̲е㷨õͷ巨Դ˴ʵּ˺׺_Head + */ +Status CreateList_Head(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p; + ElemType e; + + // ͷ + *L = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1; i <= n; ++i) { + // ɹȡ + if(ReadData(fp, "%d", &e) == 1) { + // ½ + p = (LinkList) malloc(sizeof(LNode)); + if(p == NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // ݣ뵽 + p->data = e; + p->next = (*L)->next; + (*L)->next = p; + } else { + fclose(fp); + return ERROR; + } + } + + fclose(fp); + + return OK; +} + +/* + * β巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + */ +Status CreateList_Tail(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p, q; + ElemType e; + + // ͷ + *L = (LinkList) malloc(sizeof(LNode)); + if(*L==NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1, q = *L; i <= n; ++i) { + // ɹȡ + if(ReadData(fp, "%d", &e) == 1) { + p = (LinkList) malloc(sizeof(LNode)); + if(p==NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // ݣ뵽 + p->data = e; + q->next = p; + q = q->next; + } else { + fclose(fp); + return ERROR; + } + } + + q->next = NULL; + + fclose(fp); + + return OK; +} diff --git a/VisualC++/CourseBook/0204_LinkList/LinkList.h b/VisualC++/CourseBook/0204_LinkList/LinkList.h new file mode 100644 index 0000000..6e7e06a --- /dev/null +++ b/VisualC++/CourseBook/0204_LinkList/LinkList.h @@ -0,0 +1,168 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(LinkList* L); + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(LinkList L); + +/* + * п + * + * жǷЧݡ + * + * ֵ + * TRUE : Ϊ + * FALSE: Ϊ + */ +Status ListEmpty(LinkList L); + +/* + * + * + * ЧԪص + */ +int ListLength(LinkList L); + +/* + * 㷨2.8 + * + * ȡֵ + * + * ȡеiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(LinkList L, int i, ElemType* e); + +/* + * + * + * ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(LinkList L, ElemType cur_e, ElemType* pre_e); + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(LinkList L, ElemType cur_e, ElemType* next_e); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * 㷨2.10 + * + * ɾ + * + * ɾiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(LinkList L, int i, ElemType* e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +/* + * 㷨2.11 + * + * ͷ巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + * ̲е㷨õͷ巨Դ˴ʵּ˺׺_Head + */ +Status CreateList_Head(char path[], LinkList* L, int n); + +/* + * β巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡ + */ +Status CreateList_Tail(char path[], LinkList* L, int n); + +#endif diff --git a/VisualC++/CourseBook/0204_LinkList/TestData_Head.txt b/VisualC++/CourseBook/0204_LinkList/TestData_Head.txt new file mode 100644 index 0000000..4820e7d --- /dev/null +++ b/VisualC++/CourseBook/0204_LinkList/TestData_Head.txt @@ -0,0 +1 @@ +9 7 5 3 1 \ No newline at end of file diff --git a/VisualC++/CourseBook/0204_LinkList/TestData_Tail.txt b/VisualC++/CourseBook/0204_LinkList/TestData_Tail.txt new file mode 100644 index 0000000..e2b34ca --- /dev/null +++ b/VisualC++/CourseBook/0204_LinkList/TestData_Tail.txt @@ -0,0 +1 @@ +2 4 6 8 10 \ No newline at end of file diff --git a/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj b/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj new file mode 100644 index 0000000..e5eb949 --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj @@ -0,0 +1,82 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + + + + + + + + + + + + + + {DC3475CD-A081-423F-BCE5-14464B66F475} + My0205_MergeList + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj.filters b/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj.filters new file mode 100644 index 0000000..a0f785d --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj.filters @@ -0,0 +1,44 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + 源文件 + + + + + 头文件 + + + 头文件 + + + + + 资源文件 + + + 资源文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj.user b/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/0205_MergeList.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0205_MergeList/LinkList.c b/VisualC++/CourseBook/0205_MergeList/LinkList.c new file mode 100644 index 0000000..1fc32b4 --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/LinkList.c @@ -0,0 +1,138 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * 㷨2.11 + * + * ͷ巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + * ̲е㷨õͷ巨Դ˴ʵּ˺׺_Head + */ +Status CreateList_Head(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p; + ElemType e; + + // ͷ + *L = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1; i <= n; ++i) { + // ɹȡ + if(ReadData(fp, "%d", &e) == 1) { + // ½ + p = (LinkList) malloc(sizeof(LNode)); + if(p == NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // ݣ뵽 + p->data = e; + p->next = (*L)->next; + (*L)->next = p; + } else { + fclose(fp); + return ERROR; + } + } + + fclose(fp); + + return OK; +} + +/* + * β巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + */ +Status CreateList_Tail(char path[], LinkList* L, int n) { + FILE* fp; + int i; + LinkList p, q; + ElemType e; + + // ͷ + *L = (LinkList) malloc(sizeof(LNode)); + if(*L==NULL) { + exit(OVERFLOW); + } + (*L)->next = NULL; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + return ERROR; + } + + for(i = 1, q = *L; i <= n; ++i) { + // ɹȡ + if(ReadData(fp, "%d", &e) == 1) { + p = (LinkList) malloc(sizeof(LNode)); + if(p==NULL) { + fclose(fp); + exit(OVERFLOW); + } + + // ݣ뵽 + p->data = e; + q->next = p; + q = q->next; + } else { + fclose(fp); + return ERROR; + } + } + + q->next = NULL; + + fclose(fp); + + return OK; +} diff --git a/VisualC++/CourseBook/0205_MergeList/LinkList.h b/VisualC++/CourseBook/0205_MergeList/LinkList.h new file mode 100644 index 0000000..02a6994 --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/LinkList.h @@ -0,0 +1,61 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +/* + * 㷨2.11 + * + * ͷ巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + * ̲е㷨õͷ巨Դ˴ʵּ˺׺_Head + */ +Status CreateList_Head(char path[], LinkList* L, int n); + +/* + * β巨 + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡ + */ +Status CreateList_Tail(char path[], LinkList* L, int n); + +#endif diff --git a/VisualC++/CourseBook/0205_MergeList/MergeList-main.c b/VisualC++/CourseBook/0205_MergeList/MergeList-main.c new file mode 100644 index 0000000..fbf6614 --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/MergeList-main.c @@ -0,0 +1,31 @@ +#include +#include "MergeList.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + LinkList La, Lb, Lc; + + int m = 5; + + printf("ΪʾLa趨Ϊ %d Lb趨Ϊ %d LaLb...\n", m, m); + + CreateList_Head("TestData_Head.txt", &La, m); + printf("La = "); + ListTraverse(La, PrintElem); + + CreateList_Tail("TestData_Tail.txt", &Lb, m); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + printf("鲢LaLbΪLc = "); + MergeList(&La, &Lb, &Lc); + ListTraverse(Lc, PrintElem); + + return 0; +} + diff --git a/VisualC++/CourseBook/0205_MergeList/MergeList.c b/VisualC++/CourseBook/0205_MergeList/MergeList.c new file mode 100644 index 0000000..95f6062 --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/MergeList.c @@ -0,0 +1,45 @@ +/*=============== + * 鲢ǽ + * + * 㷨: 2.12 + ================*/ + +#include "MergeList.h" //**02 Ա**// + +/* + * 㷨2.12 + * + * ǵݼ鲢C=A+B + * + * AB鲢ΪCұԪλò䡣 + * LcLaͷ㣬LbнLcС + */ +void MergeList(LinkList* La, LinkList* Lb, LinkList* Lc) { + LinkList pa, pb, pc; + + pa = (*La)->next; + pb = (*Lb)->next; + pc = *Lc = *La; // LaͷΪLcͷ + + // LaLb + while(pa && pb) { + if(pa->data <= pb->data) { + pc->next = pa; + pc = pa; + pa = pa->next; + } else { + pc->next = pb; + pc = pb; + pb = pb->next; + } + } + + // ʣ + pc->next = pa ? pa : pb; + + // ͷLbͷռڴ + free(*Lb); + + *La = NULL; + *Lb = NULL; +} diff --git a/VisualC++/CourseBook/0205_MergeList/MergeList.h b/VisualC++/CourseBook/0205_MergeList/MergeList.h new file mode 100644 index 0000000..4a7a263 --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/MergeList.h @@ -0,0 +1,24 @@ +/*=============== + * 鲢ǽ + * + * 㷨: 2.12 + ================*/ + +#ifndef MERGELIST_H +#define MERGELIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "LinkList.h" //**02 Ա**// + +/* + * 㷨2.12 + * + * ǵݼ鲢C=A+B + * + * AB鲢ΪCұԪλò䡣 + * LcLaͷ㣬LbнLcС + */ +void MergeList(LinkList* La, LinkList* Lb, LinkList* Lc); + +#endif diff --git a/VisualC++/CourseBook/0205_MergeList/TestData_Head.txt b/VisualC++/CourseBook/0205_MergeList/TestData_Head.txt new file mode 100644 index 0000000..4820e7d --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/TestData_Head.txt @@ -0,0 +1 @@ +9 7 5 3 1 \ No newline at end of file diff --git a/VisualC++/CourseBook/0205_MergeList/TestData_Tail.txt b/VisualC++/CourseBook/0205_MergeList/TestData_Tail.txt new file mode 100644 index 0000000..e2b34ca --- /dev/null +++ b/VisualC++/CourseBook/0205_MergeList/TestData_Tail.txt @@ -0,0 +1 @@ +2 4 6 8 10 \ No newline at end of file diff --git a/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj b/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj new file mode 100644 index 0000000..8a8c086 --- /dev/null +++ b/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {C0C969A9-926E-4AE3-87AC-F73CB04D0BC7} + My0206_SLinkList + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj.filters b/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj.filters new file mode 100644 index 0000000..a268195 --- /dev/null +++ b/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj.user b/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0206_SLinkList/0206_SLinkList.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0206_SLinkList/SLinkList-main.c b/VisualC++/CourseBook/0206_SLinkList/SLinkList-main.c new file mode 100644 index 0000000..c9fb486 --- /dev/null +++ b/VisualC++/CourseBook/0206_SLinkList/SLinkList-main.c @@ -0,0 +1,152 @@ +#include +#include "Status.h" +#include "SLinkList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SLinkList space; // ÿռ + int S; // ̬ͷ + + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼ S ...\n"); + InitList(space, &S); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + ListEmpty(space, S) ? printf(" S Ϊգ\n") : printf(" S Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" S %d λò \"%d\" ...\n", i, 2 * i); + ListInsert(space, S, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" S еԪΪS = "); + ListTraverse(space, S, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + printf(" S ijΪ %d \n", ListLength(space, S)); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأS = "); + ListTraverse(space, S, PrintElem); + + printf(" ɾ S е 6 Ԫ...\n"); + + if(ListDelete(space, S, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأS = "); + ListTraverse(space, S, PrintElem); + } + PressEnterToContinue(); + + + printf(" GetElem \n"); + { + GetElem(space, S, 4, &e); + printf(" S е 4 λõԪΪ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + i = LocateElem(space, S, 7, CmpGreater); + GetElem(space, S, i, &e); + printf(" S еһԪֵ \"7\" Ԫ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(space, S, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(space, S, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" S ǰ"); + ListEmpty(space, S) ? printf(" S Ϊգ\n") : printf(" S Ϊգ\n"); + + ClearList(space, S); + + printf(" S "); + ListEmpty(space, S) ? printf(" S Ϊգ\n") : printf(" S Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" S ǰ"); + S!=0 ? printf(" S ڣ\n") : printf(" S ڣ\n"); + + DestroyList(space, &S); + + printf(" S "); + S!=0 ? printf(" S ڣ\n") : printf(" S ڣ\n"); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/VisualC++/CourseBook/0206_SLinkList/SLinkList.c b/VisualC++/CourseBook/0206_SLinkList/SLinkList.c new file mode 100644 index 0000000..8884b59 --- /dev/null +++ b/VisualC++/CourseBook/0206_SLinkList/SLinkList.c @@ -0,0 +1,470 @@ +/*================================= + * ̬ + * + * 㷨: 2.132.142.152.16 + ==================================*/ + +#include "SLinkList.h" + +/* + * ʾ + * + * кβУ + * spaceָʾÿռ + * S ָʾ̬ͷ + */ + +/* ÿռ */ + +/* + * 㷨2.14 + * + * ʼÿռ + * + * ÿռΪ̬ṩõڴ档 + */ +void InitSpace(SLinkList space) { + int i; + + for(i = 0; i < MAXSIZE - 1; ++i) { + space[i].cur = i + 1; + } + + space[MAXSIZE - 1].cur = 0; +} + +/* + * 㷨2.15 + * + * ռ + * + * Ϊ̬ӱÿռռ䣬 + * ɹؿÿռ + * ʧʱ0 + */ +int Malloc(SLinkList space) { + int i = space[0].cur; + + if(i != 0) { + // 뵽Ŀռӱÿռɾȥ + space[0].cur = space[i].cur; + } + + // ± + return i; +} + +/* + * 㷨2.16 + * + * տռ + * + * kĽռԹ̬ã + * շʽǽýռӾ̬Ƴ + * ӵÿռбС + */ +void Free(SLinkList space, int k) { + space[k].cur = space[0].cur; + space[0].cur = k; +} + + +/* ̬ */ + +/* + * ʼ + * + * ȳʼÿռ䣬ӱÿռͷĿռ䣬ɾ̬ijʼ + * ʼɹʹS洢ͷҷOK򷵻ERROR + */ +Status InitList(SLinkList space, int* S) { + int index; + + // ʼÿռ + InitSpace(space); + + // ͷռ + index = Malloc(space); + + if(index == 0) { + return ERROR; + } + + space[index].cur = 0; + + *S = index; + + return OK; +} + +/* + * (ṹ) + * + * ͷž̬ռڴ棬̬нռ뱸ÿռбС + */ +Status DestroyList(SLinkList space, int* S) { + int cur; + + // ȷ̬ + if(S == NULL || *S == 0) { + return ERROR; + } + + while(*S != 0) { + // ݴһ + cur = space[*S].cur; + // յǰռռ + Free(space, *S); + // ǰһ + *S = cur; + } + + return OK; +} + +/* + * ÿ() + * + * Ҫͷž̬зͷ㴦Ŀռ䡣 + */ +Status ClearList(SLinkList space, int S) { + int P; + int cur; + + // ȷ̬ + if(S == 0) { + return ERROR; + } + + // ȡ̬׸ + P = space[S].cur; + + while(P != 0) { + // ݴһ + cur = space[P].cur; + // յǰռռ + Free(space, P); + // ǰһ + P = cur; + } + + space[S].cur = 0; + + return OK; +} + +/* + * п + * + * жϾ̬ǷЧݡ + * + * ֵ + * TRUE : ̬Ϊ + * FALSE: ̬Ϊ + */ +Status ListEmpty(SLinkList space, int S) { + // ֻͷľ̬Ϊձ + if(S != 0 && space[S].cur == 0) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * + * + * ؾ̬ЧԪص + */ +int ListLength(SLinkList space, int S) { + int count; + + // ̬ڣ̬Ϊʱ0 + if(S == 0 || space[S].cur == 0) { + return 0; + } + + // ȡ̬׸Ԫص + S = space[S].cur; + count = 0; + + while(S != 0) { + count++; + S = space[S].cur; + } + + return count; +} + +/* + * ȡֵ + * + * ȡ̬еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SLinkList space, int S, int i, ElemType* e) { + int count; + + // ȷ̬ҲΪ + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // ȡ̬׸Ԫص + S = space[S].cur; + count = 0; + + while(S != 0 && count < i - 1) { + count++; + S = space[S].cur; + } + + if(S == 0 || count > i - 1) { + return ERROR; + } + + *e = space[S].data; + + return OK; +} + +/* + * 㷨2.13 + * + * + * + * ؾ̬׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * 1.ԪeCompareڶβ + * 2.ʵ̲ϵ㷨2.13ͬԭμġע⡱Ϣ + */ +int LocateElem(SLinkList space, int S, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + int p; + + // ȷ̬ҲΪ + if(S == 0 || space[S].cur == 0) { + return 0; + } + + i = 1; // iijֵΪ1Ԫصλ + p = space[S].cur; // pijֵΪ1Ԫص + + while(p != 0 && !Compare(space[p].data, e)) { + i++; + p = space[p].cur; + } + + if(p != 0) { + return i; + } else { + return 0; + } +} + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(SLinkList space, int S, ElemType cur_e, ElemType* pre_e) { + int pre, next; + + // ȷ̬ҲΪ + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // ָ1Ԫ + pre = space[S].cur; + + // 1Ԫûǰ + if(space[pre].data == cur_e) { + return ERROR; + } + + // ָ2Ԫ + next = space[pre].cur; + + // ӵ2Ԫؿʼcur_eλ + while(next != 0 && space[next].data != cur_e) { + pre = next; + next = space[next].cur; + } + + // ûҵԪcur_eʧܣERROR + if(next == 0) { + return ERROR; + } + + *pre_e = space[pre].data; + + return OK; +} + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(SLinkList space, int S, ElemType cur_e, ElemType* next_e) { + int pre; + + // ȷ̬ҲΪ + if(S == 0 || space[S].cur == 0) { + return ERROR; + } + + // ָ1Ԫ + pre = space[S].cur; + + // ӵ1Ԫؿʼcur_eλãұ֤ýĺ̴ + while(space[pre].cur != 0 && space[pre].data != cur_e) { + pre = space[pre].cur; + } + + // ûҵcur_eҵˣûк̣ERROR + if(space[pre].cur == 0) { + return ERROR; + } + + *next_e = space[space[pre].cur].data; + + return OK; +} + +/* + * + * + * ̬iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SLinkList space, int S, int i, ElemType e) { + int p, s; + int j; + + // ȷ̬ + if(S == 0) { + return ERROR; + } + + p = S; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾 + while(p != 0 && j < i - 1) { + p = space[p].cur; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == 0 || j > i - 1) { + return ERROR; + } + + // ½ + s = Malloc(space); + space[s].data = e; + space[s].cur = space[p].cur; + space[p].cur = s; + + return OK; +} + +/* + * ɾ + * + * ɾ̬iλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(SLinkList space, int S, int i, ElemType* e) { + int p, q; + int j; + + // ȷ̬ + if(S == 0) { + return ERROR; + } + + p = S; + j = 0; + + // Ѱҵi-1㣬ұ֤ýĺ̴ + while(space[p].cur != 0 && j < i - 1) { + p = space[p].cur; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(space[p].cur == 0 || j > i - 1) { + return ERROR; + } + + // ɾi + q = space[p].cur; + space[p].cur = space[q].cur; + *e = space[q].data; + Free(space, q); + + return OK; +} + +/* + * + * + * visitʾ̬S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)) { + int p; + + // ȷ + if(S == 0 || space[S].cur == 0) { + return; + } + + p = space[S].cur; + + while(p != 0) { + Visit(space[p].data); + p = space[p].cur; + } + + printf("\n"); +} + + +/* ͼλ */ + +// ͼλʽǰṹڲʹ +void PrintGraph(SLinkList space, int S) { + int i = 0; + + printf("==== ÿռ ====\n"); + while(i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } + + printf("==== ̬ ====\n"); + i = S; + while(i>0 && i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } +} + diff --git a/VisualC++/CourseBook/0206_SLinkList/SLinkList.h b/VisualC++/CourseBook/0206_SLinkList/SLinkList.h new file mode 100644 index 0000000..c511f6c --- /dev/null +++ b/VisualC++/CourseBook/0206_SLinkList/SLinkList.h @@ -0,0 +1,208 @@ +/*================================= + * ̬ + * + * 㷨: 2.132.142.152.16 + ==================================*/ + +#ifndef SLINKLIST_H +#define SLINKLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define MAXSIZE 1000 // ÿռھ̬󳤶 + +/* ̬ԪͶ */ +typedef int ElemType; + +/* + * ̬ṹ + * + * ע̬һ飬ռÿռͿпռ + */ +typedef struct SLinkNode { + ElemType data; + int cur; // curαָ꣬ãһ㣨±꣩ +} SLinkList[MAXSIZE]; // ռ + + +/* + * ʾ + * + * кβУ + * spaceָʾÿռ + * S ָʾ̬ͷ + */ + +/* + * ע + * + * ̲㷨2.13㷨2.14~2.17ж漰̬IJ + * 㷨Ԥݽṹȴͬ + * + * 㷨2.13Ԥ鶼Ǿ̬() + * 㷨2.14~2.17ֻǽԤΪÿռ䣬 + * ̬ռǻڱÿռͷŵ() + * + * ʵֵĴУ㷨2.14~2.17ԤݽṹΪ׼ + * ԣ㷨2.13ʵֻн̲ͬ + */ + + +/* ÿռ */ + +/* + * 㷨2.14 + * + * ʼÿռ + * + * ÿռΪ̬ṩõڴ档 + */ +void InitSpace(SLinkList space); + +/* + * 㷨2.15 + * + * ռ + * + * Ϊ̬ӱÿռռ䣬 + * ɹؿÿռ + * ʧʱ0 + */ +int Malloc(SLinkList space); + +/* + * 㷨2.16 + * + * տռ + * + * kĽռԹ̬ã + * շʽǽýռӾ̬Ƴ + * ӵÿռбС + */ +void Free(SLinkList space, int k); + + +/* ̬ */ + +/* + * ʼ + * + * ȳʼÿռ䣬ӱÿռͷĿռ䣬ɾ̬ijʼ + * ʼɹʹS洢ͷҷOK򷵻ERROR + */ +Status InitList(SLinkList space, int* S); + +/* + * (ṹ) + * + * ͷž̬ռڴ棬̬нռ뱸ÿռбС + */ +Status DestroyList(SLinkList space, int* S); + +/* + * ÿ() + * + * Ҫͷž̬зͷ㴦Ŀռ䡣 + */ +Status ClearList(SLinkList space, int S); + +/* + * п + * + * жϾ̬ǷЧݡ + * + * ֵ + * TRUE : ̬Ϊ + * FALSE: ̬Ϊ + */ +Status ListEmpty(SLinkList space, int S); + +/* + * + * + * ؾ̬ЧԪص + */ +int ListLength(SLinkList space, int S); + +/* + * ȡֵ + * + * ȡ̬еiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(SLinkList space, int S, int i, ElemType* e); + +/* + * 㷨2.13 + * + * + * + * ؾ̬׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * 1.ԪeCompareڶβ + * 2.ʵ̲ϵ㷨2.13ͬԭμġע⡱Ϣ + */ +int LocateElem(SLinkList space, int S, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(SLinkList space, int S, ElemType cur_e, ElemType* pre_e); + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(SLinkList space, int S, ElemType cur_e, ElemType* next_e); + +/* + * + * + * ̬iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SLinkList space, int S, int i, ElemType e); + +/* + * ɾ + * + * ɾ̬iλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(SLinkList space, int S, int i, ElemType* e); + +/* + * + * + * visitʾ̬S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)); + + +/* ͼλ */ + +// ͼλʽǰṹڲʹ +void PrintGraph(SLinkList space, int S); + +#endif diff --git a/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj b/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj new file mode 100644 index 0000000..83130da --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj @@ -0,0 +1,81 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {EB17D84C-751A-4261-BE9F-B02951BF8E51} + My0207_Difference + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj.filters b/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj.filters new file mode 100644 index 0000000..1a0a599 --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj.filters @@ -0,0 +1,41 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + 源文件 + + + + + 头文件 + + + 头文件 + + + + + 资源文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj.user b/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/0207_Difference.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0207_Difference/Difference-main.c b/VisualC++/CourseBook/0207_Difference/Difference-main.c new file mode 100644 index 0000000..f4a0208 --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/Difference-main.c @@ -0,0 +1,19 @@ +#include +#include "Difference.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + SLinkList space; // ÿռ + int S; // ̬ + + printf("S = (A-B)(B-A) = "); + difference("TestData.txt", space, &S); + ListTraverse(space, S, PrintElem); + + return 0; +} diff --git a/VisualC++/CourseBook/0207_Difference/Difference.c b/VisualC++/CourseBook/0207_Difference/Difference.c new file mode 100644 index 0000000..3327485 --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/Difference.c @@ -0,0 +1,95 @@ +/*=============== + * ̬ȥ + * + * 㷨: 2.17 + ================*/ + +#include "Difference.h" + +/* + * 㷨2.17 + * + * S = (A-B)(B-A) + * + * ԼAͼB(A-B)(B-A)㣬뾲̬S + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + */ +void difference(char path[], SLinkList space, int* S) { + FILE* fp; + int m, n; // AͼBԪ + int j; // ѭ + int R; // ָ̬һ + int i, k, p; + int b; // ʱ洢ӼBж + + // ʼÿռ + InitSpace(space); + + // ȡ̬ͷ + *S = Malloc(space); + + // Rִо̬Ľ + R = *S; + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + exit(ERROR); + } + + // ȡAͼBԪظ + ReadData(fp, "%d%d", &m, &n); + + // ¼뼯A + for(j = 1; j <= m; ++j) { + // + i = Malloc(space); + + // 뼯AԪֵ + ReadData(fp, "%d", &space[i].data); + + // ½뵽β + space[R].cur = i; + R = i; + } + + // βָÿ + space[R].cur = 0; + + // ¼뼯B + for(j = 1; j <= n; ++j) { + // 뼯BԪֵ + ReadData(fp, "%d", &b); + + p = *S; // ָ̬ͷ㣬ָkǰһλ + k = space[*S].cur; // ָ̬е׸Ԫ + + // ڵǰ̬вǷbԪ + while(k != space[R].cur && space[k].data != b) { + p = k; + k = space[k].cur; + } + + // Ԫزڣ뾲̬ + if(k == space[R].cur) { + i = Malloc(space); + space[i].data = b; + space[i].cur = space[R].cur; + space[R].cur = i; + + // ԪѴڣҪƳ + } else { + space[p].cur = space[k].cur; + Free(space, k); + if(R == k) { + R = p; + } + } + } + + fclose(fp); +} \ No newline at end of file diff --git a/VisualC++/CourseBook/0207_Difference/Difference.h b/VisualC++/CourseBook/0207_Difference/Difference.h new file mode 100644 index 0000000..b7d9164 --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/Difference.h @@ -0,0 +1,28 @@ +/*=============== + * ̬ȥ + * + * 㷨: 2.17 + ================*/ + +#ifndef DIFFERENCE_H +#define DIFFERENCE_H + +#include +#include "Status.h" //**01 **// +#include "SLinkList.h" //**02 Ա**// + +/* + * 㷨2.17 + * + * S = (A-B)(B-A) + * + * ԼAͼB(A-B)(B-A)㣬뾲̬S + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡݡ + */ +void difference(char path[], SLinkList space, int* S); + +#endif diff --git a/VisualC++/CourseBook/0207_Difference/SLinkList.c b/VisualC++/CourseBook/0207_Difference/SLinkList.c new file mode 100644 index 0000000..624e0ea --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/SLinkList.c @@ -0,0 +1,116 @@ +/*================================= + * ̬ + * + * 㷨: 2.132.142.152.16 + ==================================*/ + +#include "SLinkList.h" + +/* + * ʾ + * + * кβУ + * spaceָʾÿռ + * S ָʾ̬ͷ + */ + +/* ÿռ */ + +/* + * 㷨2.14 + * + * ʼÿռ + * + * ÿռΪ̬ṩõڴ档 + */ +void InitSpace(SLinkList space) { + int i; + + for(i = 0; i < MAXSIZE - 1; ++i) { + space[i].cur = i + 1; + } + + space[MAXSIZE - 1].cur = 0; +} + +/* + * 㷨2.15 + * + * ռ + * + * Ϊ̬ӱÿռռ䣬 + * ɹؿÿռ + * ʧʱ0 + */ +int Malloc(SLinkList space) { + int i = space[0].cur; + + if(i != 0) { + // 뵽Ŀռӱÿռɾȥ + space[0].cur = space[i].cur; + } + + // ± + return i; +} + +/* + * 㷨2.16 + * + * տռ + * + * kĽռԹ̬ã + * շʽǽýռӾ̬Ƴ + * ӵÿռбС + */ +void Free(SLinkList space, int k) { + space[k].cur = space[0].cur; + space[0].cur = k; +} + + +/* ̬ */ + +/* + * + * + * visitʾ̬S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)) { + int p; + + // ȷ + if(S == 0 || space[S].cur == 0) { + return; + } + + p = space[S].cur; + + while(p != 0) { + Visit(space[p].data); + p = space[p].cur; + } + + printf("\n"); +} + + +/* ͼλ */ + +// ͼλʽǰṹڲʹ +void PrintGraph(SLinkList space, int S) { + int i = 0; + + printf("==== ÿռ ====\n"); + while(i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } + + printf("==== ̬ ====\n"); + i = S; + while(i>0 && i < 20) { + printf("%2d | %2d | %2d |\n", i, space[i].data, space[i].cur); + i = space[i].cur; + } +} diff --git a/VisualC++/CourseBook/0207_Difference/SLinkList.h b/VisualC++/CourseBook/0207_Difference/SLinkList.h new file mode 100644 index 0000000..d92bdf6 --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/SLinkList.h @@ -0,0 +1,89 @@ +/*================================= + * ̬ + * + * 㷨: 2.132.142.152.16 + ==================================*/ + +#ifndef SLINKLIST_H +#define SLINKLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define MAXSIZE 1000 // ÿռھ̬󳤶 + +/* ̬ԪͶ */ +typedef int ElemType; + +/* + * ̬ṹ + * + * ע̬һ飬ռÿռͿпռ + */ +typedef struct SLinkLNode { + ElemType data; + int cur; // curαָ꣬ãһ㣨±꣩ +} SLinkList[MAXSIZE]; // ռ + + +/* + * ʾ + * + * кβУ + * spaceָʾÿռ + * S ָʾ̬ͷ + */ + + +/* ÿռ */ + +/* + * 㷨2.14 + * + * ʼÿռ + * + * ÿռΪ̬ṩõڴ档 + */ +void InitSpace(SLinkList space); + +/* + * 㷨2.15 + * + * ռ + * + * Ϊ̬ӱÿռռ䣬 + * ɹؿÿռ + * ʧʱ0 + */ +int Malloc(SLinkList space); + +/* + * 㷨2.16 + * + * տռ + * + * kĽռԹ̬ã + * շʽǽýռӾ̬Ƴ + * ӵÿռбС + */ +void Free(SLinkList space, int k); + + +/* ̬ */ + +/* + * + * + * visitʾ̬S + */ +void ListTraverse(SLinkList space, int S, void(Visit)(ElemType)); + + +/* ͼλ */ + +// ͼλʽǰṹڲʹ +void PrintGraph(SLinkList space, int S); + +#endif diff --git a/VisualC++/CourseBook/0207_Difference/TestData.txt b/VisualC++/CourseBook/0207_Difference/TestData.txt new file mode 100644 index 0000000..93de27f --- /dev/null +++ b/VisualC++/CourseBook/0207_Difference/TestData.txt @@ -0,0 +1,4 @@ +Aijȣ3 +Bijȣ5 +AԪأ2 3 4 +BԪأ1 3 4 6 7 \ No newline at end of file diff --git a/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj b/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj new file mode 100644 index 0000000..6bdc7ee --- /dev/null +++ b/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {6816DB4B-DC29-4BF4-8D93-F6B00444FD37} + My0208_DuLinkList + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj.filters b/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj.filters new file mode 100644 index 0000000..de43dc6 --- /dev/null +++ b/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj.user b/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0208_DuLinkList/0208_DuLinkList.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0208_DuLinkList/DuLinkList-main.c b/VisualC++/CourseBook/0208_DuLinkList/DuLinkList-main.c new file mode 100644 index 0000000..90cbb4f --- /dev/null +++ b/VisualC++/CourseBook/0208_DuLinkList/DuLinkList-main.c @@ -0,0 +1,149 @@ +#include +#include "Status.h" +#include "DuLinkList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + DuLinkList L; + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼ˫ѭ L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" L %d λò \"%d\" ...\n", i, 2 * i); + ListInsert(L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + printf(" L ijΪ %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأL = "); + ListTraverse(L, PrintElem); + + printf(" ɾ L е 6 Ԫ...\n"); + + if(ListDelete(L, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" GetElem \n"); + { + GetElem(L, 4, &e); + printf(" L е 4 λõԪΪ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + i = LocateElem(L, 7, CmpGreater); + GetElem(L, i, &e); + printf(" L еһԪֵ \"7\" Ԫ \"%d\" \n", e); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + ElemType cur_e = 6; + + if(PriorElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + ElemType cur_e = 6; + + if(NextElem(L, cur_e, &e) == OK) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", cur_e, e); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", cur_e); + } + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" L ǰ"); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + + ClearList(L); + + printf(" L "); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" L ǰ"); + L ? printf(" L ڣ\n") : printf(" L ڣ\n"); + + DestroyList(&L); + + printf(" L "); + L ? printf(" L ڣ\n") : printf(" L ڣ\n"); + } + PressEnterToContinue(); + + return 0; +} diff --git a/VisualC++/CourseBook/0208_DuLinkList/DuLinkList.c b/VisualC++/CourseBook/0208_DuLinkList/DuLinkList.c new file mode 100644 index 0000000..b8ff6b8 --- /dev/null +++ b/VisualC++/CourseBook/0208_DuLinkList/DuLinkList.c @@ -0,0 +1,402 @@ +/*===================== + * ˫ѭ + * + * 㷨: 2.182.19 + ======================*/ + +#include "DuLinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(DuLinkList* L) { + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + // ǰͺָ̾ + (*L)->next = (*L)->prior = *L; + + return OK; +} + +/* + * (ṹ) + * + * ͷ˫ѭռڴ档 + */ +Status DestroyList(DuLinkList* L) { + // ȷṹ + if(L == NULL || *L == NULL) { + return ERROR; + } + + ClearList(*L); + + free(*L); + + *L = NULL; + + return OK; +} + +/* + * ÿ() + * + * Ҫͷ˫ѭзͷ㴦Ŀռ䡣 + */ +Status ClearList(DuLinkList L) { + DuLinkList p, q; + + if(L == NULL) { + return ERROR; + } + + p = L->next; + + while(p != L) { + q = p->next; + free(p); + p = q; + } + + L->next = L->prior = L; + + return OK; +} + +/* + * п + * + * ж˫ѭǷЧݡ + * + * ֵ + * TRUE : ˫ѭΪ + * FALSE: ˫ѭΪ + */ +Status ListEmpty(DuLinkList L) { + if(L != NULL && L->next == L && L->prior == L) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * + * + * ˫ѭЧԪص + */ +int ListLength(DuLinkList L) { + DuLinkList p; + int i; + + if(L == NULL || L->next == L || L->prior == L) { + return 0; + } + + i = 0; + p = L->next; + + // н + while(p != L) { + i++; + p = p->next; + } + + return i; +} + +/* + * ȡֵ + * + * ȡ˫ѭеiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(DuLinkList L, int i, ElemType* e) { + DuLinkList p; + int j; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ýĺ̲ΪL + while(p->next != L && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p->next == L || j > i - 1) { + return ERROR; + } + + *e = p->next->data; + + return OK; +} + +/* + * + * + * ˫ѭ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(DuLinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return 0; + } + + i = 1; // iijֵΪ1Ԫصλ + p = L->next; // pijֵΪ1Ԫصָ + + while(p != L && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != L) { + return i; + } else { + return 0; + } +} + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(DuLinkList L, ElemType cur_e, ElemType* pre_e) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // ָ1Ԫ + p = L->next; + + // 1Ԫûǰ + if(p->data == cur_e) { + return ERROR; + } + + // ָ2Ԫ + p = p->next; + + // ӵ2Ԫؿʼcur_eλ + while(p != L && p->data != cur_e) { + p = p->next; + } + + // ûҵԪcur_eʧܣERROR + if(p == L) { + return ERROR; + } + + *pre_e = p->prior->data; + + return OK; +} + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(DuLinkList L, ElemType cur_e, ElemType* next_e) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // ָ1Ԫ + p = L->next; + + // ӵ1Ԫؿʼcur_eλãұ֤ýĺ̲ΪL + while(p->next != L && p->data != cur_e) { + p = p->next; + } + + // ûҵcur_eҵˣûк̣ERROR + if(p->next == L) { + return ERROR; + } + + *next_e = p->next->data; + + return OK; +} + +/* + * 㷨2.18 + * + * + * + * ˫ѭiλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(DuLinkList L, int i, ElemType e) { + DuLinkList p, s; + + // ȷ˫ѭڣΪձ + if(L == NULL) { + return ERROR; + } + + // ҵiλãã + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // ½ + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // s뵽pǰ棬Ϊi + s->prior = p->prior; + p->prior->next = s; + s->next = p; + p->prior = s; + + return OK; +} + +/* + * 㷨2.19 + * + * ɾ + * + * ɾ˫ѭiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(DuLinkList L, int i, ElemType* e) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return ERROR; + } + + // ҵiλãã + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // p==L˵ɾԪǵlen+1ԪأϹ + if(p == L) { + return ERROR; + } + + *e = p->data; + + // Ƴp + p->prior->next = p->next; + p->next->prior = p->prior; + + free(p); + + return OK; +} + +/* + * + * + * visit˫ѭL + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return; + } + + p = L->next; + + while(p != L) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * ȡѭLϵiԪص + * + * ע + * 1.staticĺǵǰֻDuLinkListʹãᱻļ + * 2.ΪlenҪȡlen+1ԪصʱѭԷصͷ + */ +static DuLinkList GetElemP(DuLinkList L, int i) { + DuLinkList p; + int count; + + // ȷ˫ѭڣΪձ + if(L == NULL) { + return NULL; + } + + // λòϹ + if(i < 1) { + return NULL; + } + + p = L; + count = 0; + + // ԲҵiԪ + while(p->next != L && count < i) { + p = p->next; + ++count; + } + + // ǡҵiԪ + if(count == i) { + return p; + } + + // ˣ˵p->next==LʱҪжiǷ + if(count + 1 < i) { + return NULL; + } + + // ˣ˵Ҫlen+1λϲԪ + return L; +} diff --git a/VisualC++/CourseBook/0208_DuLinkList/DuLinkList.h b/VisualC++/CourseBook/0208_DuLinkList/DuLinkList.h new file mode 100644 index 0000000..0f8810d --- /dev/null +++ b/VisualC++/CourseBook/0208_DuLinkList/DuLinkList.h @@ -0,0 +1,153 @@ +/*===================== + * ˫ѭ + * + * 㷨: 2.182.19 + ======================*/ + +#ifndef DULINKLIST_H +#define DULINKLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ˫ѭԪͶ */ +typedef int ElemType; + +/* + * ˫ѭṹ + * + * ע˫ѭͷ + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // ǰ + struct DuLNode* next; // +} DuLNode; + +// ָ˫ѭָ +typedef DuLNode* DuLinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(DuLinkList* L); + +/* + * (ṹ) + * + * ͷ˫ѭռڴ档 + */ +Status DestroyList(DuLinkList* L); + +/* + * ÿ() + * + * Ҫͷ˫ѭзͷ㴦Ŀռ䡣 + */ +Status ClearList(DuLinkList L); + +/* + * п + * + * ж˫ѭǷЧݡ + * + * ֵ + * TRUE : ˫ѭΪ + * FALSE: ˫ѭΪ + */ +Status ListEmpty(DuLinkList L); + +/* + * + * + * ˫ѭЧԪص + */ +int ListLength(DuLinkList L); + +/* + * ȡֵ + * + * ȡ˫ѭеiԪأ洢eС + * ҵOK򣬷ERROR + * + *ע + * ̲iĺԪλã1ʼⲻϱͨԼ + * ͨiĺӦָ0ʼ + */ +Status GetElem(DuLinkList L, int i, ElemType* e); + +/* + * + * + * ˫ѭ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(DuLinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * ǰ + * + * ȡԪcur_eǰ + * ڣ洢pre_eУOK + * ڣ򷵻ERROR + */ +Status PriorElem(DuLinkList L, ElemType cur_e, ElemType* pre_e); + +/* + * + * + * ȡԪcur_eḷ́ + * ڣ洢next_eУOK + * ڣ򷵻ERROR + */ +Status NextElem(DuLinkList L, ElemType cur_e, ElemType* next_e); + +/* + * 㷨2.18 + * + * + * + * ˫ѭiλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(DuLinkList L, int i, ElemType e); + +/* + * 㷨2.19 + * + * ɾ + * + * ɾ˫ѭiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListDelete(DuLinkList L, int i, ElemType* e); + +/* + * + * + * visit˫ѭL + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)); + +/* + * ȡѭLϵiԪص + * + * ע + * 1.staticĺǵǰֻDuLinkListʹãᱻļ + * 2.ΪlenҪȡlen+1ԪصʱѭԷصͷ + */ +static DuLinkList GetElemP(DuLinkList L, int i); + +#endif diff --git a/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj b/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj new file mode 100644 index 0000000..9697cfd --- /dev/null +++ b/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {2FE48840-F7BB-4DC7-B3D9-4AFF2B35206B} + My0209_ELinkList + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj.filters b/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj.filters new file mode 100644 index 0000000..3b25574 --- /dev/null +++ b/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj.user b/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0209_ELinkList/0209_ELinkList.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0209_ELinkList/ELinkList-main.c b/VisualC++/CourseBook/0209_ELinkList/ELinkList-main.c new file mode 100644 index 0000000..7d37082 --- /dev/null +++ b/VisualC++/CourseBook/0209_ELinkList/ELinkList-main.c @@ -0,0 +1,224 @@ +#include +#include "ELinkList.h" //**02 Ա**// + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + + +int main(int argc, char** argv) { + ELinkList L; + Link p, q, s; + Position r; + int i; + ElemType e; + + printf(" InitList \n"); + { + printf(" ʼչ L ...\n"); + InitList(&L); + } + PressEnterToContinue(); + + + printf(" ListEmpty \n"); + { + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" ListInsert \n"); + { + for(i = 1; i <= 8; i++) { + printf(" L %d λò \"%d\" ...\n", i, 2 * i); + ListInsert(&L, i, 2 * i); + } + } + PressEnterToContinue(); + + + printf(" ListTraverse \n"); + { + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ListLength \n"); + { + printf(" L ijΪ %d \n", ListLength(L)); + } + PressEnterToContinue(); + + + printf(" ListDelete \n"); + { + printf(" ɾǰԪأL = "); + ListTraverse(L, PrintElem); + + printf(" ɾ L е 6 Ԫ...\n"); + + if(ListDelete(&L, 6, &e) == OK) { + printf(" ɾɹɾԪǣ\"%d\"\n", e); + } else { + printf(" ɾʧܣ 6 Ԫزڣ\n"); + } + + printf(" ɾԪأL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" LocateElem \n"); + { + r = LocateElem(L, 7, CmpGreater); + printf(" L еһԪֵ \"7\" Ԫ \"%d\" \n", r->data); + } + PressEnterToContinue(); + + + printf(" PriorElem \n"); + { + Position pre = PriorPos(L, r); + + if(pre !=NULL) { + printf(" Ԫ \"%d\" ǰΪ \"%d\" \n", r->data, pre->data); + } else { + printf(" Ԫ \"%d\" ǰڣ\n", r->data); + } + } + PressEnterToContinue(); + + + printf(" NextElem \n"); + { + Position next = NextPos(L, r); + + if(next !=NULL) { + printf(" Ԫ \"%d\" ĺΪ \"%d\" \n", r->data, next->data); + } else { + printf(" Ԫ \"%d\" ĺ̲ڣ\n", r->data); + } + } + PressEnterToContinue(); + + + printf(" MakeNode \n"); + { + printf(" \"100\" ...\n"); + MakeNode(&p, 100); + printf(" \"200\" ...\n"); + MakeNode(&q, 200); + printf(" \"300\" ...\n"); + MakeNode(&s, 300); + } + PressEnterToContinue(); + + + printf(" InsFirst \n"); + { + printf(" Ԫ \"%d\" 뵽Ԫ \"%d\" ֮...\n", s->data, r->data); + InsFirst(&L, r, s); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" DelFirst \n"); + { + printf(" ɾԪ \"%d\" ֮Ԫ...\n", r->data); + DelFirst(&L, r, &s); + printf(" ɾԪΪ\"%d\"\n", s->data); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" InsBefore \n"); + { + Link t = r; + + printf(" Ԫ \"%d\" 뵽Ԫ \"%d\" ֮ǰ...\n", p->data, t->data); + InsBefore(&L, &t, p); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" InsAfter \n"); + { + Link t = r; + + printf(" Ԫ \"%d\" 뵽Ԫ \"%d\" ֮...\n", q->data, t->data); + InsAfter(&L, &t, q); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" Append \n"); + { + printf(" \"400\" ...\n"); + MakeNode(&s, 400); + + printf(" Ԫ %d 뵽...\n", s->data); + Append(&L, s); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" Remove \n"); + { + printf(" ɾԪ...\n"); + Remove(&L, &s); + printf(" ɾԪΪ\"%d\"\n", s->data); + printf(" L еԪΪL = "); + ListTraverse(L, PrintElem); + } + PressEnterToContinue(); + + + printf(" ClearList \n"); + { + printf(" L ǰ"); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + + ClearList(&L); + + printf(" L "); + ListEmpty(L) ? printf(" L Ϊգ\n") : printf(" L Ϊգ\n"); + } + PressEnterToContinue(); + + + printf(" DestroyList \n"); + { + printf(" L ǰ"); + L.head != NULL && L.tail != NULL ? printf(" L ڣ\n") : printf(" L ڣ\n"); + + DestroyList(&L); + + printf(" L "); + L.head != NULL && L.tail != NULL ? printf(" L ڣ\n") : printf(" L ڣ\n"); + + } + PressEnterToContinue(); + + return 0; +} + diff --git a/VisualC++/CourseBook/0209_ELinkList/ELinkList.c b/VisualC++/CourseBook/0209_ELinkList/ELinkList.c new file mode 100644 index 0000000..c77bc91 --- /dev/null +++ b/VisualC++/CourseBook/0209_ELinkList/ELinkList.c @@ -0,0 +1,630 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#include "ELinkList.h" //**02 Ա**// + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // ռ + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // û˳򣬶Ƿشʾ + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // ͷ + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // ֻͷʱλαָ + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(ELinkList* L) { + + // ʱûҪ + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + ClearList(L); + + free((*L).head); + + (*L).head = (*L).tail = NULL; + + return OK; +} + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(ELinkList* L) { + Link p, q; + + // ûЧԪʱҪ + if(L == NULL || (*L).head == NULL || (*L).len <= 0) { + return ERROR; + } + + // ָ1Ԫ + p = (*L).head->next; + + // ͷԪռڴ + while(p != NULL) { + q = p->next; + free(p); + p = q; + } + + (*L).head->next = NULL; + (*L).tail = (*L).head; + (*L).len = 0; + + return OK; +} + +/* + * п + * + * жǷЧݡ + * + * ֵ + * TRUE : Ϊ + * FALSE: Ϊ + */ +Status ListEmpty(ELinkList L) { + if(L.len <= 0) { + return TRUE; + } else { + return FALSE; + } +} + +/* + * + * + * ЧԪص + */ +int ListLength(ELinkList L) { + return L.len; +} + +/* + * + * + * ׸eCompareϵԪá + * Ԫأ򷵻NULL + * + *ע + * 1.ԪeCompareڶβ + * 2.ķֵĿԪصãλ + */ +Position LocateElem(ELinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + Position p; + + if(L.len <= 0) { + return NULL; + } + + // ָ1Ԫ + p = L.head->next; + + while(p != NULL && !Compare(p->data, e)) { + p = p->next; + } + + return p; +} + +/* + * 㷨2.20 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.9ĸд + */ +Status ListInsert(ELinkList* L, int i, ElemType e) { + Link h, s; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // ȷiֵϹ[1, len+1] + if(i < 1 || i > (*L).len + 1) { + return ERROR; + } + + // ҵi-1Ԫصã洢h + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // ½s + if(MakeNode(&s, e) == ERROR) { + return ERROR; + } + + // s뵽h棬Ϊhĵһ + if(InsFirst(L, h, s) == ERROR) { + return ERROR; + } + + return OK; +} + +/* + * ɾ + * + * ɾiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.10ĸд + */ +Status ListDelete(ELinkList* L, int i, ElemType* e) { + Link h, q; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // ȷiֵϹ[1, len] + if(i < 1 || i > (*L).len) { + return ERROR; + } + + // ҵi-1Ԫصã洢h + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // ɾhĵһ㣬q洢ɾ + if(DelFirst(L, h, &q) == ERROR) { + return ERROR; + } + + // ±ɾԪصֵ + *e = q->data; + + // ͷűɾĿռ + FreeNode(&q); + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)) { + Link p; + + if(L.len <= 0) { + return; + } + + // ָ1Ԫ + p = L.head->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p) { + if(p == NULL) { + return INT_MIN; + } + + return p->data; +} + +/* + * ֵ + * + * ΪpԪֵ + */ +Status SetCurElem(Link p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + p->data = e; + + return OK; +} + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * β + * + * ȡβá + */ +Position GetLast(ELinkList L) { + return L.tail; +} + +/* + * ǰ + * + * ȡpǰڣ򷵻NULL + */ +Position PriorPos(ELinkList L, Link p) { + Link pre; + + // ȷ(ͷ) + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + // ָͷ + pre = L.head; + + // һǰ + if(pre->next == p) { + return NULL; + } + + // Pǰ + while(pre != NULL && pre->next != p) { + pre = pre->next; + } + + return pre; +} + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p) { + + // ȷ(ͷ) + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * + * + * Lеi(Ϊ0)㣬ôpҷOK + * iֵϹ棬򷵻ERROR + * رע⣬iΪ0ʱp洢ͷ + */ +Status LocatePos(ELinkList L, int i, Link* p) { + int j; + Link r; + + // עiΪ0 + if(i < 0 || i > L.len) { + return ERROR; + } + + // ֤(ͷ) + if(L.head == NULL) { + return ERROR; + } + + // iΪ0ʱȡͷ + if(i == 0) { + *p = L.head; + return OK; + } + + j = 0; // + r = L.head; // ָͷ + + while(r != NULL && j < i) { + j++; + r = r->next; + } + + if(r == NULL) { + return ERROR; + } + + *p = r; + + return OK; +} + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // hΪβ㣬Ҫβ + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // ûнɾشϢ + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // ɾɹĽ + (*q)->next = NULL; + + // hֻһ㣬βָ + if(h->next == NULL) { + (*L).tail = h; + } + + // ͷűɾռռ + (*L).len--; + + return OK; +} + +/* + * ǰ + * + * s뵽p֮ǰpָ½ + */ +Status InsBefore(ELinkList* L, Link* p, Link s) { + Link pre; + + if(L == NULL || (*L).head == NULL || p == NULL || s == NULL) { + return ERROR; + } + + // ָͷ + pre = (*L).head; + + // pĹǰڵһԪأǰΪͷ + while(pre != NULL && pre->next != (*p)) { + pre = pre->next; + } + + // ûҵǰ + if(pre == NULL) { + return ERROR; + } + + s->next = *p; + pre->next = s; + *p = s; + + (*L).len++; //޸lenõ*L + + return OK; +} + +/* + * + * + * s뵽p֮ǰpָ½ + */ +Status InsAfter(ELinkList* L, Link* p, Link s) { + Link r; + + if(L == NULL || (*L).head == NULL || p == NULL || s == NULL) { + return ERROR; + } + + r = (*L).head; + + while(r != NULL && r != (*p)) { + r = r->next; + } + + // δҵpشϢ + if(r == NULL) { + return ERROR; + } + + // pָһ㣬Ҫβָ + if(*p == (*L).tail) { + (*L).tail = s; + } + + s->next = (*p)->next; + (*p)->next = s; + *p = s; + + (*L).len++; + + return OK; +} + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // ȷµβλ + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} + +/* + * βƳ + * + * βƳƳĽô洢q + */ +Status Remove(ELinkList* L, Link* q) { + Link p; + + if(L == NULL || (*L).head == NULL || q == NULL) { + return ERROR; + } + + // ûԪؿɹƳ + if((*L).len == 0) { + *q = NULL; + return ERROR; + } + + *q = (*L).tail; + + // ȷµβλ + p = (*L).head; + while(p->next != (*L).tail) { + p = p->next; + } + p->next = NULL; + (*L).tail = p; + + (*L).len--; + + return OK; +} diff --git a/VisualC++/CourseBook/0209_ELinkList/ELinkList.h b/VisualC++/CourseBook/0209_ELinkList/ELinkList.h new file mode 100644 index 0000000..e988542 --- /dev/null +++ b/VisualC++/CourseBook/0209_ELinkList/ELinkList.h @@ -0,0 +1,253 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩһЩ޳ +#include "Status.h" //**01 **// + +/* + * ע + * + * ̲еΪLinkList + * Ϊ뵥֣ʽΪELinkList + * ɶͨһչ + */ + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עͷ + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* άͷβָ뼰Ϣ */ +typedef struct { + Link head, tail; // ֱָеͷβ + int len; // ָʾԪصĸ +} ELinkList; + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e); + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p); + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L); + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(ELinkList* L); + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(ELinkList* L); + +/* + * п + * + * жǷЧݡ + * + * ֵ + * TRUE : Ϊ + * FALSE: Ϊ + */ +Status ListEmpty(ELinkList L); + +/* + * + * + * ЧԪص + */ +int ListLength(ELinkList L); + +/* + * + * + * ׸eCompareϵԪá + * Ԫأ򷵻NULL + * + *ע + * 1.ԪeCompareڶβ + * 2.ķֵĿԪصãλ + */ +Position LocateElem(ELinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 㷨2.20 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.9ĸд + */ +Status ListInsert(ELinkList* L, int i, ElemType e); + +/* + * ɾ + * + * ɾiλϵԪأɾԪش洢eС + * ɾɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.10ĸд + */ +Status ListDelete(ELinkList* L, int i, ElemType* e); + +/* + * + * + * visitL + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)); + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p); + +/* + * ֵ + * + * ΪpԪֵ + */ +Status SetCurElem(Link p, ElemType e); + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L); + +/* + * β + * + * ȡβá + */ +Position GetLast(ELinkList L); + +/* + * ǰ + * + * ȡpǰڣ򷵻NULL + */ +Position PriorPos(ELinkList L, Link p); + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p); + +/* + * + * + * Lеi(Ϊ0)㣬ôpҷOK + * iֵϹ棬򷵻ERROR + * رע⣬iΪ0ʱp洢ͷ + */ +Status LocatePos(ELinkList L, int i, Link* p); + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * ǰ + * + * s뵽p֮ǰpָ½ + */ +Status InsBefore(ELinkList* L, Link* p, Link s); + +/* + * + * + * s뵽p֮ǰpָ½ + */ +Status InsAfter(ELinkList* L, Link* p, Link s); + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s); + +/* + * βƳ + * + * βƳƳĽô洢q + */ +Status Remove(ELinkList* L, Link* q); + +#endif diff --git a/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj b/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj new file mode 100644 index 0000000..bd7647c --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj @@ -0,0 +1,82 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {58E663CD-DDC0-48B4-BE73-5AA11CEED026} + My0210_MergeEList + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj.filters b/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj.filters new file mode 100644 index 0000000..ecffb9f --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj.filters @@ -0,0 +1,44 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + 源文件 + + + + + 头文件 + + + 头文件 + + + + + 资源文件 + + + 资源文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj.user b/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/0210_MergeEList.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0210_MergeEList/ELinkList.c b/VisualC++/CourseBook/0210_MergeEList/ELinkList.c new file mode 100644 index 0000000..fe46f87 --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/ELinkList.c @@ -0,0 +1,324 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#include "ELinkList.h" //**02 Ա**// + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // ռ + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // û˳򣬶Ƿشʾ + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // ͷ + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // ֻͷʱλαָ + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * 㷨2.20 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.9ĸд + */ +Status ListInsert(ELinkList* L, int i, ElemType e) { + Link h, s; + + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + // ȷiֵϹ[1, len+1] + if(i < 1 || i > (*L).len + 1) { + return ERROR; + } + + // ҵi-1Ԫصã洢h + if(LocatePos(*L, i - 1, &h) == ERROR) { + return ERROR; + } + + // ½s + if(MakeNode(&s, e) == ERROR) { + return ERROR; + } + + // s뵽h棬Ϊhĵһ + if(InsFirst(L, h, s) == ERROR) { + return ERROR; + } + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)) { + Link p; + + if(L.len <= 0) { + return; + } + + // ָ1Ԫ + p = L.head->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p) { + if(p == NULL) { + return INT_MIN; + } + + return p->data; +} + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p) { + + // ȷ(ͷ) + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * + * + * Lеi(Ϊ0)㣬ôpҷOK + * iֵϹ棬򷵻ERROR + * رע⣬iΪ0ʱp洢ͷ + */ +Status LocatePos(ELinkList L, int i, Link* p) { + int j; + Link r; + + // עiΪ0 + if(i < 0 || i > L.len) { + return ERROR; + } + + // ֤(ͷ) + if(L.head == NULL) { + return ERROR; + } + + // iΪ0ʱȡͷ + if(i == 0) { + *p = L.head; + return OK; + } + + j = 0; // + r = L.head; // ָͷ + + while(r != NULL && j < i) { + j++; + r = r->next; + } + + if(r == NULL) { + return ERROR; + } + + *p = r; + + return OK; +} + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // hΪβ㣬Ҫβ + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // ûнɾشϢ + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // ｫɾɹĽ + (*q)->next = NULL; + + // hֻһ㣬βָ + if(h->next == NULL) { + (*L).tail = h; + } + + // ͷűɾռռ + (*L).len--; + + return OK; +} + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // ȷµβλ + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} diff --git a/VisualC++/CourseBook/0210_MergeEList/ELinkList.h b/VisualC++/CourseBook/0210_MergeEList/ELinkList.h new file mode 100644 index 0000000..1bfb4e6 --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/ELinkList.h @@ -0,0 +1,155 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩһЩ޳ +#include "Status.h" //**01 **// + +/* + * ע + * + * ̲еΪLinkList + * Ϊ뵥֣ʽΪELinkList + * ɶͨһչ + */ + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עͷ + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* άͷβָ뼰Ϣ */ +typedef struct { + Link head, tail; // ֱָеͷβ + int len; // ָʾԪصĸ +} ELinkList; + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e); + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p); + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L); + +/* + * 㷨2.20 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + * Կ㷨2.9ĸд + */ +Status ListInsert(ELinkList* L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(ELinkList L, void(Visit)(ElemType)); + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p); + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L); + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p); + +/* + * + * + * Lеi(Ϊ0)㣬ôpҷOK + * iֵϹ棬򷵻ERROR + * رע⣬iΪ0ʱp洢ͷ + */ +Status LocatePos(ELinkList L, int i, Link* p); + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s); + +#endif diff --git a/VisualC++/CourseBook/0210_MergeEList/MergeEList-main.c b/VisualC++/CourseBook/0210_MergeEList/MergeEList-main.c new file mode 100644 index 0000000..b5fbcd5 --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/MergeEList-main.c @@ -0,0 +1,71 @@ +#include +#include "MergeEList.h" //**02 Ա**// + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} + +/* + * Ƚ + * + * Ƚe1e2ĴСֵ£ + * < 0e1 < e2 + * = 0e1 = e2 + * > 0e1 > e2 + */ +int Cmp(ElemType e1, ElemType e2) { + return e1 - e2; +} + +/* + * β巨 + * + *ע + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļfpжȡݡ + */ +void CreateList_Tail(char path[], ELinkList* L) { + FILE* fp; + int i, n; + ElemType e; + + fp = fopen(path, "r"); + if(fp == NULL) { + printf("ļʧ...\n"); + exit(ERROR); + } + + // ȡָԪص + ReadData(fp, "%d", &n); + + InitList(L); + + for(i = 1; i <= n; i++) { + ReadData(fp, "%d", &e); + ListInsert(L, i, e); + } + + fclose(fp); +} + + +int main(int argc, char** argv) { + ELinkList La, Lb, Lc; + + printf("LaLbԴ...\n"); + + CreateList_Tail("TestData_La.txt", &La); + printf("La= "); + ListTraverse(La, PrintElem); + + CreateList_Tail("TestData_Lb.txt", &Lb); + printf("Lb= "); + ListTraverse(Lb, PrintElem); + + MergeEList(&La, &Lb, &Lc, Cmp); + printf("ϲLaLbΪ Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} diff --git a/VisualC++/CourseBook/0210_MergeEList/MergeEList.c b/VisualC++/CourseBook/0210_MergeEList/MergeEList.c new file mode 100644 index 0000000..e445d32 --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/MergeEList.c @@ -0,0 +1,75 @@ +/*=============== + * 鲢ǽ + * + * 㷨: 2.21 + ================*/ + +#include "MergeEList.h" + +Status MergeEList(ELinkList* La, ELinkList* Lb, ELinkList* Lc, int(Compare)(ElemType, ElemType)){ + Link ha, hb, pa, pb, q; + ElemType a, b; + + if(InitList(Lc) == ERROR) { + return ERROR; + } + + ha = GetHead(*La); // ָLaͷ + hb = GetHead(*Lb); // ָLbͷ + + // ֤LaLbЧпǿձ + if(ha == NULL || hb ==NULL) { + return ERROR; + } + + pa = NextPos(*La, ha); // ָLa1Ԫ + pb = NextPos(*La, hb); // ָLb1Ԫ + + // LaLbѡСԪأμ뵽Lc + while(pa !=NULL && pb!=NULL){ + a = GetCurElem(pa); + b = GetCurElem(pb); + + // La<=Lb + if(Compare(a, b)<=0) { + // ժLa׸Ԫ + DelFirst(La, ha, &q); + + // ժµԪ׷ӵLc + Append(Lc, q); + + // ȻǻȡLaе1Ԫ + pa = NextPos(*La, ha); + } else { + // ժLb׸Ԫ + DelFirst(Lb, hb, &q); + + // ժµԪ׷ӵLc + Append(Lc, q); + + // ȻǻȡLaе1Ԫ + pb = NextPos(*Lb, hb); + } + } + + // Laʣ + if(pa!=NULL) { + Append(Lc, pa); + } else { + Append(Lc, pb); + } + + // ͷLaͷ㡣̲Ƕha޷ÿLaͷָ룬޸ + FreeNode(&(La->head)); + + // ͷLbͷ㡣̲Ƕhb޷ÿLbͷָ룬޸ + FreeNode(&(Lb->head)); + + La->tail = NULL; + Lb->tail = NULL; + + La->len = 0; + Lb->len = 0; + + return OK; +} \ No newline at end of file diff --git a/VisualC++/CourseBook/0210_MergeEList/MergeEList.h b/VisualC++/CourseBook/0210_MergeEList/MergeEList.h new file mode 100644 index 0000000..5137f17 --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/MergeEList.h @@ -0,0 +1,36 @@ +/*=============== + * 鲢ǽ + * + * 㷨: 2.21 + ================*/ + +#ifndef MERGEELIST_H +#define MERGEELIST_H + +#include +#include "Status.h" //**01 **// +#include "ELinkList.h" //**02 Ա**// + +/* + * ע + * + * Ϊ֮ǰĹ鲢㷨֣ｫ㷨ΪMergeEList(̲еMergeList_L) + */ + +/* + * 㷨2.21 + * + * ǵݼ鲢C=A+B + * + * AB鲢ΪCұԪλò䡣 + * 鲢󣬻LaLb + */ +Status MergeEList(ELinkList* La, ELinkList* Lb, ELinkList* Lc, int(Compare)(ElemType, ElemType)); + +/* +(01)㷨2.21LaLbǵݼУ鲢ΪһǵݼеĵLc +*/ + + + +#endif diff --git a/VisualC++/CourseBook/0210_MergeEList/TestData_La.txt b/VisualC++/CourseBook/0210_MergeEList/TestData_La.txt new file mode 100644 index 0000000..dc09018 --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/TestData_La.txt @@ -0,0 +1,2 @@ +Aijȣ6 +La = 1 2 3 5 7 8 \ No newline at end of file diff --git a/VisualC++/CourseBook/0210_MergeEList/TestData_Lb.txt b/VisualC++/CourseBook/0210_MergeEList/TestData_Lb.txt new file mode 100644 index 0000000..df78f0a --- /dev/null +++ b/VisualC++/CourseBook/0210_MergeEList/TestData_Lb.txt @@ -0,0 +1,2 @@ +Bijȣ7 +Lb = 2 4 5 8 10 11 13 \ No newline at end of file diff --git a/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj b/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj new file mode 100644 index 0000000..ba70dba --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj @@ -0,0 +1,82 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {BA5E9196-08EF-4F25-9F82-D35296370F52} + My0211_Polynomial + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj.filters b/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj.filters new file mode 100644 index 0000000..b67ac87 --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj.filters @@ -0,0 +1,44 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + 源文件 + + + + + 头文件 + + + 头文件 + + + + + 资源文件 + + + 资源文件 + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj.user b/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/0211_Polynomial.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/CourseBook/0211_Polynomial/ELinkList.c b/VisualC++/CourseBook/0211_Polynomial/ELinkList.c new file mode 100644 index 0000000..65ecb40 --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/ELinkList.c @@ -0,0 +1,338 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#include "ELinkList.h" //**02 Ա**// + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + // ռ + *p = (Link) malloc(sizeof(LNode)); + if(*p == NULL) { + // û˳򣬶Ƿشʾ + return ERROR; + } + + (*p)->data = e; + (*p)->next = NULL; + + return OK; +} + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p) { + if(p == NULL || *p == NULL) { + return; + } + + free(*p); + + *p = NULL; +} + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L) { + Link p; + + if(L == NULL) { + return ERROR; + } + + // ͷ + p = (Link) malloc(sizeof(LNode)); + if(p == NULL) { + exit(OVERFLOW); + } + p->next = NULL; + + // ֻͷʱλαָ + (*L).head = (*L).tail = p; + (*L).len = 0; + + return OK; +} + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(ELinkList* L) { + + // ʱûҪ + if(L == NULL || (*L).head == NULL) { + return ERROR; + } + + ClearList(L); + + free((*L).head); + + (*L).head = (*L).tail = NULL; + + return OK; +} + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(ELinkList* L) { + Link p, q; + + // ûЧԪʱҪ + if(L == NULL || (*L).head == NULL || (*L).len <= 0) { + return ERROR; + } + + // ָ1Ԫ + p = (*L).head->next; + + // ͷԪռڴ + while(p != NULL) { + q = p->next; + free(p); + p = q; + } + + (*L).head->next = NULL; + (*L).tail = (*L).head; + (*L).len = 0; + + return OK; +} + +/* + * + * + * ЧԪص + */ +int ListLength(ELinkList L) { + return L.len; +} + +/* + * + * + * Һ봫ͳİ汾һ + * ȻԪeCompare()==0Ԫأҵʹq洢ãTrue + * ã׸ԪeCompare()>0ԪصǰFALSE + * еԪؾeq洢ͷá + * еԪؾСeq洢βá + * £Ὣqÿա + * + *ע + * 1.ԪeCompareڶβ + */ +Status LocateElem(ELinkList L, ElemType e, Position* q, Status(Compare)(ElemType, ElemType)) { + Position pre, p; + + *q = NULL; + + // ڣشϢ + if(L.head == NULL) { + return FALSE; + } + + pre = L.head; + p = pre->next; + + while(p != NULL && Compare(p->data, e) < 0) { + pre = p; + p = p->next; + } + + // ҵe""Ԫ + if(p != NULL && Compare(p->data, e) == 0) { + *q = p; + return TRUE; + } + + // ԪؾСepԪشeֻΪձ + *q = pre; + + return FALSE; +} + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p) { + ElemType e; + + if(p == NULL) { + e.coef = 0.0f; + e.expn = -1; + return e; + } + + return p->data; +} + +/* + * ֵ + * + * ΪpԪֵ + */ +Status SetCurElem(Link p, ElemType e) { + if(p == NULL) { + return ERROR; + } + + p->data = e; + + return OK; +} + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L) { + return L.head; +} + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p) { + + // ȷ(ͷ) + if(L.head == NULL) { + return NULL; + } + + if(p == NULL) { + return NULL; + } + + return p->next; +} + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s) { + if(L == NULL || (*L).head == NULL || h == NULL || s == NULL) { + return ERROR; + } + + s->next = h->next; + h->next = s; + + // hΪβ㣬Ҫβ + if(h == (*L).tail) { + (*L).tail = h->next; + } + + (*L).len++; + + return OK; +} + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q) { + if(L == NULL || (*L).head == NULL || h == NULL || q == NULL) { + return ERROR; + } + + // ûнɾشϢ + if(h->next == NULL) { + return ERROR; + } + + *q = h->next; + + h->next = (*q)->next; + + // ɾɹĽ + (*q)->next = NULL; + + // hֻһ㣬βָ + if(h->next == NULL) { + (*L).tail = h; + } + + // ͷűɾռռ + (*L).len--; + + return OK; +} + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s) { + int count; + + if(L == NULL || (*L).head == NULL || s == NULL) { + return ERROR; + } + + count = 0; + (*L).tail->next = s; + + // ȷµβλ + while(s != NULL) { + (*L).tail = s; + s = s->next; + count++; + } + + (*L).len += count; + + return OK; +} diff --git a/VisualC++/CourseBook/0211_Polynomial/ELinkList.h b/VisualC++/CourseBook/0211_Polynomial/ELinkList.h new file mode 100644 index 0000000..44da806 --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/ELinkList.h @@ -0,0 +1,175 @@ +/*======================= + * չĵ + * + * 㷨: 2.20 + ========================*/ + +#ifndef ELINKLIST_H +#define ELINKLIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩһЩ޳ +#include "Status.h" //**01 **// + +/* + * ע + * + * ̲еΪLinkList + * Ϊ뵥֣ʽΪELinkList + * ɶͨһչ + */ + +/* + * ԪͶ + * ڶʽУõ˽ṹ͵Ԫ + */ +typedef struct { + float coef; // ʽϵ + int expn; // ʽָ +} ElemType; // ¶չԱԪ + +/* + * ṹ + * + * עͷ + */ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode, * Link, * Position; + +/* άͷβָ뼰Ϣ */ +typedef struct { + Link head, tail; // ֱָеͷβ + int len; // ָʾԪصĸ +} ELinkList; + + +/* ڴ */ + +/* + * ڴ + * + * Ϊһ㣬ָe + * + *ע + * staticεĺǸú޵ǰļʹ + */ +Status MakeNode(Link* p, ElemType e); + +/* + * ڴ + * + * ͷָĽ㡣 + * + *ע + * staticεĺǸú޵ǰļʹ + */ +void FreeNode(Link* p); + + +/* */ + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(ELinkList* L); + +/* + * (ṹ) + * + * ͷռڴ档 + */ +Status DestroyList(ELinkList* L); + +/* + * ÿ() + * + * Ҫͷзͷ㴦Ŀռ䡣 + */ +Status ClearList(ELinkList* L); + +/* + * + * + * ЧԪص + */ +int ListLength(ELinkList L); + +/* + * + * + * Һ봫ͳİ汾һ + * ȻԪeCompare()==0Ԫأҵʹq洢ãTrue + * ã׸ԪeCompare()>0ԪصǰFALSE + * еԪؾeq洢ͷá + * еԪؾСeq洢βá + * £Ὣqÿա + * + *ע + * 1.ԪeCompareڶβ + */ +Status LocateElem(ELinkList L, ElemType e, Position* q, Status(Compare)(ElemType, ElemType)); + + +/* չ */ + +/* + * ȡֵ + * + * ȡpԪֵ + */ +ElemType GetCurElem(Link p); + +/* + * ֵ + * + * ΪpԪֵ + */ +Status SetCurElem(Link p, ElemType e); + +/* + * ͷ + * + * ȡͷá + */ +Position GetHead(ELinkList L); + +/* + * + * + * ȡpḷ́ڣNULL + */ +Position NextPos(ELinkList L, Link p); + +/* + * + * + * s뵽h棬Ϊhĵһ + * + *ע + * ̲жڸ÷Щ⣬İ汾 + */ +Status InsFirst(ELinkList* L, Link h, Link s); + +/* + * ɾ + * + * ɾhĵһ㣬q洢ɾ + * + *ע + * ̲жڸ÷ĶԴֲڣİ汾 + */ +Status DelFirst(ELinkList* L, Link h, Link* q); + +/* + * β + * + * sָһL + */ +Status Append(ELinkList* L, Link s); + +#endif diff --git a/VisualC++/CourseBook/0211_Polynomial/Polynomial-main.c b/VisualC++/CourseBook/0211_Polynomial/Polynomial-main.c new file mode 100644 index 0000000..ab64e6e --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/Polynomial-main.c @@ -0,0 +1,79 @@ +#include "Polynomial.h" //**02 Ա**// + +int main(int argc, char **argv) { + Polynomial Pa, Pb; + int m, n; + + m = 5; + n = 6; + + printf(" CreatPolyn \n"); + { + printf(" ΪʾΪ %d ĶʽPa...\n", m); + CreatPolyn("TestData_Pa.txt", &Pa, m); + + printf(" ΪʾΪ %d ĶʽPb...\n", n); + CreatPolyn("TestData_Pb.txt", &Pb, n); + } + PressEnterToContinue(); + + + printf(" PrintPolyn \n"); + { + printf(" һԪʽ Pa = "); + PrintPolyn(Pa); + + printf(" һԪʽ Pb = "); + PrintPolyn(Pb); + } + PressEnterToContinue(); + + + printf(" PolynLength \n"); + { + printf(" La Ϊ %d Lb Ϊ %d\n", PolynLength(Pa), PolynLength(Pb)); + } + PressEnterToContinue(); + + + printf(" AddPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + AddPolyn(&Pa, &Pb); + + printf(" Pa = Pa + Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + + printf(" SubtractPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + SubtractPolyn(&Pa, &Pb); + + printf(" Pa = Pa - Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + + printf(" MultiplyPolyn \n"); + { + CreatPolyn("TestData_Pa.txt", &Pa, m); + CreatPolyn("TestData_Pb.txt", &Pb, n); + + MultiplyPolyn(&Pa, &Pb); + + printf(" Pa = Pa * Pb = "); + PrintPolyn(Pa); + } + PressEnterToContinue(); + + return 0; +} + diff --git a/VisualC++/CourseBook/0211_Polynomial/Polynomial.c b/VisualC++/CourseBook/0211_Polynomial/Polynomial.c new file mode 100644 index 0000000..b575b3f --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/Polynomial.c @@ -0,0 +1,397 @@ +/*======================== + * һԪʽ() + * + * 㷨: 2.222.23 + =========================*/ + +#include "Polynomial.h" + + +/* һԪʽ */ + +/* + * 㷨2.22 + * + * + * + * ϵָΪmһԪʽ + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡ + */ +void CreatPolyn(char path[], Polynomial* P, int m) { + FILE* fp; + int i; + ElemType e; + Position h, q; + Link s; + + // ʼһһԪʽ + InitList(P); + + // ȡʽͷָ + h = GetHead(*P); + + // Ϊͷ + e.coef = 0.0f; + e.expn = -1; + SetCurElem(h, e); + + // ļ׼ȡ + fp = fopen(path, "r"); + if(fp == NULL) { + exit(ERROR); + } + + // ¼mЧ + for(i = 1; i <= m; i++) { + // ȡϵָϢʱe + ReadData(fp, "%f%d", &(e.coef), &(e.expn)); + + // ǰвڸָ + if(LocateElem(*P, e, &q, Cmp) == FALSE && q != NULL) { + // ½ + if(MakeNode(&s, e) == OK) { + // q֮s + InsFirst(P, q, s); + } + } + } + + fclose(fp); +} + +/* + * + * + * һԪʽ + */ +void DestroyPolyn(Polynomial* P) { + DestroyList(P); +} + +/* + * + * + * һԪʽ + */ +int PolynLength(Polynomial P) { + return ListLength(P); +} + +/* + * 㷨2.23 + * + * ӷ + * + * һԪʽӷPa=Pa+Pb + * ɺ󣬼浽PaУPb١ + */ +void AddPolyn(Polynomial* Pa, Polynomial* Pb) { + Position ha, hb; + Position qa, qb; + ElemType a, b; + float sum; + + // hahbֱָPaPbͷ + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // qaqbֱָPaPbĵǰ + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + + // qaqbǿ + while(qa && qb) { + // abΪеǰȽԪ + a = GetCurElem(qa); + b = GetCurElem(qb); + + //ȽϵǰԪصָС + switch(Cmp(a, b)) { + // ʽPaеǰֵָС + case -1: { + ha = qa; + qa = NextPos(*Pa, qa); + } + break; + + // ֵ + case 0: { + sum = a.coef + b.coef; + + // ӲܵʱPaϵֵ + if(sum != 0.0) { + // SetCurElem()ʣֱӸֵ + qa->data.coef = sum; + // ha + ha = qa; + + //ӵʱɾPaеǰ + } else { + // ɾhaĽ㣨ʵɾľqa + DelFirst(Pa, ha, &qa); + // ͷűɾռռ + FreeNode(&qa); + } + + // ɾPbɨĽ + DelFirst(Pb, hb, &qb); + // ͷűɾռռ + FreeNode(&qb); + + // qaqb + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + + // ʽPbеǰֵָС + case 1: { + // ժPbǰ + DelFirst(Pb, hb, &qb); + + // ժ½Pa + InsFirst(Pa, ha, qb); + + ha = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + }//switch + }//while + + // Pbδɨ꣬ʣӵPa + if(qb != NULL) { + Append(Pa, qb); + } + + // ͷPbͷ + FreeNode(&hb); + + // PbΪ״̬ + (*Pb).head = (*Pb).tail = NULL; + (*Pb).len = 0; +} + +/* + * + * + * һԪʽPa=Pa-Pb + * ɺ󣬼浽PaУPb١ + */ +void SubtractPolyn(Polynomial* Pa, Polynomial* Pb) { + Position ha, hb; + Position qa, qb; + Position r; + ElemType a, b; + float sum; + + // hahbֱָPaPbͷ + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // qaqbֱָPaPbĵǰ + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + + // qaqbǿ + while(qa && qb) { + // abΪеǰȽԪ + a = GetCurElem(qa); + b = GetCurElem(qb); + + // ȽϵǰԪصָС + switch(Cmp(a, b)) { + // ʽPaеǰֵָС + case -1: { + ha = qa; + qa = NextPos(*Pa, ha); + } + break; + + // ֵ + case 0: { + sum = a.coef - b.coef; + + // ܵʱPaϵֵ + if(sum != 0.0) { + // ϵ + qa->data.coef = sum; + // ha + ha = qa; + + // ʱɾPaеǰ + } else { + // ɾhaĽ㣨ʵɾľqa + DelFirst(Pa, ha, &qa); + // ͷűɾռռ + FreeNode(&qa); + } + + // ɾPbɨĽ + DelFirst(Pb, hb, &qb); + // ͷűɾռռ + FreeNode(&qb); + + // qaqb + qa = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + + // ʽPbеǰֵָС + case 1: { + // ժPbǰ + DelFirst(Pb, hb, &qb); + + // ı䵱ǰ + qb->data.coef = -qb->data.coef; + + // ժ½Pa + InsFirst(Pa, ha, qb); + + ha = NextPos(*Pa, ha); + qb = NextPos(*Pb, hb); + } + break; + }//switch + }//while + + // Pbδɨ꣬ʣϵȡӵPa + if(qb != NULL) { + // ıʣķ + for(r = qb = 0; r != NULL; r = r->next) { + r->data.coef = -r->data.coef; + } + + Append(Pa, qb); + } + + // ͷPbͷ + FreeNode(&hb); + + // PbΪ״̬ + (*Pb).head = (*Pb).tail = NULL; + (*Pb).len = 0; +} + +/* + * ˷ + * + * һԪʽ˷Pa=Pa*Pb + * ɺ󣬼浽PaУPb١ + */ +void MultiplyPolyn(Polynomial* Pa, Polynomial* Pb) { + Polynomial Pc, Ptmp; + int i, j, la, lb; + Position ha, hb; + Position qa, qb; + Link s; + ElemType e; + + // ȡʽij + la = PolynLength(*Pa); + lb = PolynLength(*Pb); + + // hahbֱָPaPbͷ + ha = GetHead(*Pa); + hb = GetHead(*Pb); + + // ۼӼ + InitList(&Pc); + + // PaеԪ + for(i = 1; i <= la; i++) { + // 洢ʱ + InitList(&Ptmp); + + // ժPaеĽ + DelFirst(Pa, ha, &qa); + + // Pbн㣬PaժµĽ + for(j = 1, qb = NextPos(*Pb, hb); j <= lb; j++, qb = NextPos(*Pb, qb)) { + e.coef = qa->data.coef * qb->data.coef; //ϵ + e.expn = qa->data.expn + qb->data.expn; //ָ + + // ½洢 + MakeNode(&s, e); + + // ӵʱʽ + Append(&Ptmp, s); + } + + // µĶʽۼӵPc + AddPolyn(&Pc, &Ptmp); + } + + // нӵPa + AddPolyn(Pa, &Pc); + + // ٶʽPb + DestroyPolyn(Pb); +} + + +/* */ + +/* + * + * + * ӡһԪʽ + */ +void PrintPolyn(Polynomial P) { + int i; + Link p; + + p = P.head->next; + for(i = 1; i <= P.len; i++) { + if(p->data.coef == 0.0f) { + continue; + } + + if(i == 1) { + printf("%g", p->data.coef); + } else { + if(p->data.coef > 0) { + printf(" + "); + printf("%g", p->data.coef); + } else { + printf(" - "); + printf("%g", -p->data.coef); + } + } + + if(p->data.expn) { + printf("x"); + + if(p->data.expn != 1) { + printf("^%d", p->data.expn); + } + } + + p = p->next; + } + + printf("\n"); +} + +/* + * Ƚ + * + * Ƚc1c2ָС + */ +int Cmp(ElemType c1, ElemType c2) { + // ָ + int i = c1.expn - c2.expn; + + if(i < 0) { + return -1; + } else if(i == 0) { + return 0; + } else { + return 1; + } +} diff --git a/VisualC++/CourseBook/0211_Polynomial/Polynomial.h b/VisualC++/CourseBook/0211_Polynomial/Polynomial.h new file mode 100644 index 0000000..8a6204a --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/Polynomial.h @@ -0,0 +1,91 @@ +/*======================== + * һԪʽ() + * + * 㷨: 2.222.23 + =========================*/ + +#ifndef POLYNOMIAL_H +#define POLYNOMIAL_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "ELinkList.h" //**02 Ա**// + +/* һԪʽͶ */ +typedef ELinkList Polynomial; + + +/* һԪʽ */ + +/* + * 㷨2.22 + * + * + * + * ϵָΪmһԪʽ + * + *ע + * ̲Ĭϴӿ̨ȡݡ + * Ϊ˷ԣÿжֶݣ + * ѡ˴Ԥļpathжȡ + */ +void CreatPolyn(char path[], Polynomial *P, int m); + +/* + * + * + * һԪʽ + */ +void DestroyPolyn(Polynomial *P); + +/* + * + * + * һԪʽ + */ +int PolynLength(Polynomial P); + +/* + * 㷨2.23 + * + * ӷ + * + * һԪʽӷPa=Pa+Pb + * ɺ󣬼浽PaУPb١ + */ +void AddPolyn(Polynomial *Pa, Polynomial *Pb); + +/* + * + * + * һԪʽPa=Pa-Pb + * ɺ󣬼浽PaУPb١ + */ +void SubtractPolyn(Polynomial *Pa, Polynomial *Pb); + +/* + * ˷ + * + * һԪʽ˷Pa=Pa*Pb + * ɺ󣬼浽PaУPb١ + */ +void MultiplyPolyn(Polynomial *Pa, Polynomial *Pb); + + +/* */ + +/* + * + * + * ӡһԪʽ + */ +void PrintPolyn(Polynomial P); + +/* + * Ƚ + * + * Ƚc1c2ָС + */ +int Cmp(ElemType c1, ElemType c2); + +#endif diff --git a/VisualC++/CourseBook/0211_Polynomial/TestData_Pa.txt b/VisualC++/CourseBook/0211_Polynomial/TestData_Pa.txt new file mode 100644 index 0000000..e72f216 --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/TestData_Pa.txt @@ -0,0 +1 @@ +Pa = (2.1 , 1) (5.3 , 7) (4.0 , 3) (2.5 , 9) (-3.12 , 5) \ No newline at end of file diff --git a/VisualC++/CourseBook/0211_Polynomial/TestData_Pb.txt b/VisualC++/CourseBook/0211_Polynomial/TestData_Pb.txt new file mode 100644 index 0000000..2940e87 --- /dev/null +++ b/VisualC++/CourseBook/0211_Polynomial/TestData_Pb.txt @@ -0,0 +1 @@ +Pb = (0.5 , 12) (-3.17 , 4) (3.4 , 2) (-2.5 , 9) (4.1 , 5) (1.8 , 8) \ No newline at end of file diff --git a/VisualC++/CourseBook/CourseBook.sdf b/VisualC++/CourseBook/CourseBook.sdf new file mode 100644 index 0000000..67ff2c3 Binary files /dev/null and b/VisualC++/CourseBook/CourseBook.sdf differ diff --git a/VisualC++/CourseBook/CourseBook.sln b/VisualC++/CourseBook/CourseBook.sln new file mode 100644 index 0000000..e00d873 --- /dev/null +++ b/VisualC++/CourseBook/CourseBook.sln @@ -0,0 +1,80 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual C++ Express 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0201_SqList", "0201_SqList\0201_SqList.vcxproj", "{4DDF7C1A-9DF8-4983-B478-1B8928B8A239}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0202_Union", "0202_Union\0202_Union.vcxproj", "{5C53EFFE-EE74-42B8-875C-CFB7B2659917}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0203_MergeSqList", "0203_MergeSqList\0203_MergeSqList.vcxproj", "{D3309A60-3384-4EB0-9392-BEB5BF9934BF}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0204_LinkList", "0204_LinkList\0204_LinkList.vcxproj", "{8818D7C5-70C7-4649-9690-ACB30147C37B}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0205_MergeList", "0205_MergeList\0205_MergeList.vcxproj", "{DC3475CD-A081-423F-BCE5-14464B66F475}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0206_SLinkList", "0206_SLinkList\0206_SLinkList.vcxproj", "{C0C969A9-926E-4AE3-87AC-F73CB04D0BC7}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0207_Difference", "0207_Difference\0207_Difference.vcxproj", "{EB17D84C-751A-4261-BE9F-B02951BF8E51}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0208_DuLinkList", "0208_DuLinkList\0208_DuLinkList.vcxproj", "{6816DB4B-DC29-4BF4-8D93-F6B00444FD37}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0209_ELinkList", "0209_ELinkList\0209_ELinkList.vcxproj", "{2FE48840-F7BB-4DC7-B3D9-4AFF2B35206B}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0210_MergeEList", "0210_MergeEList\0210_MergeEList.vcxproj", "{58E663CD-DDC0-48B4-BE73-5AA11CEED026}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "0211_Polynomial", "0211_Polynomial\0211_Polynomial.vcxproj", "{BA5E9196-08EF-4F25-9F82-D35296370F52}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {4DDF7C1A-9DF8-4983-B478-1B8928B8A239}.Debug|Win32.ActiveCfg = Debug|Win32 + {4DDF7C1A-9DF8-4983-B478-1B8928B8A239}.Debug|Win32.Build.0 = Debug|Win32 + {4DDF7C1A-9DF8-4983-B478-1B8928B8A239}.Release|Win32.ActiveCfg = Release|Win32 + {4DDF7C1A-9DF8-4983-B478-1B8928B8A239}.Release|Win32.Build.0 = Release|Win32 + {5C53EFFE-EE74-42B8-875C-CFB7B2659917}.Debug|Win32.ActiveCfg = Debug|Win32 + {5C53EFFE-EE74-42B8-875C-CFB7B2659917}.Debug|Win32.Build.0 = Debug|Win32 + {5C53EFFE-EE74-42B8-875C-CFB7B2659917}.Release|Win32.ActiveCfg = Release|Win32 + {5C53EFFE-EE74-42B8-875C-CFB7B2659917}.Release|Win32.Build.0 = Release|Win32 + {D3309A60-3384-4EB0-9392-BEB5BF9934BF}.Debug|Win32.ActiveCfg = Debug|Win32 + {D3309A60-3384-4EB0-9392-BEB5BF9934BF}.Debug|Win32.Build.0 = Debug|Win32 + {D3309A60-3384-4EB0-9392-BEB5BF9934BF}.Release|Win32.ActiveCfg = Release|Win32 + {D3309A60-3384-4EB0-9392-BEB5BF9934BF}.Release|Win32.Build.0 = Release|Win32 + {8818D7C5-70C7-4649-9690-ACB30147C37B}.Debug|Win32.ActiveCfg = Debug|Win32 + {8818D7C5-70C7-4649-9690-ACB30147C37B}.Debug|Win32.Build.0 = Debug|Win32 + {8818D7C5-70C7-4649-9690-ACB30147C37B}.Release|Win32.ActiveCfg = Release|Win32 + {8818D7C5-70C7-4649-9690-ACB30147C37B}.Release|Win32.Build.0 = Release|Win32 + {DC3475CD-A081-423F-BCE5-14464B66F475}.Debug|Win32.ActiveCfg = Debug|Win32 + {DC3475CD-A081-423F-BCE5-14464B66F475}.Debug|Win32.Build.0 = Debug|Win32 + {DC3475CD-A081-423F-BCE5-14464B66F475}.Release|Win32.ActiveCfg = Release|Win32 + {DC3475CD-A081-423F-BCE5-14464B66F475}.Release|Win32.Build.0 = Release|Win32 + {C0C969A9-926E-4AE3-87AC-F73CB04D0BC7}.Debug|Win32.ActiveCfg = Debug|Win32 + {C0C969A9-926E-4AE3-87AC-F73CB04D0BC7}.Debug|Win32.Build.0 = Debug|Win32 + {C0C969A9-926E-4AE3-87AC-F73CB04D0BC7}.Release|Win32.ActiveCfg = Release|Win32 + {C0C969A9-926E-4AE3-87AC-F73CB04D0BC7}.Release|Win32.Build.0 = Release|Win32 + {EB17D84C-751A-4261-BE9F-B02951BF8E51}.Debug|Win32.ActiveCfg = Debug|Win32 + {EB17D84C-751A-4261-BE9F-B02951BF8E51}.Debug|Win32.Build.0 = Debug|Win32 + {EB17D84C-751A-4261-BE9F-B02951BF8E51}.Release|Win32.ActiveCfg = Release|Win32 + {EB17D84C-751A-4261-BE9F-B02951BF8E51}.Release|Win32.Build.0 = Release|Win32 + {6816DB4B-DC29-4BF4-8D93-F6B00444FD37}.Debug|Win32.ActiveCfg = Debug|Win32 + {6816DB4B-DC29-4BF4-8D93-F6B00444FD37}.Debug|Win32.Build.0 = Debug|Win32 + {6816DB4B-DC29-4BF4-8D93-F6B00444FD37}.Release|Win32.ActiveCfg = Release|Win32 + {6816DB4B-DC29-4BF4-8D93-F6B00444FD37}.Release|Win32.Build.0 = Release|Win32 + {2FE48840-F7BB-4DC7-B3D9-4AFF2B35206B}.Debug|Win32.ActiveCfg = Debug|Win32 + {2FE48840-F7BB-4DC7-B3D9-4AFF2B35206B}.Debug|Win32.Build.0 = Debug|Win32 + {2FE48840-F7BB-4DC7-B3D9-4AFF2B35206B}.Release|Win32.ActiveCfg = Release|Win32 + {2FE48840-F7BB-4DC7-B3D9-4AFF2B35206B}.Release|Win32.Build.0 = Release|Win32 + {58E663CD-DDC0-48B4-BE73-5AA11CEED026}.Debug|Win32.ActiveCfg = Debug|Win32 + {58E663CD-DDC0-48B4-BE73-5AA11CEED026}.Debug|Win32.Build.0 = Debug|Win32 + {58E663CD-DDC0-48B4-BE73-5AA11CEED026}.Release|Win32.ActiveCfg = Release|Win32 + {58E663CD-DDC0-48B4-BE73-5AA11CEED026}.Release|Win32.Build.0 = Release|Win32 + {BA5E9196-08EF-4F25-9F82-D35296370F52}.Debug|Win32.ActiveCfg = Debug|Win32 + {BA5E9196-08EF-4F25-9F82-D35296370F52}.Debug|Win32.Build.0 = Debug|Win32 + {BA5E9196-08EF-4F25-9F82-D35296370F52}.Release|Win32.ActiveCfg = Release|Win32 + {BA5E9196-08EF-4F25-9F82-D35296370F52}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/VisualC++/CourseBook/CourseBook.suo b/VisualC++/CourseBook/CourseBook.suo new file mode 100644 index 0000000..6c1f351 Binary files /dev/null and b/VisualC++/CourseBook/CourseBook.suo differ diff --git a/VisualC++/ExerciseBook/01.16/01.16.c b/VisualC++/ExerciseBook/01.16/01.16.c new file mode 100644 index 0000000..e47616f --- /dev/null +++ b/VisualC++/ExerciseBook/01.16/01.16.c @@ -0,0 +1,53 @@ +#include + +/* + * 1.16 + * + * 3ӴС˳ + */ +void Algo_1_16(int *x, int *y, int *z); + + +int main(int argc, char* argv[]) { + int x, y, z; + + x = 3; + y = 7; + z = 1; + + printf("Ϊʾ趨Ϊ%d %d %d...\n", x, y, z); + + // + Algo_1_16(&x, &y, &z); + + printf("ӴСΪ%d %d %d...\n", x, y, z); + + return 0; +} + + +// 3ӴС˳ +void Algo_1_16(int *x, int *y, int *z) { + int tmp; + + // ȷx>=y + if(*x < *y) { + tmp = *x; + *x = *y; + *y = tmp; + } + + // ȷz>=y + if(*y < *z) { + tmp = *y; + *y = *z; + *z = tmp; + } + + // ȷx>=z + if(*x < *z) { + tmp = *x; + *x = *z; + *z = tmp; + } +} diff --git a/VisualC++/ExerciseBook/01.16/01.16.vcxproj b/VisualC++/ExerciseBook/01.16/01.16.vcxproj new file mode 100644 index 0000000..6dc861b --- /dev/null +++ b/VisualC++/ExerciseBook/01.16/01.16.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {5D2C546F-8544-475E-8060-44A929F48A65} + My0116 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.16/01.16.vcxproj.filters b/VisualC++/ExerciseBook/01.16/01.16.vcxproj.filters new file mode 100644 index 0000000..d8dc5ba --- /dev/null +++ b/VisualC++/ExerciseBook/01.16/01.16.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.16/01.16.vcxproj.user b/VisualC++/ExerciseBook/01.16/01.16.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/01.16/01.16.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.17/01.17.c b/VisualC++/ExerciseBook/01.17/01.17.c new file mode 100644 index 0000000..0959239 --- /dev/null +++ b/VisualC++/ExerciseBook/01.17/01.17.c @@ -0,0 +1,86 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* + * 1.171ݹ㷨 + * + * k쳲еmֵ + * + * עintͣʱ + */ +int Algo_1_17_1(int k, int m); + +/* + * 1.172()㷨 + * + * k쳲еmֵ + * + * עintͣʱ + */ +int Algo_1_17_2(int k, int m); + + +int main(int argc, char* argv[]) { + int k, m; + + k = 3; + m = 20; + + printf("Ϊʾ %d 쳲е %d ֵΪ%d \n", k, m, Algo_1_17_1(k, m)); + + printf("Ϊʾ %d 쳲е %d ֵΪ%d \n", k, m, Algo_1_17_2(k, m)); + + return 0; +} + + +// k쳲еmֵ +int Algo_1_17_1(int k, int m) { + int i, value; + + if(k < 2 || m < 0) { + exit(OVERFLOW); + } + + if(m < k - 1) { + return 0; + } else if(m == k - 1) { + return 1; + } else { + for(i = 1, value = 0; i <= k; i++) { + value += Algo_1_17_1(k, m - i); + } + + return value; + } +} + +// k쳲еmֵ +int Algo_1_17_2(int k, int m) { + int i, j; + int* fib; + + if(k < 1 || m < 0) { + exit(OVERFLOW); + } + + // fib + fib = (int*) malloc((m + 1) * sizeof(int)); + + // ʼǰk-1Ϊ0 + for(i = 0; i < k - 1 ;i++) { + fib[i] = 0; + } + + fib[k-1] = 1; + + for(i = k; i <= m; ++i) { + // ۼǰk + for(j = i - 1, fib[i] = 0; j >= i - k; j--) { + fib[i] += fib[j]; + } + } + + return fib[m]; +} diff --git a/VisualC++/ExerciseBook/01.17/01.17.vcxproj b/VisualC++/ExerciseBook/01.17/01.17.vcxproj new file mode 100644 index 0000000..6710099 --- /dev/null +++ b/VisualC++/ExerciseBook/01.17/01.17.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {D604D310-9601-49FB-ABEE-48D81E6A2724} + My0117 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.17/01.17.vcxproj.filters b/VisualC++/ExerciseBook/01.17/01.17.vcxproj.filters new file mode 100644 index 0000000..17b7e23 --- /dev/null +++ b/VisualC++/ExerciseBook/01.17/01.17.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.17/01.17.vcxproj.user b/VisualC++/ExerciseBook/01.17/01.17.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/01.17/01.17.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.19/01.19.c b/VisualC++/ExerciseBook/01.19/01.19.c new file mode 100644 index 0000000..31d5b91 --- /dev/null +++ b/VisualC++/ExerciseBook/01.19/01.19.c @@ -0,0 +1,55 @@ +#include +#include // ṩINT_MAX +#include "Status.h" //**01 **// + +/* 궨 */ +#define arrsize 20 //鳤 +#define maxint INT_MAX // + +/* + * 1.17 + * + * i!*2^iֵa[i-1]i[1, arrsize] + * + * i!*2^i = (i-1)!*2^(i-1) * i * 2 + */ +Status Algo_1_19(int i, int a[]); + + +int main(int argc, char* argv[]) { + int i, a[arrsize]; + + i = 5; + + printf("i!*2^i...\n"); + + if(Algo_1_19(i, a) == OK) { + printf("Ϊʾ㵱i = %d ʱa[i-1] = %d\n", i, a[i - 1]); + } + + return 0; +} + + +// i!*2^iֵ +Status Algo_1_19(int i, int a[]) { + int j; + + if(i < 1 || i > arrsize) { + return ERROR; + } + + // i==1ʱ + a[0] = 2; + + // i>1ʱ + for(j = 2; j <= i; j++) { + if(maxint / (2 * j) < a[j - 2]) { + return OVERFLOW; + } + + a[j - 1] = a[j - 2] * j * 2; + } + + return OK; +} diff --git a/VisualC++/ExerciseBook/01.19/01.19.vcxproj b/VisualC++/ExerciseBook/01.19/01.19.vcxproj new file mode 100644 index 0000000..62a8803 --- /dev/null +++ b/VisualC++/ExerciseBook/01.19/01.19.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {F30CB20D-C44F-45FF-AA39-D459E6EB16B9} + My0119 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.19/01.19.vcxproj.filters b/VisualC++/ExerciseBook/01.19/01.19.vcxproj.filters new file mode 100644 index 0000000..0ef5a41 --- /dev/null +++ b/VisualC++/ExerciseBook/01.19/01.19.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.19/01.19.vcxproj.user b/VisualC++/ExerciseBook/01.19/01.19.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/01.19/01.19.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.20/01.20.c b/VisualC++/ExerciseBook/01.20/01.20.c new file mode 100644 index 0000000..1d1c8b3 --- /dev/null +++ b/VisualC++/ExerciseBook/01.20/01.20.c @@ -0,0 +1,34 @@ +#include +#include //ṩpowԭ + +/* + * 1.20 + * + * ʽPn(Xo)ֵ + */ +double Algo_1_20(int a[], int x, int n); + + +int main(int argc, char* argv[]) { + int a[5] = {-2, 3, 6, -8, 7}; + int n = 5; + int Xo = 3; + + printf("Ϊʾ趨n = 5Xo = 3Pn(Xo)...\n"); + printf("P%d(%d) = %f\n", n, Xo, Algo_1_20(a, Xo, n)); + + return 0; +} + + +// ʽPn(Xo)ֵ +double Algo_1_20(int a[], int x, int n) { + int i; + double tmp; + + for(i = 1, tmp = 0; i <= n; i++) { + tmp += a[i - 1] * pow(x, i - 1); + } + + return tmp; +} \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.20/01.20.vcxproj b/VisualC++/ExerciseBook/01.20/01.20.vcxproj new file mode 100644 index 0000000..c75e6d0 --- /dev/null +++ b/VisualC++/ExerciseBook/01.20/01.20.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {A6883C77-6D02-44B1-B492-965B019E15C2} + My0120 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.20/01.20.vcxproj.filters b/VisualC++/ExerciseBook/01.20/01.20.vcxproj.filters new file mode 100644 index 0000000..c98c2c9 --- /dev/null +++ b/VisualC++/ExerciseBook/01.20/01.20.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/01.20/01.20.vcxproj.user b/VisualC++/ExerciseBook/01.20/01.20.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/01.20/01.20.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.10/02.10.c b/VisualC++/ExerciseBook/02.10/02.10.c new file mode 100644 index 0000000..76b985f --- /dev/null +++ b/VisualC++/ExerciseBook/02.10/02.10.c @@ -0,0 +1,68 @@ +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.10 + * + * ɾ˳дӵiԪkԪ + * ikֵϹ棬˳б仯 + */ +Status Algo_2_10(SqList* a, int i, int k); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // ʼ˳ + InitList(&L); + + // ֵ + for(i = 1; i <= 15; i++) { + ListInsert(&L, i, i); + } + + printf("ɾǰL = "); + ListTraverse(L, PrintElem); + + printf("ɾ 6 Ԫ 5 Ԫ...\n"); + Algo_2_10(&L, 6, 5); + + printf("ɾL = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// ɾ˳дӵiԪkԪ +Status Algo_2_10(SqList* a, int i, int k) { + int j; + + // ȷ˳ + if(a == NULL || a->elem == NULL) { + return ERROR; + } + + // ±Խ + if(i < 1 || i > (*a).length || k < 0 || i + k - 1 > (*a).length) { + return ERROR; + } + + for(j = i; j <= i + k - 1; j++) { + (*a).elem[j - 1] = (*a).elem[j + k - 1]; + } + + (*a).length -= k; + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.10/02.10.vcxproj b/VisualC++/ExerciseBook/02.10/02.10.vcxproj new file mode 100644 index 0000000..1b13504 --- /dev/null +++ b/VisualC++/ExerciseBook/02.10/02.10.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {00719F0C-F124-42BE-9297-711FF153A064} + My0210 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.10/02.10.vcxproj.filters b/VisualC++/ExerciseBook/02.10/02.10.vcxproj.filters new file mode 100644 index 0000000..b5c8292 --- /dev/null +++ b/VisualC++/ExerciseBook/02.10/02.10.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.10/02.10.vcxproj.user b/VisualC++/ExerciseBook/02.10/02.10.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.10/02.10.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.10/SqList.c b/VisualC++/ExerciseBook/02.10/SqList.c new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/VisualC++/ExerciseBook/02.10/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.10/SqList.h b/VisualC++/ExerciseBook/02.10/SqList.h new file mode 100644 index 0000000..a7b6e55 --- /dev/null +++ b/VisualC++/ExerciseBook/02.10/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.11/02.11.c b/VisualC++/ExerciseBook/02.11/02.11.c new file mode 100644 index 0000000..716a9a0 --- /dev/null +++ b/VisualC++/ExerciseBook/02.11/02.11.c @@ -0,0 +1,92 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.11 + * + * x뵽va + */ +Status Algo_2_11(SqList* va, ElemType x); + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // ʼ˳ + InitList(&L); + + // ֵ + for(i = 1; i <= 5; i++) { + ListInsert(&L, i, 2 * i); + } + + printf("ǰL = "); + ListTraverse(L, PrintElem); + + printf("Ԫ\"5\"뵽˳...\n"); + Algo_2_11(&L, 5); + + printf("L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// x뵽va +Status Algo_2_11(SqList* va, ElemType x) { + int i, j; + ElemType* newbase; + + // ȷ˳ + if(va == NULL || va->elem == NULL) { + return ERROR; + } + + // 洢ռ迪¿ռ + if((*va).length == (*va).listsize) { + newbase = (ElemType*) realloc((*va).elem, ((*va).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + exit(OVERFLOW); + } + + (*va).elem = newbase; + (*va).listsize += LISTINCREMENT; + } + + // ˳׸ԪxԪλλxҪλ + i = LocateElem(*va, x, CmpGreater); + if(i == 0) { + // Ҫ뵽˳ + i = (*va).length + 1; + } + + // Ԫغƣڳλáעjλ򣬼1֮ + for(j=(*va).length + 1; j>i; j--){ + (*va).elem[j-1] = (*va).elem[j-2]; + } + + (*va).elem[j-1] = x; + (*va).length++; + + return OK; +} + +// жdata>eǷ +Status CmpGreater(ElemType data, ElemType e) { + return data > e ? TRUE : FALSE; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.11/02.11.vcxproj b/VisualC++/ExerciseBook/02.11/02.11.vcxproj new file mode 100644 index 0000000..f225d0d --- /dev/null +++ b/VisualC++/ExerciseBook/02.11/02.11.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {52058BF7-48EF-4058-A47D-C358600A3D43} + My0211 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.11/02.11.vcxproj.filters b/VisualC++/ExerciseBook/02.11/02.11.vcxproj.filters new file mode 100644 index 0000000..8a34bce --- /dev/null +++ b/VisualC++/ExerciseBook/02.11/02.11.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.11/02.11.vcxproj.user b/VisualC++/ExerciseBook/02.11/02.11.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.11/02.11.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.11/SqList.c b/VisualC++/ExerciseBook/02.11/SqList.c new file mode 100644 index 0000000..0d96ded --- /dev/null +++ b/VisualC++/ExerciseBook/02.11/SqList.c @@ -0,0 +1,142 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + ElemType* p; + + // ȷ˳ṹ + if(L.elem == NULL) { + return ERROR; + } + + /* + * iijֵΪ1Ԫصλ + * + * ʵȻдǽiʼΪ1Ԫص + * ڽ̲ǰλģдλ + */ + i = 1; + + // pijֵΪ1ԪصĴ洢λ + p = L.elem; + + // ˳ + while(i <= L.length && !Compare(*p++, e)) { + ++i; + } + + if(i <= L.length) { + return i; + } else { + return 0; + } +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.11/SqList.h b/VisualC++/ExerciseBook/02.11/SqList.h new file mode 100644 index 0000000..4de6606 --- /dev/null +++ b/VisualC++/ExerciseBook/02.11/SqList.h @@ -0,0 +1,74 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.6 + * + * + * + * ˳׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(SqList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.12/02.12.c b/VisualC++/ExerciseBook/02.12/02.12.c new file mode 100644 index 0000000..bc988c7 --- /dev/null +++ b/VisualC++/ExerciseBook/02.12/02.12.c @@ -0,0 +1,86 @@ +#include +#include "SqList.h" //**02 Ա**// + +/* + * 2.12 + * + * Ƚ˳СȽϲǴұ˳ + * ׶ԲͬԪʱݸԪصĴСϵȷ˳ĴСϵ + * + * ֵ-101ֱAB + */ +int Algo_2_12(SqList A, SqList B); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + int i, mark; + SqList A, B; + + int a[7] = {1, 2, 3, 4, 5, 9, 12}; + int b[7] = {1, 2, 3, 4, 5, 11, 12}; + + // ʼ + InitList(&A); + InitList(&B); + + // ֵ + for(i = 1; i <= 7; i++) { + ListInsert(&A, i, a[i - 1]); + ListInsert(&B, i, b[i - 1]); + } + + printf("A = "); + ListTraverse(A, PrintElem); + + printf("B = "); + ListTraverse(B, PrintElem); + + mark = Algo_2_12(A, B); + if(mark < 0) { + printf("==> A 1) { + printf("==> A>B\n"); + } else { + printf("A==B\n"); + } + + return 0; +} + + +// Ƚ˳С +int Algo_2_12(SqList A, SqList B) { + int i = 0; + + // ɨ˳AB + while(i < A.length && i < B.length) { + if(A.elem[i] > B.elem[i]) { + return 1; + } else if(A.elem[i] < B.elem[i]) { + return -1; + } else { + i++; //ʱȽһԪ + } + } + + // Aʣ࣬A + if(i < A.length) { + return 1; + + // Bʣ࣬B + } else if(i < B.length) { + return -1; + + // ͬʱɨ꣬ + } else { + return 0; + } +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.12/02.12.vcxproj b/VisualC++/ExerciseBook/02.12/02.12.vcxproj new file mode 100644 index 0000000..dd90a57 --- /dev/null +++ b/VisualC++/ExerciseBook/02.12/02.12.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {BB137EB3-5250-427B-95D7-0D26A73234C7} + My0212 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.12/02.12.vcxproj.filters b/VisualC++/ExerciseBook/02.12/02.12.vcxproj.filters new file mode 100644 index 0000000..e85b0d2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.12/02.12.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.12/02.12.vcxproj.user b/VisualC++/ExerciseBook/02.12/02.12.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.12/02.12.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.12/SqList.c b/VisualC++/ExerciseBook/02.12/SqList.c new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/VisualC++/ExerciseBook/02.12/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.12/SqList.h b/VisualC++/ExerciseBook/02.12/SqList.h new file mode 100644 index 0000000..cd00561 --- /dev/null +++ b/VisualC++/ExerciseBook/02.12/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.13/02.13.c b/VisualC++/ExerciseBook/02.13/02.13.c new file mode 100644 index 0000000..44ca935 --- /dev/null +++ b/VisualC++/ExerciseBook/02.13/02.13.c @@ -0,0 +1,60 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.13 + * + * ѰԪxLеλá + * 0˵xڡ + */ +int Algo_2_13(LinkList L, ElemType x); + +// жdata==eǷ +Status Equals(ElemType data, ElemType e); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // ʼ˳ + InitList(&L); + + // ֵ + for(i = 1; i <= 10; i++) { + ListInsert(L, i, 2 * i); + } + + // ˳ + printf("L = "); + ListTraverse(L, PrintElem); + + printf("Ԫ \"12\" LеλΪ %d \n", Algo_2_13(L, 12)); + + return 0; +} + + +// ѰԪxLеλ +int Algo_2_13(LinkList L, ElemType x) { + // ֱӵIJҺ + return LocateElem(L, x, Equals); +} + +// жdata==eǷ +Status Equals(ElemType data, ElemType e) { + if(data == e) { + return TRUE; + } else { + return FALSE; + } +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.13/02.13.vcxproj b/VisualC++/ExerciseBook/02.13/02.13.vcxproj new file mode 100644 index 0000000..869ebad --- /dev/null +++ b/VisualC++/ExerciseBook/02.13/02.13.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {F9D880FE-6305-4B6A-AF56-0BE0C976D006} + My0213 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.13/02.13.vcxproj.filters b/VisualC++/ExerciseBook/02.13/02.13.vcxproj.filters new file mode 100644 index 0000000..8d2d82c --- /dev/null +++ b/VisualC++/ExerciseBook/02.13/02.13.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.13/02.13.vcxproj.user b/VisualC++/ExerciseBook/02.13/02.13.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.13/02.13.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.13/LinkList.c b/VisualC++/ExerciseBook/02.13/LinkList.c new file mode 100644 index 0000000..2e75ab5 --- /dev/null +++ b/VisualC++/ExerciseBook/02.13/LinkList.c @@ -0,0 +1,125 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * + * + * ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)) { + int i; + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 1; // iijֵΪ1Ԫصλ + p = L->next; // pijֵΪ1Ԫصָ + + while(p != NULL && !Compare(p->data, e)) { + i++; + p = p->next; + } + + if(p != NULL) { + return i; + } else { + return 0; + } +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.13/LinkList.h b/VisualC++/ExerciseBook/02.13/LinkList.h new file mode 100644 index 0000000..93b4faa --- /dev/null +++ b/VisualC++/ExerciseBook/02.13/LinkList.h @@ -0,0 +1,68 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * + * + * ׸eCompareϵԪλ + * Ԫأ򷵻0 + * + *ע + * ԪeCompareڶβ + */ +int LocateElem(LinkList L, ElemType e, Status(Compare)(ElemType, ElemType)); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.14/02.14.c b/VisualC++/ExerciseBook/02.14/02.14.c new file mode 100644 index 0000000..6660205 --- /dev/null +++ b/VisualC++/ExerciseBook/02.14/02.14.c @@ -0,0 +1,46 @@ +#include +#include "LinkList.h" //**02 Ա**// + +/* + * 2.14 + * + * ȡ˳Lijȡ + */ +int Algo_2_14(LinkList L); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // ʼ˳ + InitList(&L); + + // ֵ + for(i = 1; i <= 15; i++) { + ListInsert(L, i, 2 * i); + } + + // ˳ + printf("L = "); + ListTraverse(L, PrintElem); + + printf("LijΪ %d \n", Algo_2_14(L)); + + return 0; +} + + +// ȡ˳Lij +int Algo_2_14(LinkList L) { + // ֱӵļ + return ListLength(L); +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.14/02.14.vcxproj b/VisualC++/ExerciseBook/02.14/02.14.vcxproj new file mode 100644 index 0000000..db4e7f1 --- /dev/null +++ b/VisualC++/ExerciseBook/02.14/02.14.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {AA43C2F9-4ADF-41F2-89ED-47843643C4A3} + My0214 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.14/02.14.vcxproj.filters b/VisualC++/ExerciseBook/02.14/02.14.vcxproj.filters new file mode 100644 index 0000000..8121443 --- /dev/null +++ b/VisualC++/ExerciseBook/02.14/02.14.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.14/02.14.vcxproj.user b/VisualC++/ExerciseBook/02.14/02.14.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.14/02.14.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.14/LinkList.c b/VisualC++/ExerciseBook/02.14/LinkList.c new file mode 100644 index 0000000..de7f136 --- /dev/null +++ b/VisualC++/ExerciseBook/02.14/LinkList.c @@ -0,0 +1,118 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * + * + * ЧԪص + */ +int ListLength(LinkList L) { + LinkList p; + int i; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return 0; + } + + i = 0; + p = L->next; + + // н + while(p != NULL) { + i++; + p = p->next; + } + + return i; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.14/LinkList.h b/VisualC++/ExerciseBook/02.14/LinkList.h new file mode 100644 index 0000000..5911e04 --- /dev/null +++ b/VisualC++/ExerciseBook/02.14/LinkList.h @@ -0,0 +1,64 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * + * + * ЧԪص + */ +int ListLength(LinkList L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.15/02.15.c b/VisualC++/ExerciseBook/02.15/02.15.c new file mode 100644 index 0000000..4b62d2e --- /dev/null +++ b/VisualC++/ExerciseBook/02.15/02.15.c @@ -0,0 +1,90 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.15 + * + * hahb洢hcС + */ +Status Algo_2_15(LinkList* ha, LinkList* hb, LinkList* hc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList ha, hb, hc = NULL; + int i; + + // ʼ + InitList(&ha); + InitList(&hb); + + // ֵ + for(i = 1; i <= 5; i++) { + ListInsert(ha, i, 2 * i - 1); + ListInsert(hb, i, 2 * i); + } + + printf("ha = "); + ListTraverse(ha, PrintElem); + + printf("hb = "); + ListTraverse(hb, PrintElem); + + // hahb + Algo_2_15(&ha, &hb, &hc); + + printf("hc = "); + ListTraverse(hc, PrintElem); + + return 0; +} + + +// hahb洢hc +Status Algo_2_15(LinkList* ha, LinkList* hb, LinkList* hc) { + LinkList pa, pb; + + *hc = NULL; + + // ȷhahb + if(ha == NULL || *ha == NULL || hb == NULL || *hb == NULL) { + return ERROR; + } + + pa = *ha; + pb = *hb; + + // ΪЧʣҪȱͬIJ + while(pa->next != NULL && pb->next != NULL) { + pa = pa->next; + pb = pb->next; + } + + // haѾͷˣhbʣ + if(pa->next == NULL && pb->next != NULL) { + *hc = *ha; + pa->next = (*hb)->next; + free(*hb); + } + + // hbѾͷˣhaʣ࣬Ҳû + if(pb->next == NULL) { + *hc = *hb; + pb->next = (*ha)->next; + free(*ha); + } + + // ha/hbͷ + *ha = NULL; + *hb = NULL; + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.15/02.15.vcxproj b/VisualC++/ExerciseBook/02.15/02.15.vcxproj new file mode 100644 index 0000000..67cffc4 --- /dev/null +++ b/VisualC++/ExerciseBook/02.15/02.15.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {D14B8DD0-5CF1-4D80-8B2E-71E53670E7DA} + My0215 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.15/02.15.vcxproj.filters b/VisualC++/ExerciseBook/02.15/02.15.vcxproj.filters new file mode 100644 index 0000000..4c911df --- /dev/null +++ b/VisualC++/ExerciseBook/02.15/02.15.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.15/02.15.vcxproj.user b/VisualC++/ExerciseBook/02.15/02.15.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.15/02.15.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.15/LinkList.c b/VisualC++/ExerciseBook/02.15/LinkList.c new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.15/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.15/LinkList.h b/VisualC++/ExerciseBook/02.15/LinkList.h new file mode 100644 index 0000000..d3b16d7 --- /dev/null +++ b/VisualC++/ExerciseBook/02.15/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.c b/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.c new file mode 100644 index 0000000..c9bb25a --- /dev/null +++ b/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.c @@ -0,0 +1,296 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵûСͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * 2.16 + * + * ɾlaеiλlenԪأӵlbjλ֮ǰ + */ +Status Algo_2_16(LinkList* la, LinkList* lb, int i, int j, int len); + +/* + * 2.17 + * + * Ԫb뵽LiλϣiԪصλ򣬴1ʼ + */ +Status Algo_2_17(LinkList* L, int i, ElemType b); + +/* + * 2.18 + * + * ɾLĵi㣬iԪصλ򣬴1ʼ + */ +Status Algo_2_18(LinkList* L, int i); + +// ʼͷL +void InitList(LinkList* L); + +// ͷеԪ +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + int i; + LinkList la, lb; + + InitList(&la); + InitList(&lb); + + printf(" 2.17 ֤...\n"); + for(i = 1; i <= 10; i++) { + Algo_2_17(&la, i, 2 * i - 1); + Algo_2_17(&lb, i, 2 * i); + } + printf(" ͷ\n"); + printf(" la = "); + Output(la); + printf(" lb = "); + Output(lb); + PressEnterToContinue(); + + printf(" 2.16 ֤...\n"); + printf(" laдӵ25뵽lbĵ6֮ǰ...\n"); + Algo_2_16(&la, &lb, 2, 6, 5); + printf(" la = "); + Output(la); + printf(" lb = "); + Output(lb); + PressEnterToContinue(); + + printf(" 2.18 ֤...\n"); + printf(" ɾlb65...\n"); + for(i = 1; i <= 5; i++) { + Algo_2_18(&lb, 6); + } + printf(" ɾɺlb = "); + Output(lb); + + return 0; +} + + +// ɾlaеiλlenԪأӵlbjλ֮ǰ +Status Algo_2_16(LinkList* la, LinkList* lb, int i, int j, int len) { + LinkList p; // ָlaеi-1 + LinkList q; // ָlaеi+len-1 + LinkList r; // ָqĽ + LinkList s; // ָlbеj-1 + int k; + + if(i <= 0 || j <= 0 || len <= 0) { + return ERROR; + } + + // ȷlaнժ + if(la == NULL || *la == NULL) { + return ERROR; + } + + + // ȷpλ + k = 1; + p = *la; + + if(i == 1) { + p = NULL; + } else { + // laеi-1㣬ұ̴֤ + while(p->next != NULL && k < i - 1) { + ++k; + p = p->next; + } + + // δҵʵλ + if(p->next == NULL) { + return ERROR; + } + } + + + // ȷqλ + if(p == NULL) { + q = *la; + } else { + q = p->next; + } + k = i; + + while(q != NULL && k < i + len - 1) { + ++k; + q = q->next; + } + + if(q == NULL) { + return ERROR; + } + + // ȷrλ + r = q->next; + + + if(lb == NULL) { + return ERROR; + } + + // ȷsλ + k = 1; + s = *lb; + + // 뵽lbһλ֮ǰ + if(j == 1) { + q->next = *lb; + + if(p == NULL) { + *lb = *la; + *la = r; + } else { + *lb = p->next; + p->next = r; + } + } else { + // lbеj-1㣬ұ̴֤ + while(s->next != NULL && k < j - 1) { + ++k; + s = s->next; + } + + // δҵʵλ + if(s->next == NULL) { + return ERROR; + } + + q->next = s->next; + + if(p == NULL) { + *lb = *la; + *la = r; + } else { + s->next = p->next; + p->next = r; + } + } + + return OK; +} + +// Ԫb뵽Liλ +Status Algo_2_17(LinkList* L, int i, ElemType b) { + LinkList p, s; + int j; + + if(L == NULL) { + return ERROR; + } + + // i1ʼ + if(i <= 0) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = b; + + j = 1; + p = *L; + + // + if(i == 1) { + s->next = p; + *L = s; + } else { + // ҵi-1㣬ұ֤ + while(p != NULL && j < i - 1) { + ++j; + p = p->next; + } + + // δҵʵλ + if(p == NULL) { + return ERROR; + } + + s->next = p->next; + p->next = s; + } + + return OK; +} + +// ɾLĵi +Status Algo_2_18(LinkList* L, int i) { + LinkList p, q; + int j; + + // ȷнɾ + if(L == NULL || *L == NULL) { + return ERROR; + } + + // i1ʼ + if(i <= 0) { + return ERROR; + } + + j = 1; + p = *L; + + // + if(i == 1) { + *L = p->next; + free(p); + } else { + // ҵi-1㣬ұ̴֤ + while(p->next != NULL && j < i - 1) { + ++j; + p = p->next; + } + + // δҵʵλ + if(p->next == NULL) { + return ERROR; + } + + q = p->next; + p->next = q->next; + free(q); + } + + return OK; +} + +// ʼͷL +void InitList(LinkList* L) { + *L = NULL; +} + +// ͷеԪ +void Output(LinkList L) { + while(L != NULL) { + printf("%2d ", L->data); + L = L->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj b/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj new file mode 100644 index 0000000..84a918b --- /dev/null +++ b/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {F3E461F8-2545-4922-AF95-C0FAC35EDF8D} + My02160218 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj.filters b/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj.filters new file mode 100644 index 0000000..fbab577 --- /dev/null +++ b/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj.user b/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.16-02.18/02.16-02.18.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.c b/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.c new file mode 100644 index 0000000..c36a97f --- /dev/null +++ b/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.c @@ -0,0 +1,194 @@ +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.19һ + * + * ɾԱԪֵ(mink, maxk)֮Ľ㡣 + */ +Status Algo_2_19_1(LinkList L, int mink, int maxk); + +/* + * 2.19 + * + * ɾԱԪֵ(mink, maxk)֮Ľ㡣 + */ +Status Algo_2_19_2(LinkList L, int mink, int maxk); + +/* + * 2.20 + * + * ԷǵݼԱȥأظԪأһ + */ +Status Algo_2_20(LinkList L); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList L; + int mink1, mink2, maxk1, maxk2, i; + int a[] = {1, 2, 2, 3, 3, 3, 4, 4, 5, 6, 6, 7, 7, 8, 9, 9, 10, 11, 12, 12}; + + mink1 = 2; + maxk1 = 4; + + mink2 = 5; + maxk2 = 8; + + InitList(&L); + + for(i = 1; i <= 20; i++) { + ListInsert(L, i, a[i - 1]); + } + + printf(" L = "); + ListTraverse(L, PrintElem); + + printf(" 2.19 ֤...\n"); + printf(" ɾ (%d, %d) ΧڵԪ֮", mink1, maxk1); + Algo_2_19_1(L, mink1, maxk1); + printf("L = "); + ListTraverse(L, PrintElem); + + printf(" ɾ (%d, %d) ΧڵԪ֮", mink2, maxk2); + Algo_2_19_2(L, mink2, maxk2); + printf("L = "); + ListTraverse(L, PrintElem); + + printf(" 2.20 ֤...\n"); + printf(" Էǵݼȥ֮"); + Algo_2_20(L); + printf("L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// ɾԱԪֵ(mink, maxk)֮Ľ +Status Algo_2_19_1(LinkList L, int mink, int maxk) { + LinkList p, q; + int flag; // Ч + + // ȷ + if(L == NULL) { + return ERROR; + } + + // Χ趨 + if(mink >= maxk) { + return ERROR; + } + + // Ϊգֱӷ + if(L->next == NULL) { + return OK; + } + + p = L; // ָͷ + flag = 0; // δ(mink, maxk)ΧڵԪ + + while(p->next != NULL) { + q = p->next; + + // ҪɾĽ + if(q->data > mink && q->data < maxk) { + // (mink, maxk)ΧڵԪ + flag = 1; + p->next = q->next; + free(q); + } else { + // ˵ʣԪؾ>=maxkٱ + if(flag == 1) { + break; + } + p = q; + } + } + + return OK; +} + +// ɾԱԪֵ(mink, maxk)֮Ľ +Status Algo_2_19_2(LinkList L, int mink, int maxk) { + LinkList p, q; + + // ȷ + if(L == NULL) { + return ERROR; + } + + // Χ趨 + if(mink >= maxk) { + return ERROR; + } + + // Ϊգֱӷ + if(L->next == NULL) { + return OK; + } + + p = L; // ָͷ + + // + while(p->next != NULL && p->next->data <= mink) { + p = p->next; + } + + // + if(p->next == NULL) { + return OK; + } + + // ޣɾ(mink, maxk)֮IJ + while(p->next != NULL && p->next->data < maxk) { + q = p->next; + p->next = q->next; + free(q); + } + + return OK; +} + +// ԷǵݼԱȥأظԪأһ +Status Algo_2_20(LinkList L) { + LinkList p, q; + + // ȷ + if(L == NULL) { + return ERROR; + } + + // Ϊգֱӷ + if(L->next == NULL) { + return OK; + } + + // ָ1Ԫ + p = L->next; + + while(p->next != NULL) { + q = p->next; + + // ظԪأҪɾһ + if(p->data == q->data) { + p->next = q->next; + free(q); + + // DzͬԪأpǰһ + } else { + p = q; + } + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj b/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj new file mode 100644 index 0000000..9216403 --- /dev/null +++ b/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {A0DE4DB7-5E42-412A-896E-8CD17902142C} + My02190220 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj.filters b/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj.filters new file mode 100644 index 0000000..ece2ecd --- /dev/null +++ b/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj.user b/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.19-02.20/02.19-02.20.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.19-02.20/LinkList.c b/VisualC++/ExerciseBook/02.19-02.20/LinkList.c new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.19-02.20/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.19-02.20/LinkList.h b/VisualC++/ExerciseBook/02.19-02.20/LinkList.h new file mode 100644 index 0000000..d3b16d7 --- /dev/null +++ b/VisualC++/ExerciseBook/02.19-02.20/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.21/02.21.c b/VisualC++/ExerciseBook/02.21/02.21.c new file mode 100644 index 0000000..ee027cc --- /dev/null +++ b/VisualC++/ExerciseBook/02.21/02.21.c @@ -0,0 +1,63 @@ +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.21 + * + * ˳á + */ +Status Algo_2_21(SqList L); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList L; + int i; + + // ׼ + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(&L, i, i); + } + + printf("˳L = "); + ListTraverse(L, PrintElem); + + Algo_2_21(L); + + printf("ãL = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// ˳ +Status Algo_2_21(SqList L) { + int i, mid; + ElemType tmp; + + // ȷ˳ + if(L.elem == NULL) { + return ERROR; + } + + // ֻҪǰһԪؼ + mid = L.length / 2; + + for(i = 1; i <= mid; i++) { + tmp = L.elem[i - 1]; + L.elem[i - 1] = L.elem[L.length - i]; + L.elem[L.length - i] = tmp; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/VisualC++/ExerciseBook/02.21/02.21.vcxproj b/VisualC++/ExerciseBook/02.21/02.21.vcxproj new file mode 100644 index 0000000..f60ee11 --- /dev/null +++ b/VisualC++/ExerciseBook/02.21/02.21.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {2DC8B8E0-D90F-40F6-B0F0-D951DDCA408E} + My0221 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.21/02.21.vcxproj.filters b/VisualC++/ExerciseBook/02.21/02.21.vcxproj.filters new file mode 100644 index 0000000..8c90808 --- /dev/null +++ b/VisualC++/ExerciseBook/02.21/02.21.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.21/02.21.vcxproj.user b/VisualC++/ExerciseBook/02.21/02.21.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.21/02.21.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.21/SqList.c b/VisualC++/ExerciseBook/02.21/SqList.c new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/VisualC++/ExerciseBook/02.21/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.21/SqList.h b/VisualC++/ExerciseBook/02.21/SqList.h new file mode 100644 index 0000000..25b1d92 --- /dev/null +++ b/VisualC++/ExerciseBook/02.21/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.22/02.22.c b/VisualC++/ExerciseBook/02.22/02.22.c new file mode 100644 index 0000000..8a8ca81 --- /dev/null +++ b/VisualC++/ExerciseBook/02.22/02.22.c @@ -0,0 +1,62 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.22 + * + * á + */ +Status Algo_2_22(LinkList L); + +// ԺӡԪ +void PrintElem(ElemType e); + +int main(int argc, char* argv[]) { + LinkList L; + int i; + + // ׼ + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(L, i, i); + } + + printf("˳L = "); + ListTraverse(L, PrintElem); + + Algo_2_22(L); + + printf("ãL = "); + ListTraverse(L, PrintElem); + + return 0; +} + +// +Status Algo_2_22(LinkList L) { + LinkList p, q; + + // ȷ + if(L==NULL) { + return ERROR; + } + + p = L->next; + L->next = NULL; + + // ͷ巨 + while(p!=NULL){ + q = p->next; + p->next = L->next; + L->next = p; + p = q; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/VisualC++/ExerciseBook/02.22/02.22.vcxproj b/VisualC++/ExerciseBook/02.22/02.22.vcxproj new file mode 100644 index 0000000..3c0650a --- /dev/null +++ b/VisualC++/ExerciseBook/02.22/02.22.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {479F8705-7B4A-413F-939D-5A68C82C7E6A} + My0222 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.22/02.22.vcxproj.filters b/VisualC++/ExerciseBook/02.22/02.22.vcxproj.filters new file mode 100644 index 0000000..c4c76d2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.22/02.22.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.22/02.22.vcxproj.user b/VisualC++/ExerciseBook/02.22/02.22.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.22/02.22.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.22/LinkList.c b/VisualC++/ExerciseBook/02.22/LinkList.c new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.22/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.22/LinkList.h b/VisualC++/ExerciseBook/02.22/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/VisualC++/ExerciseBook/02.22/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.23/02.23.c b/VisualC++/ExerciseBook/02.23/02.23.c new file mode 100644 index 0000000..96d6bc4 --- /dev/null +++ b/VisualC++/ExerciseBook/02.23/02.23.c @@ -0,0 +1,147 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.23һLa뵽Lb + * + * ϲ + * ϲɺ󣬽LaLbÿգ١ + */ +Status Algo_2_23_1(LinkList La, LinkList Lb, LinkList* Lc); + +/* + * 2.23LaLbеԪؽ뵽Lc + * + * ϲ + * ϲɺ󣬽LaLbÿգ١ + */ +Status Algo_2_23_2(LinkList La, LinkList Lb, LinkList* Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 5; i++) { + ListInsert(La, i, 2 * i - 1); + ListInsert(Lb, i, 2 * i); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // ϲ +// Algo_2_23_1(La, Lb, &Lc); + Algo_2_23_2(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +// ϲ +Status Algo_2_23_1(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList p, pb; + + // ȷLaLb + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + pb = Lb; + + while(La->next != NULL && pb->next != NULL) { + // Laժ½ + p = La->next; + La->next = p->next; + + // LaժµĽ뵽Lb + p->next = pb->next; + pb->next = p; + + // ǰԭLbһλ + pb = pb->next->next; + } + + // Laʣ࣬ҪȫӵLbβ + if(pb->next == NULL && La->next != NULL) { + pb->next = La->next; + La->next = NULL; + } + + InitList(Lc); + + (*Lc)->next = Lb->next; + Lb->next = NULL; + + return OK; +} + +// ϲ +Status Algo_2_23_2(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList p, pc; + int flag; // ָӲLaеԪػDzLbеԪ + + // ȷLaLb + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + InitList(Lc); + + flag = 0; + pc = *Lc; + + while(La->next!=NULL && Lb->next!=NULL){ + // ҪLaеԪ + if(flag==0) { + // ժLaеԪ + p = La->next; + La->next = p->next; + + flag = 1; + } else { + // ժLaеԪ + p = Lb->next; + Lb->next = p->next; + + flag = 0; + } + + // ժµԪز뵽Lc + pc->next = p; + pc = pc->next; + } + + // Lbʣ + if(La->next==NULL) { + // ժLbеԪ + p = Lb->next; + Lb->next = NULL; + pc->next = p; + + // Laʣ + } else { + // ժLaеԪ + p = La->next; + La->next = NULL; + pc->next = p; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.23/02.23.vcxproj b/VisualC++/ExerciseBook/02.23/02.23.vcxproj new file mode 100644 index 0000000..3c887d5 --- /dev/null +++ b/VisualC++/ExerciseBook/02.23/02.23.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {9B913BF8-0766-462F-B982-8D5020815B34} + My0223 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.23/02.23.vcxproj.filters b/VisualC++/ExerciseBook/02.23/02.23.vcxproj.filters new file mode 100644 index 0000000..45a5825 --- /dev/null +++ b/VisualC++/ExerciseBook/02.23/02.23.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.23/02.23.vcxproj.user b/VisualC++/ExerciseBook/02.23/02.23.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.23/02.23.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.23/LinkList.c b/VisualC++/ExerciseBook/02.23/LinkList.c new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.23/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.23/LinkList.h b/VisualC++/ExerciseBook/02.23/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/VisualC++/ExerciseBook/02.23/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.24/02.24.c b/VisualC++/ExerciseBook/02.24/02.24.c new file mode 100644 index 0000000..dcecc52 --- /dev/null +++ b/VisualC++/ExerciseBook/02.24/02.24.c @@ -0,0 +1,94 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.24 + * + * 鲢Ϊһݼ + * 鲢ǣժLaLbеԪأʹͷ巨뵽Lc + * 鲢ɺ󣬽ԭÿգ١ + */ +Status Algo_2_24(LinkList La, LinkList Lb, LinkList* Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 5; i++) { + ListInsert(La, i, 2 * i - 1); + ListInsert(Lb, i, 2 * i); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 鲢 + Algo_2_24(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +// 鲢Ϊһݼ +Status Algo_2_24(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList pa, pb; + + // ȷLaLb + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + InitList(Lc); + + // LaLb + while(La->next!=NULL && Lb->next!=NULL){ + pa = La->next; + pb = Lb->next; + + // ժLaLbнСԪ + if(pa->data<=pb->data) { + La->next = pa->next; + pa->next = (*Lc)->next; + (*Lc)->next = pa; + } else { + Lb->next = pb->next; + pb->next = (*Lc)->next; + (*Lc)->next = pb; + } + } + + // Laʣ࣬LaʣԪز뵽Lc + while(La->next!=NULL){ + pa = La->next; + La->next = pa->next; + pa->next = (*Lc)->next; + (*Lc)->next = pa; + } + + // Lbʣ࣬LbʣԪز뵽Lc + while(Lb->next!=NULL){ + pb = Lb->next; + Lb->next = pb->next; + pb->next = (*Lc)->next; + (*Lc)->next = pb; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.24/02.24.vcxproj b/VisualC++/ExerciseBook/02.24/02.24.vcxproj new file mode 100644 index 0000000..0cd7459 --- /dev/null +++ b/VisualC++/ExerciseBook/02.24/02.24.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {69D091DF-26ED-4578-91BB-328FE9BAAF2D} + My0224 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.24/02.24.vcxproj.filters b/VisualC++/ExerciseBook/02.24/02.24.vcxproj.filters new file mode 100644 index 0000000..d5dbd17 --- /dev/null +++ b/VisualC++/ExerciseBook/02.24/02.24.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.24/02.24.vcxproj.user b/VisualC++/ExerciseBook/02.24/02.24.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.24/02.24.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.24/LinkList.c b/VisualC++/ExerciseBook/02.24/LinkList.c new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.24/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.24/LinkList.h b/VisualC++/ExerciseBook/02.24/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/VisualC++/ExerciseBook/02.24/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.25/02.25.c b/VisualC++/ExerciseBook/02.25/02.25.c new file mode 100644 index 0000000..9f0a5df --- /dev/null +++ b/VisualC++/ExerciseBook/02.25/02.25.c @@ -0,0 +1,82 @@ +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.25 + * + * 󽻼C=AB + */ +Status Algo_2_25(SqList La, SqList Lb, SqList* Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 󽻼 + Algo_2_25(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 󽻼C=AB +Status Algo_2_25(SqList La, SqList Lb, SqList* Lc) { + int i, j, k; + + // ȷLaLb + if(La.elem == NULL || Lb.elem == NULL) { + return ERROR; + } + + InitList(Lc); + + i = j = 0; // LaLb + k = 0; // Lc + + // ֻLaLbĹͬ־ + while(i < La.length && j < Lb.length) { + if(La.elem[i] < Lb.elem[j]) { + i++; + } else if(La.elem[i] > Lb.elem[j]) { + j++; + // LaLbеԪ + } else { + // LcԪؿظ + ListInsert(Lc, k+1, La.elem[i]); + k++; + i++; + j++; + } + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.25/02.25.vcxproj b/VisualC++/ExerciseBook/02.25/02.25.vcxproj new file mode 100644 index 0000000..7f8fac2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.25/02.25.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {6694823F-5439-4003-B718-84A60147E5F3} + My0225 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.25/02.25.vcxproj.filters b/VisualC++/ExerciseBook/02.25/02.25.vcxproj.filters new file mode 100644 index 0000000..53660a3 --- /dev/null +++ b/VisualC++/ExerciseBook/02.25/02.25.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.25/02.25.vcxproj.user b/VisualC++/ExerciseBook/02.25/02.25.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.25/02.25.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.25/SqList.c b/VisualC++/ExerciseBook/02.25/SqList.c new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/VisualC++/ExerciseBook/02.25/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.25/SqList.h b/VisualC++/ExerciseBook/02.25/SqList.h new file mode 100644 index 0000000..a7b6e55 --- /dev/null +++ b/VisualC++/ExerciseBook/02.25/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.26/02.26.c b/VisualC++/ExerciseBook/02.26/02.26.c new file mode 100644 index 0000000..f9f4f64 --- /dev/null +++ b/VisualC++/ExerciseBook/02.26/02.26.c @@ -0,0 +1,89 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.26 + * + * 󽻼C=AB + */ +Status Algo_2_26(LinkList La, LinkList Lb, LinkList* Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 󽻼 + Algo_2_26(La, Lb, &Lc); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 󽻼C=AB +Status Algo_2_26(LinkList La, LinkList Lb, LinkList* Lc) { + LinkList pa, pb, pc, s; + + // ȷLaLb + if(La == NULL || Lb == NULL) { + return ERROR; + } + + InitList(Lc); + + pa = La->next; + pb = Lb->next; + pc = *Lc; + + // ֻLaLbĹͬ־ + while(pa != NULL && pb != NULL) { + if(pa->data < pb->data) { + pa = pa->next; + } else if(pa->data > pb->data) { + pb = pb->next; + } else { + // LcԪؿظ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = pa->data; + s->next = NULL; + + pc->next = s; + + pc = pc->next; + + pa = pa->next; + pb = pb->next; + } + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.26/02.26.vcxproj b/VisualC++/ExerciseBook/02.26/02.26.vcxproj new file mode 100644 index 0000000..98a2fff --- /dev/null +++ b/VisualC++/ExerciseBook/02.26/02.26.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {4F184A85-5203-4DED-BFA9-0F2799F9AF12} + My0226 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.26/02.26.vcxproj.filters b/VisualC++/ExerciseBook/02.26/02.26.vcxproj.filters new file mode 100644 index 0000000..15b9610 --- /dev/null +++ b/VisualC++/ExerciseBook/02.26/02.26.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.26/02.26.vcxproj.user b/VisualC++/ExerciseBook/02.26/02.26.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.26/02.26.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.26/LinkList.c b/VisualC++/ExerciseBook/02.26/LinkList.c new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.26/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.26/LinkList.h b/VisualC++/ExerciseBook/02.26/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/VisualC++/ExerciseBook/02.26/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.27/02.27.c b/VisualC++/ExerciseBook/02.27/02.27.c new file mode 100644 index 0000000..f575a69 --- /dev/null +++ b/VisualC++/ExerciseBook/02.27/02.27.c @@ -0,0 +1,96 @@ +#include +#include "SqList.h" //**02 Ա**// + +/* + * 2.27 + * + * 󽻼C=AB + * CеԪظCAԭеĿռ䣬A١ + */ +SqList Algo_2_27(SqList* La, SqList Lb); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 󽻼 + Lc = Algo_2_27(&La, Lb); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + +// 󽻼C=AB +SqList Algo_2_27(SqList* La, SqList Lb) { + int i, j, k; + SqList Lc; + + // ȷLaLb + if((*La).elem == NULL || Lb.elem == NULL) { + Lc.elem = NULL; + Lc.length = 0; + Lc.listsize = 0; + return Lc; + } + + i = j = 0; // LaLb + k = 0; // Lc + + Lc.elem = (*La).elem; + Lc.listsize = La->listsize; + + // ֻLaLbĹͬ־ + while(i < (*La).length && j < Lb.length) { + if((*La).elem[i] < Lb.elem[j]) { + i++; + } else if((*La).elem[i] > Lb.elem[j]) { + j++; + // LaLbеԪ + } else { + // ȷLcеԪزظ + if(k == 0 || Lc.elem[k - 1] != (*La).elem[i]) { + Lc.elem[k] = (*La).elem[i]; + k++; + } + + i++; + j++; + } + } + + // Aռ佻Cʹ + (*La).elem = NULL; + (*La).length = 0; + (*La).listsize = 0; + + Lc.length = k; + + return Lc; +} + +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.27/02.27.vcxproj b/VisualC++/ExerciseBook/02.27/02.27.vcxproj new file mode 100644 index 0000000..0efa42c --- /dev/null +++ b/VisualC++/ExerciseBook/02.27/02.27.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {94F9896A-E87A-47EB-B598-C1E60F16F9A7} + My0227 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.27/02.27.vcxproj.filters b/VisualC++/ExerciseBook/02.27/02.27.vcxproj.filters new file mode 100644 index 0000000..ffec16e --- /dev/null +++ b/VisualC++/ExerciseBook/02.27/02.27.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.27/02.27.vcxproj.user b/VisualC++/ExerciseBook/02.27/02.27.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.27/02.27.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.27/SqList.c b/VisualC++/ExerciseBook/02.27/SqList.c new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/VisualC++/ExerciseBook/02.27/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.27/SqList.h b/VisualC++/ExerciseBook/02.27/SqList.h new file mode 100644 index 0000000..a7b6e55 --- /dev/null +++ b/VisualC++/ExerciseBook/02.27/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.28/02.28.c b/VisualC++/ExerciseBook/02.28/02.28.c new file mode 100644 index 0000000..3300e69 --- /dev/null +++ b/VisualC++/ExerciseBook/02.28/02.28.c @@ -0,0 +1,92 @@ +#include +#include "LinkList.h" //**02 Ա**// + +/* + * 2.28 + * + * 󽻼C=AB + * CеԪظCAԭеĿռ䣬A١ + */ +LinkList Algo_2_28(LinkList* La, LinkList Lb); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int b[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + } + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + + // 󽻼 + Lc = Algo_2_28(&La, Lb); + + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + return 0; +} + + +LinkList Algo_2_28(LinkList* La, LinkList Lb) { + LinkList Lc; + LinkList pa, pb, pc, s; + + // ȷLaLb + if(La == NULL || *La == NULL || Lb == NULL) { + return NULL; + } + + pa = (*La)->next; + pb = Lb->next; + + Lc = *La; + Lc->next = NULL; + pc = Lc; + + // ֻLaLbĹͬ־ + while(pa != NULL && pb != NULL) { + if(pa->data < pb->data) { + s = pa; + pa = pa->next; + free(s); + } else if(pa->data > pb->data) { + pb = pb->next; + } else { + // ȷLcеԪزظ + if(pc == Lc || pc->data != pa->data) { + pc->next = pa; + pc = pc->next; + } + + pa = pa->next; + pb = pb->next; + } + } + + pc->next = NULL; + + + *La = NULL; + + return Lc; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.28/02.28.vcxproj b/VisualC++/ExerciseBook/02.28/02.28.vcxproj new file mode 100644 index 0000000..3c990ad --- /dev/null +++ b/VisualC++/ExerciseBook/02.28/02.28.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {CDC6D120-D68F-47B6-A9E7-A5A461133DFA} + My0228 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.28/02.28.vcxproj.filters b/VisualC++/ExerciseBook/02.28/02.28.vcxproj.filters new file mode 100644 index 0000000..aa2ef20 --- /dev/null +++ b/VisualC++/ExerciseBook/02.28/02.28.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.28/02.28.vcxproj.user b/VisualC++/ExerciseBook/02.28/02.28.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.28/02.28.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.28/LinkList.c b/VisualC++/ExerciseBook/02.28/LinkList.c new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.28/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.28/LinkList.h b/VisualC++/ExerciseBook/02.28/LinkList.h new file mode 100644 index 0000000..3b4e4f6 --- /dev/null +++ b/VisualC++/ExerciseBook/02.28/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.29/02.29.c b/VisualC++/ExerciseBook/02.29/02.29.c new file mode 100644 index 0000000..b132464 --- /dev/null +++ b/VisualC++/ExerciseBook/02.29/02.29.c @@ -0,0 +1,104 @@ +#include +#include "Status.h" //**01 **// +#include "SqList.h" //**02 Ա**// + +/* + * 2.29 + * + * A=A-BC + */ +Status Algo_2_29(SqList* La, SqList Lb, SqList Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + SqList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int b[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int c[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + InitList(&Lc); + for(i = 1; i <= 10; i++) { + ListInsert(&La, i, a[i - 1]); + ListInsert(&Lb, i, b[i - 1]); + ListInsert(&Lc, i, c[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + + // + Algo_2_29(&La, Lb, Lc); + + printf("La = La-LbLc = "); + ListTraverse(La, PrintElem); + + return 0; +} + +// A=A-BC +Status Algo_2_29(SqList* La, SqList Lb, SqList Lc) { + int i, j, k, count; + + if(La==NULL || (*La).elem==NULL || Lb.elem==NULL || Lc.elem==NULL) { + return ERROR; + } + + i = j = k = 0; + count = 0; + + // ȡBCĽȻAɾ + while(i < (*La).length && j < Lb.length && k < Lc.length) { + if(Lb.elem[j] < Lc.elem[k]) { + j++; + } else if(Lb.elem[j] > Lc.elem[k]) { + k++; + } else { + // AвҽԪ + while(i < (*La).length && (*La).elem[i] < Lb.elem[j]) { + (*La).elem[count] = (*La).elem[i]; + count++; + i++; + } + + // Ԫ + while(i < (*La).length && (*La).elem[i] == Lb.elem[j]) { + i++; + } + + // Aûб + if(i < (*La).length) { + j++; + k++; + } + } + } + + // ʣԪطŵʵλ + while(i < (*La).length) { + (*La).elem[count] = (*La).elem[i]; + count++; + i++; + } + + (*La).length = count; + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/VisualC++/ExerciseBook/02.29/02.29.vcxproj b/VisualC++/ExerciseBook/02.29/02.29.vcxproj new file mode 100644 index 0000000..16b9359 --- /dev/null +++ b/VisualC++/ExerciseBook/02.29/02.29.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {D051583F-72E8-4F2E-A5FA-AAEED0793C86} + My0229 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.29/02.29.vcxproj.filters b/VisualC++/ExerciseBook/02.29/02.29.vcxproj.filters new file mode 100644 index 0000000..d92f0fb --- /dev/null +++ b/VisualC++/ExerciseBook/02.29/02.29.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.29/02.29.vcxproj.user b/VisualC++/ExerciseBook/02.29/02.29.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.29/02.29.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.29/SqList.c b/VisualC++/ExerciseBook/02.29/SqList.c new file mode 100644 index 0000000..3ab2fda --- /dev/null +++ b/VisualC++/ExerciseBook/02.29/SqList.c @@ -0,0 +1,99 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#include "SqList.h" + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L) { + // ָڴ棬ʧܣ򷵻NULL + (*L).elem = (ElemType*) malloc(LIST_INIT_SIZE * sizeof(ElemType)); + if((*L).elem == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + (*L).length = 0; // ʼ˳Ϊ0 + (*L).listsize = LIST_INIT_SIZE; // ˳ʼڴ + + return OK; // ʼɹ +} + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e) { + ElemType* newbase; + ElemType* p, * q; + + // ȷ˳ṹ + if(L == NULL || (*L).elem == NULL) { + return ERROR; + } + + // iֵԽ + if(i < 1 || i > (*L).length + 1) { + return ERROR; + } + + // 洢ռ¿ռ + if((*L).length >= (*L).listsize) { + // пռ + newbase = (ElemType*) realloc((*L).elem, ((*L).listsize + LISTINCREMENT) * sizeof(ElemType)); + if(newbase == NULL) { + // 洢ڴʧ + exit(OVERFLOW); + } + + // »ַ + (*L).elem = newbase; + // Ĵ洢ռ + (*L).listsize += LISTINCREMENT; + } + + // qΪλ + q = &(*L).elem[i - 1]; + + // 1.Ԫأڳλ + for(p = &(*L).elem[(*L).length - 1]; p >= q; --p) { + *(p + 1) = *p; + } + + // 2.e + *q = e; + + // 3.1 + (*L).length++; + + return OK; +} + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void(Visit)(ElemType)) { + int i; + + for(i = 0; i < L.length; i++) { + Visit(L.elem[i]); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.29/SqList.h b/VisualC++/ExerciseBook/02.29/SqList.h new file mode 100644 index 0000000..a7b6e55 --- /dev/null +++ b/VisualC++/ExerciseBook/02.29/SqList.h @@ -0,0 +1,61 @@ +/*============================= + * Ա˳洢ṹ˳ + * + * 㷨: 2.32.42.52.6 + =============================*/ + +#ifndef SEQUENCELIST_H +#define SEQUENCELIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* 궨 */ +#define LIST_INIT_SIZE 100 // ˳洢ռijʼ +#define LISTINCREMENT 10 // ˳洢ռķ + +/* ˳ԪͶ */ +typedef int ElemType; + +/* + * ˳ṹ + * + * עelemʹǰҪΪڴ棬Ԫشelem[0]ʼ洢 + */ +typedef struct { + ElemType* elem; // ˳洢ռĻַָ˳ռڴʼλã + int length; // ǰ˳ȣԪأ + int listsize; // ǰĴ洢Դ洢Ԫأ +} SqList; + + +/* + * 㷨2.3 + * + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(SqList* L); + +/* + * 㷨2.4 + * + * + * + * ˳iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(SqList* L, int i, ElemType e); + +/* + * + * + * visit˳L + */ +void ListTraverse(SqList L, void (Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.30/02.30.c b/VisualC++/ExerciseBook/02.30/02.30.c new file mode 100644 index 0000000..b4281bf --- /dev/null +++ b/VisualC++/ExerciseBook/02.30/02.30.c @@ -0,0 +1,97 @@ +#include +#include "Status.h" //**01 **// +#include "LinkList.h" //**02 Ա**// + +/* + * 2.30 + * + * A=A-BC + */ +Status Algo_2_30(LinkList La, LinkList Lb, LinkList Lc); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + LinkList La, Lb, Lc; + int i; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int b[10] = {1, 2, 2, 3, 4, 4, 9, 9, 10, 12}; + int c[10] = {1, 1, 2, 2, 3, 3, 4, 5, 12, 13}; + + // ׼ + InitList(&La); + InitList(&Lb); + InitList(&Lc); + for(i = 1; i <= 10; i++) { + ListInsert(La, i, a[i - 1]); + ListInsert(Lb, i, b[i - 1]); + ListInsert(Lc, i, c[i - 1]); + } + + printf("La = "); + ListTraverse(La, PrintElem); + printf("Lb = "); + ListTraverse(Lb, PrintElem); + printf("Lc = "); + ListTraverse(Lc, PrintElem); + + // + Algo_2_30(La, Lb, Lc); + + printf("La = La-LbLc = "); + ListTraverse(La, PrintElem); + + return 0; +} + +// A=A-BC +Status Algo_2_30(LinkList La, LinkList Lb, LinkList Lc) { + LinkList pa, pb, pc, p; + + if(La == NULL || Lb == NULL || Lc == NULL) { + return ERROR; + } + + pa = La->next; + pb = Lb->next; + pc = Lc->next; + p = La; + + // ȡBCĽȻAɾ + while(pa != NULL && pb != NULL && pc != NULL) { + if(pb->data < pc->data) { + pb = pb->next; + } else if(pb->data > pc->data) { + pc = pc->next; + } else { + // AвҽԪ + while(pa != NULL && pa->data < pb->data) { + p = pa; + pa = pa->next; + } + + // Ԫ + while(pa != NULL && pa->data == pb->data) { + p->next = pa->next; + free(pa); + pa = p->next; + } + + // Aûб + if(pa != NULL ) { + pb = pb->next; + pc = pc->next; + } + } + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%2d ", e); +} diff --git a/VisualC++/ExerciseBook/02.30/02.30.vcxproj b/VisualC++/ExerciseBook/02.30/02.30.vcxproj new file mode 100644 index 0000000..111bbea --- /dev/null +++ b/VisualC++/ExerciseBook/02.30/02.30.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {267890F4-9F75-4F76-972B-9D621336FAB8} + My0230 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.30/02.30.vcxproj.filters b/VisualC++/ExerciseBook/02.30/02.30.vcxproj.filters new file mode 100644 index 0000000..20a393a --- /dev/null +++ b/VisualC++/ExerciseBook/02.30/02.30.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.30/02.30.vcxproj.user b/VisualC++/ExerciseBook/02.30/02.30.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.30/02.30.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.30/LinkList.c b/VisualC++/ExerciseBook/02.30/LinkList.c new file mode 100644 index 0000000..24a25e2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.30/LinkList.c @@ -0,0 +1,92 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#include "LinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ֻdzʼһͷ㡣 + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L) { + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + (*L)->next = NULL; + + return OK; +} + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e) { + LinkList p, s; + int j; + + // ȷ + if(L == NULL) { + return ERROR; + } + + p = L; + j = 0; + + // Ѱҵi-1㣬ұ֤ý㱾ΪNULL + while(p != NULL && j < i - 1) { + p = p->next; + ++j; + } + + // ͷˣiֵϹ(i<=0)˵ûҵϺĿĽ + if(p == NULL || j > i - 1) { + return ERROR; + } + + // ½ + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + s->next = p->next; + p->next = s; + + return OK; +} + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)) { + LinkList p; + + // ȷҲΪձ + if(L == NULL || L->next == NULL) { + return; + } + + p = L->next; + + while(p != NULL) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.30/LinkList.h b/VisualC++/ExerciseBook/02.30/LinkList.h new file mode 100644 index 0000000..c61d71a --- /dev/null +++ b/VisualC++/ExerciseBook/02.30/LinkList.h @@ -0,0 +1,57 @@ +/*=============================== + * Աʽ洢ṹ + * + * 㷨: 2.82.92.102.11 + ================================*/ + +#ifndef LINKEDLIST_H +#define LINKEDLIST_H + +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +/* + * ṹ + * + * עĵͷ + */ +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(LinkList* L); + +/* + * 㷨2.9 + * + * + * + * iλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(LinkList L, int i, ElemType e); + +/* + * + * + * visitL + */ +void ListTraverse(LinkList L, void(Visit)(ElemType)); + +#endif diff --git a/VisualC++/ExerciseBook/02.31/02.31.c b/VisualC++/ExerciseBook/02.31/02.31.c new file mode 100644 index 0000000..0278340 --- /dev/null +++ b/VisualC++/ExerciseBook/02.31/02.31.c @@ -0,0 +1,136 @@ +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +// ѭṹͷ㣩 +typedef struct LNode { + ElemType data; // ݽ + struct LNode* next; // ָһָ +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * 2.31 + * + * ɾsǰ + */ +Status Algo_2_31(LinkList* L, LinkList s); + +// ָݴޡͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n); + +// L +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L, s; + + int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + // ׼ + CreatList(&L, a, 10); + printf("L = "); + Output(L); + + s = L->next->next->next->next; + + printf("ɾ %d ǰ...\n", s->data); + Algo_2_31(&L, s); + + printf("L = "); + Output(L); + + return 0; +} + +// ɾsǰ +Status Algo_2_31(LinkList* L, LinkList s) { + LinkList p, pre; + + if(L == NULL || *L == NULL) { + return ERROR; + } + + // ǰ + if(s == NULL || s->next == s) { + return ERROR; + } + + p = s; + + // ʹp->nextָsǰ + while(p->next->next != s) { + p = p->next; + } + + // sǰ + pre = p->next; + + // ɾǰ + p->next = pre->next; + free(pre); + + // ǰ + if(pre == *L) { + *L = s; + } + + return OK; +} + +// ָݴͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + *L = NULL; + + for(i = 0; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + + s->data = elems[i]; + + if(i == 0) { + *L = s; + s->next = *L; // ѭ + r = *L; + } else { + s->next = r->next; + r->next = s; + r = r->next; + } + } + + return OK; +} + +// L +void Output(LinkList L) { + LinkList p; + + if(L == NULL) { + return; + } + + printf("%2d ", L->data); + + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.31/02.31.vcxproj b/VisualC++/ExerciseBook/02.31/02.31.vcxproj new file mode 100644 index 0000000..8704a6b --- /dev/null +++ b/VisualC++/ExerciseBook/02.31/02.31.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {C02C7FFC-6B3F-42AD-85A9-9E085BF0168C} + My0231 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.31/02.31.vcxproj.filters b/VisualC++/ExerciseBook/02.31/02.31.vcxproj.filters new file mode 100644 index 0000000..d317abf --- /dev/null +++ b/VisualC++/ExerciseBook/02.31/02.31.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.31/02.31.vcxproj.user b/VisualC++/ExerciseBook/02.31/02.31.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.31/02.31.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.32/02.32.c b/VisualC++/ExerciseBook/02.32/02.32.c new file mode 100644 index 0000000..55dc484 --- /dev/null +++ b/VisualC++/ExerciseBook/02.32/02.32.c @@ -0,0 +1,134 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef int ElemType; + +// ˫ѭṹ +typedef struct LNode { + ElemType data; + struct LNode* next; + struct LNode* pre; +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * 2.32 + * + * ѭ޸Ϊ˫ѭ + */ +Status Algo_2_32(LinkList L); + +// ָݴСͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n); + +// +void Output(LinkList L); + +// +void OutputReverse(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L; + ElemType a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + // ׼ݣ + CreatList(&L, a, 10); + printf("L = "); + Output(L); + + // Ϊ˫ + Algo_2_32(L); + + // + printf("L = "); + OutputReverse(L); + + return 0; +} + + +// ѭ޸Ϊ˫ѭ +Status Algo_2_32(LinkList L) { + LinkList r; + + if(L==NULL || L->next==L) { + return ERROR; + } + + for(r = L; r->next != L; r = r->next) { + r->next->pre = r; + } + + L->pre = r; + + return OK; +} + +// ָݴСͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + // ʼͷ + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->pre = NULL; + (*L)->next = *L; + + for(i = 0, r = *L; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + s->pre = NULL; + + s->next = r->next; + r->next = s; + r = r->next; + } + + return OK; +} + +// +void Output(LinkList L) { + LinkList p; + + if(L == NULL || L->next == L) { + return; + } + + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + + printf("\n"); +} + +// +void OutputReverse(LinkList L) { + LinkList p; + + if(L == NULL || L->pre == L) { + return; + } + + for(p = L->pre; p != L; p = p->pre) { + printf("%2d ", p->data); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.32/02.32.vcxproj b/VisualC++/ExerciseBook/02.32/02.32.vcxproj new file mode 100644 index 0000000..85075cf --- /dev/null +++ b/VisualC++/ExerciseBook/02.32/02.32.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {21A0126B-82E0-45B8-94BF-2FEC0216F99F} + My0232 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.32/02.32.vcxproj.filters b/VisualC++/ExerciseBook/02.32/02.32.vcxproj.filters new file mode 100644 index 0000000..6af6607 --- /dev/null +++ b/VisualC++/ExerciseBook/02.32/02.32.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.32/02.32.vcxproj.user b/VisualC++/ExerciseBook/02.32/02.32.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.32/02.32.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.33/02.33.c b/VisualC++/ExerciseBook/02.33/02.33.c new file mode 100644 index 0000000..6e6160d --- /dev/null +++ b/VisualC++/ExerciseBook/02.33/02.33.c @@ -0,0 +1,174 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩisalphaisdigitԭ +#include "Status.h" //**01 **// + +/* ԪͶ */ +typedef char ElemType; + +// ѭṹ +typedef struct LNode { + ElemType data; + struct LNode* next; +} LNode; + +// ָָ +typedef LNode* LinkList; + + +/* + * 2.33 + * + * ַ֡ + */ +Status Algo_2_33(LinkList L, LinkList* L_char, LinkList* L_num, LinkList* L_other); + +// ʼһѭ +Status InitList(LinkList* L); + +// ָݴСͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n); + +// +void Output(LinkList L); + + +int main(int argc, char* argv[]) { + LinkList L, L_char, L_num, L_other; + + ElemType a[20+1] = "2a3@A5e$T*1%s&7pl(o)"; + + // ׼ݣ + CreatList(&L, a, 20); + printf("L = "); + Output(L); + + // + Algo_2_33(L, &L_char, &L_num, &L_other); + + // ֺ + printf("L_char = "); + Output(L_char); + printf("L_num = "); + Output(L_num); + printf("L_other = "); + Output(L_other); + + return 0; +} + + +// ַ֡ +Status Algo_2_33(LinkList L, LinkList* L_char, LinkList* L_num, LinkList* L_other) { + LinkList r, rc, rn, ro, s; + + if(L_char == NULL || L_num == NULL || L_other == NULL) { + return ERROR; + } + + if(L == NULL || L->next == L) { + return ERROR; + } + + InitList(L_char); + InitList(L_num); + InitList(L_other); + + r = L->next; + rc = *L_char; + rn = *L_num; + ro = *L_other; + + while(r != L) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = r->data; + + // ԪΪַ + if(isalpha(r->data)) { + s->next = rc->next; + rc->next = s; + rc = rc->next; + + // ԪΪ + } else if(isdigit(r->data)) { + s->next = rn->next; + rn->next = s; + rn = rn->next; + + // + } else { + s->next = ro->next; + ro->next = s; + ro = ro->next; + } + + r = r->next; + } + + return OK; +} + + +// ʼһѭ +Status InitList(LinkList* L) { + if(L == NULL) { + return ERROR; + } + + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = *L; + + return OK; +} + +// ָݴСͷĵѭ +Status CreatList(LinkList* L, ElemType elems[], int n) { + LinkList s, r; + int i; + + if(L == NULL) { + return ERROR; + } + + // ʼͷ + (*L) = (LinkList) malloc(sizeof(LNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->next = *L; + + for(i = 0, r = *L; i < n; i++) { + s = (LinkList) malloc(sizeof(LNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + + s->next = r->next; + r->next = s; + r = r->next; + } + + return OK; +} + +// +void Output(LinkList L) { + LinkList p; + + if(L == NULL || L->next == L) { + return; + } + + for(p = L->next; p != L; p = p->next) { + printf("%c ", p->data); + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.33/02.33.vcxproj b/VisualC++/ExerciseBook/02.33/02.33.vcxproj new file mode 100644 index 0000000..e090ced --- /dev/null +++ b/VisualC++/ExerciseBook/02.33/02.33.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {F8AA03E3-9F5C-42BF-B105-3E89041A14F8} + My0233 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.33/02.33.vcxproj.filters b/VisualC++/ExerciseBook/02.33/02.33.vcxproj.filters new file mode 100644 index 0000000..dedd7b5 --- /dev/null +++ b/VisualC++/ExerciseBook/02.33/02.33.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.33/02.33.vcxproj.user b/VisualC++/ExerciseBook/02.33/02.33.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.33/02.33.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.c b/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.c new file mode 100644 index 0000000..7ebb208 --- /dev/null +++ b/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.c @@ -0,0 +1,433 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include +#include "Status.h" //**01 **// + +// ָԪ +typedef char XElemType; + +// ָṹ +typedef struct XorNode { + XElemType data; + struct XorNode* LRPtr; +} XorNode; +typedef XorNode* XorPointer; + +// ͷָ˫ͷβָ +typedef struct { + XorPointer Left; // ֱָˣͷָ룩Ҷˣβָ룩 + XorPointer Right; +} XorLinkedList; + + +/* + * 2.34һPriorOrNext + * + * Lmarkʾ01 + */ +void Algo_2_34_1(XorLinkedList L, int mark); + +/* + * 2.34PriorOrNext + * + * Lmarkʾ01 + */ +void Algo_2_34_2(XorLinkedList L, int mark); + +/* + * 2.35 + * + * Ԫe뵽i֮ǰ + */ +Status Algo_2_35(XorLinkedList* L, int i, XElemType e); + +/* + * 2.36 + * + * ɾi(>0)㣬eܽԪֵ + */ +Status Algo_2_36(XorLinkedList* L, int i, char* e); + +// ָָpqֵ㣺p^q +XorPointer XorP(XorPointer p, XorPointer q); + +// ָL +Status Create(XorLinkedList* L, XElemType elems[], int n); + +// ȡǰ(cur)ǰ(mark=0)(mark=1) +XorPointer PriorOrNext(XorLinkedList L, XorPointer cur, int mark); + + +int main(int argc, char** argv) { + XorLinkedList L; + XElemType e; + XElemType* data = "123456789"; + + Create(&L, data, strlen(data)); + printf(" 2.34 ֤...\n"); + printf(" L = "); + Algo_2_34_1(L, 0); + printf(" L = "); + Algo_2_34_1(L, 1); + + printf(" 2.35 ֤...\n"); + Algo_2_35(&L, 5, '*'); + printf(" '*' ΪLĵ5˳...\n"); + printf(" L = "); + Algo_2_34_2(L, 0); + + printf(" 2.36 ֤...\n"); + Algo_2_36(&L, 5, &e); + printf(" ɾLĵ5 '%c' ...\n", e); + printf(" L = "); + Algo_2_34_2(L, 1); + + return 0; +} + + +// 㣺p^q +XorPointer XorP(XorPointer p, XorPointer q) { + unsigned long x, y, z; + + x = (unsigned long) p; + y = (unsigned long) q; + + // + z = x ^ y; + + return (XorPointer) z; +} + +// ָL +Status Create(XorLinkedList* L, XElemType elems[], int n) { + int i; + XorPointer pre_l, pre_m, pre_r; // ׼ָ룬ָнڵ + + (*L).Left = NULL; + (*L).Right = NULL; + + pre_l = pre_m = NULL; + + for(i = 0; i < n; i++) { + pre_r = (XorPointer) malloc(sizeof(XorNode)); + if(pre_r == NULL) { + exit(OVERFLOW); + } + pre_r->data = elems[i]; + + // ָ루׽ʱ + if(i == 0) { + L->Left = pre_r; + } + + // ָ룬ָһ + L->Right = pre_r; + + // ½ʱһָҪ޸ + if(pre_m != NULL) { + pre_m->LRPtr = XorP(pre_l, pre_r); + } + + pre_r->LRPtr = XorP(pre_m, NULL); + pre_l = pre_m; + pre_m = pre_r; + } + + return OK; +} + +// ȡǰ(cur)ǰ(mark=0)(mark=1) +XorPointer PriorOrNext(XorLinkedList L, XorPointer cur, int mark) { + XorPointer p_l, p_m, p_r; + + if(mark != 1 && mark != 0) { + return NULL; + } + + // ȷ + if(L.Left == NULL || L.Right == NULL || cur == NULL) { + return NULL; + } + + // ̣ + if(mark == 1) { + p_l = NULL; + p_m = L.Left; + + // ָ벻ƽ + while(p_m != cur) { + p_r = XorP(p_l, p_m->LRPtr); //Ҳһַ + p_l = p_m; + p_m = p_r; + } + + // p_mָcurǰ + p_r = XorP(p_l, p_m->LRPtr); + + return p_r; + + // ǰ + } else { + p_m = L.Right; + p_r = NULL; + + // ָ벻ƽ + while(p_m != cur) { + p_l = XorP(p_m->LRPtr, p_r); //һַ + p_r = p_m; + p_m = p_l; + } + + // p_mָcurĺ + p_l = XorP(p_m->LRPtr, p_r); + + return p_l; + } +} + +// Lmarkʾ01 +void Algo_2_34_1(XorLinkedList L, int mark) { + XorPointer cur; + + if(mark != 1 && mark != 0) { + return; + } + + // ȷ + if(L.Left == NULL || L.Right == NULL) { + return; + } + + // + if(mark == 0) { + cur = L.Left; + do { + printf("%c ", cur->data); + // ȡcurĺ + cur = PriorOrNext(L, cur, 1); + } while(cur != NULL); + + // + } else { + cur = L.Right; + do { + printf("%c ", cur->data); + // ȡcurǰ + cur = PriorOrNext(L, cur, 0); + } while(cur != NULL); + } + + printf("\n"); +} + +// Lmarkʾ01 +void Algo_2_34_2(XorLinkedList L, int mark) { + XorPointer p_l, p_m, p_r; + + if(mark != 1 && mark != 0) { + return; + } + + // ȷ + if(L.Left == NULL || L.Right == NULL) { + return; + } + + // + if(mark == 0) { + p_l = NULL; + p_m = L.Left; + + // p_mΪʱ˵ + while(p_m != NULL) { + printf("%c ", p_m->data); + p_r = XorP(p_l, p_m->LRPtr); // Ҳһַ + p_l = p_m; // ָ벻ƽ + p_m = p_r; + } + + // + } else { + p_m = L.Right; + p_r = NULL; + + // p_mΪʱ˵ + while(p_m != NULL) { + printf("%c ", p_m->data); + p_l = XorP(p_m->LRPtr, p_r); // һַ + p_r = p_m; // ָ벻ǰƽ + p_m = p_l; + } + } + + printf("\n"); +} + +// Ԫe뵽i֮ǰ +Status Algo_2_35(XorLinkedList* L, int i, XElemType e) { + XorPointer pl; // ָi-2 + XorPointer pre; // ָi-1 + XorPointer p; // ָi + XorPointer pr; // ָi+1 + XorPointer s; + int j; + + if(L == NULL) { + return ERROR; + } + + // i>=1 + if(i < 1) { + return ERROR; + } + + // ½ + s = (XorPointer) malloc(sizeof(XorNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // ȴΪյ + if((*L).Left == NULL && (*L).Right == NULL) { + if(i != 1) { + return ERROR; // ΪʱiֻΪ1 + } + + (*L).Left = (*L).Right = s; + s->LRPtr = NULL; + + return OK; + } + + j = 0; + pre = NULL; + p = (*L).Left; + + // ҵi-1㣬preָ + while(j < i - 1 && p != NULL) { + j++; + pr = XorP(pre, p->LRPtr); + pre = p; + p = pr; + } + + // iֵϹ棨 + if(j < i - 1) { + return ERROR; + } + + // Ҫ뵽β + if(p == NULL) { + pl = XorP(pre->LRPtr, p); + pre->LRPtr = XorP(pl, s); + + s->LRPtr = XorP(pre, p); + + (*L).Right = s; + + return OK; + } + + // Ҫ뵽ͷ + if(pre == NULL) { + pr = XorP(pre, p->LRPtr); + p->LRPtr = XorP(s, pr); + + s->LRPtr = XorP(pre, p); + + (*L).Left = s; + + return OK; + } + + // + pl = XorP(pre->LRPtr, p); + pr = XorP(pre, p->LRPtr); + pre->LRPtr = XorP(pl, s); + p->LRPtr = XorP(s, pr); + s->LRPtr = XorP(pre, p); + + return OK; +} + +// ɾi(>0)㣬eܽԪֵ +Status Algo_2_36(XorLinkedList* L, int i, XElemType* e) { + XorPointer pl; // ָi-2 + XorPointer pre; // ָi-1 + XorPointer p; // ָi + XorPointer pr; // ָi+1 + XorPointer prr; // ָi+2 + int j; + + if(L == NULL || (*L).Left == NULL || (*L).Right == NULL) { + return ERROR; + } + + // i>=1 + if(i < 1) { + return ERROR; + } + + // ȴֻһ + if((*L).Left == (*L).Right) { + if(i != 1) { + return ERROR; // ֻһʱiֻΪ1 + } + + *e = (*L).Left->data; + (*L).Left = (*L).Right = NULL; + + return OK; + } + + j = 0; + pre = NULL; + p = (*L).Left; + + // ҵi-1㣬preָ + while(j < i - 1 && p != NULL) { + j++; + pr = XorP(pre, p->LRPtr); + pre = p; + p = pr; + } + + // iֵϹ棨 + if(j < i - 1 || p == NULL) { + return ERROR; + } + + // 洢ɾԪصֵ + *e = p->data; + + /* ˣԪشڣpָɾԪ */ + + pr = XorP(pre, p->LRPtr); + + // ɾͷ + if(pre == NULL) { + // ڴʱ㣬pr!=NULL + prr = XorP(p, pr->LRPtr); + + pr->LRPtr = XorP(pre, prr); + + (*L).Left = pr; + } else { + pl = XorP(pre->LRPtr, p); + pre->LRPtr = XorP(pl, pr); + + // ɾһ + if(pr==NULL) { + (*L).Right = pre; + } else { + prr = XorP(p, pr->LRPtr); + pr->LRPtr = XorP(pre, prr); + } + } + + free(p); + + return OK; +} diff --git a/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj b/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj new file mode 100644 index 0000000..11bf345 --- /dev/null +++ b/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {34443CD7-11AB-4846-A502-111ECDF91619} + My02340236 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj.filters b/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj.filters new file mode 100644 index 0000000..7234a94 --- /dev/null +++ b/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj.user b/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.34-02.36/02.34-02.36.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.37/02.37.c b/VisualC++/ExerciseBook/02.37/02.37.c new file mode 100644 index 0000000..2890d7f --- /dev/null +++ b/VisualC++/ExerciseBook/02.37/02.37.c @@ -0,0 +1,73 @@ +#include +#include "Status.h" //**01 **// +#include "DuLinkList.h" //**02 Ա**// + +/* + * 2.37 + * + * żԪλλԪؿǰżλԪؿ + */ +Status Algo_2_37(DuLinkList L); + +// ԺӡԪ +void PrintElem(ElemType e); + + +int main(int argc, char* argv[]) { + DuLinkList L; + int i; + + // ׼ + InitList(&L); + for(i = 1; i <= 10; i++) { + ListInsert(L, i, i); + } + printf("ǰ L = "); + ListTraverse(L, PrintElem); + + Algo_2_37(L); + + printf("ź L = "); + ListTraverse(L, PrintElem); + + return 0; +} + + +// żԪλλԪؿǰżλԪؿ +Status Algo_2_37(DuLinkList L) { + DuLinkList head, tail, p; + + if(L == NULL || L->prior == NULL || L->next == NULL) { + return ERROR; + } + + head = L->next; // ָףƽ + tail = L->prior; // ָβ̶ + + // headtailмٸһԪ + while(head != tail && head->next != tail) { + // ָԭżλԪ + p = head->next; + + // ժ´żλԪ + p->next->prior = head; + head->next = p->next; + + // Ԫӵԭtail + p->next = tail->next; + p->prior = tail; + tail->next->prior = p; + tail->next = p; + + // ǰһλԪ + head = head->next; + } + + return OK; +} + +// ԺӡԪ +void PrintElem(ElemType e) { + printf("%d ", e); +} diff --git a/VisualC++/ExerciseBook/02.37/02.37.vcxproj b/VisualC++/ExerciseBook/02.37/02.37.vcxproj new file mode 100644 index 0000000..ddb02ce --- /dev/null +++ b/VisualC++/ExerciseBook/02.37/02.37.vcxproj @@ -0,0 +1,76 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {6F8F4D0B-E744-43AB-9B26-B5CD540CC32C} + My0237 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.37/02.37.vcxproj.filters b/VisualC++/ExerciseBook/02.37/02.37.vcxproj.filters new file mode 100644 index 0000000..f6cf1db --- /dev/null +++ b/VisualC++/ExerciseBook/02.37/02.37.vcxproj.filters @@ -0,0 +1,30 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + 源文件 + + + + + 头文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.37/02.37.vcxproj.user b/VisualC++/ExerciseBook/02.37/02.37.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.37/02.37.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.37/DuLinkList.c b/VisualC++/ExerciseBook/02.37/DuLinkList.c new file mode 100644 index 0000000..df3f94d --- /dev/null +++ b/VisualC++/ExerciseBook/02.37/DuLinkList.c @@ -0,0 +1,130 @@ +/*===================== + * ˫ѭ + * + * 㷨: 2.182.19 + ======================*/ + +#include "DuLinkList.h" //**02 Ա**// + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(DuLinkList* L) { + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + + // ǰͺָ̾ + (*L)->next = (*L)->prior = *L; + + return OK; +} + +/* + * 㷨2.18 + * + * + * + * ˫ѭiλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(DuLinkList L, int i, ElemType e) { + DuLinkList p, s; + + // ȷ˫ѭڣΪձ + if(L == NULL) { + return ERROR; + } + + // ҵiλãã + if((p = GetElemP(L, i)) == NULL) { + return ERROR; + } + + // ½ + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = e; + + // s뵽pǰ棬Ϊi + s->prior = p->prior; + p->prior->next = s; + s->next = p; + p->prior = s; + + return OK; +} + +/* + * + * + * visit˫ѭL + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)) { + DuLinkList p; + + // ȷ˫ѭ + if(L == NULL || L->next == L || L->prior == L) { + return; + } + + p = L->next; + + while(p != L) { + Visit(p->data); + p = p->next; + } + + printf("\n"); +} + +/* + * ȡѭLϵiԪص + * + * ע + * 1.staticĺǵǰֻDuLinkListʹãᱻļ + * 2.ΪlenҪȡlen+1ԪصʱѭԷصͷ + */ +static DuLinkList GetElemP(DuLinkList L, int i) { + DuLinkList p; + int count; + + // ȷ˫ѭڣΪձ + if(L == NULL) { + return NULL; + } + + // λòϹ + if(i < 1) { + return NULL; + } + + p = L; + count = 0; + + // ԲҵiԪ + while(p->next != L && count < i) { + p = p->next; + ++count; + } + + // ǡҵiԪ + if(count == i) { + return p; + } + + // ˣ˵p->next==LʱҪжiǷ + if(count + 1 < i) { + return NULL; + } + + // ˣ˵Ҫlen+1λϲԪ + return L; +} diff --git a/VisualC++/ExerciseBook/02.37/DuLinkList.h b/VisualC++/ExerciseBook/02.37/DuLinkList.h new file mode 100644 index 0000000..4a0edc2 --- /dev/null +++ b/VisualC++/ExerciseBook/02.37/DuLinkList.h @@ -0,0 +1,67 @@ +/*===================== + * ˫ѭ + * + * 㷨: 2.182.19 + ======================*/ + +#ifndef DULINKLIST_H +#define DULINKLIST_H + +#include +#include //ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ˫ѭԪͶ */ +typedef int ElemType; + +/* + * ˫ѭṹ + * + * ע˫ѭͷ + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // ǰ + struct DuLNode* next; // +} DuLNode; + +// ָ˫ѭָ +typedef DuLNode* DuLinkList; + + +/* + * ʼ + * + * ʼɹ򷵻OK򷵻ERROR + */ +Status InitList(DuLinkList* L); + +/* + * 㷨2.18 + * + * + * + * ˫ѭiλϲeɹ򷵻OK򷵻ERROR + * + *ע + * ̲iĺԪλã1ʼ + */ +Status ListInsert(DuLinkList L, int i, ElemType e); + +/* + * + * + * visit˫ѭL + */ +void ListTraverse(DuLinkList L, void(Visit)(ElemType)); + +/* + * ȡѭLϵiԪص + * + * ע + * 1.staticĺǵǰֻDuLinkListʹãᱻļ + * 2.ΪlenҪȡlen+1ԪصʱѭԷصͷ + */ +static DuLinkList GetElemP(DuLinkList L, int i); + +#endif diff --git a/VisualC++/ExerciseBook/02.38/02.38.c b/VisualC++/ExerciseBook/02.38/02.38.c new file mode 100644 index 0000000..72a7780 --- /dev/null +++ b/VisualC++/ExerciseBook/02.38/02.38.c @@ -0,0 +1,153 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +/* ˫ѭԪͶ */ +typedef int ElemType; + +/* + * ˫ѭṹһƴ + * + * ע˫ѭͷ + */ +typedef struct DuLNode { + ElemType data; + struct DuLNode* prior; // ǰ + struct DuLNode* next; // + int freq; // Ƶ +} DuLNode; + +// ָ˫ѭṹָ +typedef DuLNode* DuLinkList; + +/* + * 2.38 + * + * Ԫe״Lгֵλ򣬲Ƶ + */ +DuLinkList Algo_2_38(DuLinkList* L, ElemType e); + +// ˫ѭ +Status CreatList(DuLinkList* L, ElemType elems[], int n); + +// +void Output(DuLinkList L); + + +int main(int argc, char* argv[]) { + DuLinkList L; + int i; + ElemType data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + ElemType visit[10] = {1, 2, 2, 2, 3, 4, 4, 5, 5, 9}; + + CreatList(&L, data, 10); + printf("ǰ L = \n"); + Output(L); + + // ηtmpԤ + for(i = 0; i < 10; i++) { + Algo_2_38(&L, visit[i]); + } + + printf("ʺL = \n"); + Output(L); + + return 0; +} + +// Ԫe״Lгֵλ򣬲Ƶ +DuLinkList Algo_2_38(DuLinkList* L, ElemType e) { + DuLinkList pre, r; + + // ȷ + if(L == NULL || *L == NULL) { + return NULL; + } + + for(pre = *L; pre->next != *L && pre->next->data != e; pre = pre->next) { + // Ԫeǰ + } + + // ûҵԪ + if(pre->next == *L) { + return NULL; + } + + // ժԪe + r = pre->next; + pre->next = r->next; + r->next->prior = pre; + + // Ƶһ + r->freq++; + + for(pre = *L; pre->next != *L && pre->next->freq > r->freq; pre = pre->next) { + // ݷƵȣѰԪeӦòλõǰ + } + + // Ԫe뵽ʵλ + r->next = pre->next; + r->prior = pre; + pre->next->prior = r; + pre->next = r; + + // ָԪe + return r; +} + +// ˫ѭ +Status CreatList(DuLinkList* L, ElemType elems[], int n) { + DuLinkList s, p; + int i; + + *L = (DuLinkList) malloc(sizeof(DuLNode)); + if(*L == NULL) { + exit(OVERFLOW); + } + (*L)->data = -1; + (*L)->prior = *L; + (*L)->next = *L; + (*L)->freq = 0; + + p = *L; + + for(i = 0; i < n; i++) { + s = (DuLinkList) malloc(sizeof(DuLNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = elems[i]; + s->freq = 0; + + // β + s->next = *L; + (*L)->prior = s; + s->prior = p; + p->next = s; + + p = p->next; + } + + return OK; +} + +// +void Output(DuLinkList L) { + DuLinkList p; + + if(L == NULL || L->next == L || L->prior == NULL) { + return; + } + + printf("ݣ"); + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->data); + } + printf("\n"); + + printf("Ƶȣ"); + for(p = L->next; p != L; p = p->next) { + printf("%2d ", p->freq); + } + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.38/02.38.vcxproj b/VisualC++/ExerciseBook/02.38/02.38.vcxproj new file mode 100644 index 0000000..cca674c --- /dev/null +++ b/VisualC++/ExerciseBook/02.38/02.38.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {CF7E8C5D-B306-4A9A-9029-64B7A3A19FED} + My0238 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.38/02.38.vcxproj.filters b/VisualC++/ExerciseBook/02.38/02.38.vcxproj.filters new file mode 100644 index 0000000..c20ab80 --- /dev/null +++ b/VisualC++/ExerciseBook/02.38/02.38.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.38/02.38.vcxproj.user b/VisualC++/ExerciseBook/02.38/02.38.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.38/02.38.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.c b/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.c new file mode 100644 index 0000000..eefde6c --- /dev/null +++ b/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.c @@ -0,0 +1,184 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include // ṩpowԭ +#include "Status.h" //**01 **// + +// ϡʽ˳ṹ +typedef struct { + int coef; //ϵ + int exp; //ָ +} PolyTerm; + +// ʽ˳洢ṹ +typedef struct { + PolyTerm* data; + int last; // ʽ +} SqPoly; + +/* + * 2.39 + * + * ʽֵ + */ +int Algo_2_39(SqPoly P, int x); + +/* + * 2.40 + * + * Pc=Pa-Pb + */ +Status Algo_2_40(SqPoly Pa, SqPoly Pb, SqPoly* Pc); + +// ϡʽ +Status CreatPoly(SqPoly* P, PolyTerm Data[], int n); + +// ϡʽ +void OutputPoly(SqPoly P); + + +int main(int argc, char* argv[]) { + SqPoly Pa, Pb, Pc; + + PolyTerm a[5] = {{-2, 1}, {4, 3}, {11, 5}, {-7, 7}, {8, 9}}; + PolyTerm b[5] = {{3, 2}, {-5, 3}, {12, 4}, {-7, 7}, {6, 11}}; + + // ׼ + CreatPoly(&Pa, a, 5); + CreatPoly(&Pb, b, 5); + printf("Pan(x) = "); + OutputPoly(Pa); + printf("Pbn(x) = "); + OutputPoly(Pb); + + printf("\n"); + + printf(" 2.39 ֤...\n"); + printf(" Pa5(2) = %d", Algo_2_39(Pa, 2)); + printf("\n"); + printf(" Pb5(2) = %d", Algo_2_39(Pb, 2)); + printf("\n\n"); + + printf(" 2.40 ֤...\n"); + Algo_2_40(Pa, Pb, &Pc); + printf(" Pcn(x) = "); + OutputPoly(Pc); + + printf("ʽPcֵ Pc5(2) = %d\n", Algo_2_39(Pc, 2)); + + return 0; +} + + +// ʽֵ +int Algo_2_39(SqPoly P, int x) { + int i, sum; + + for(i = 0, sum = 0; i < P.last; i++) { + sum += P.data[i].coef * (int) (pow(x, P.data[i].exp)); + } + + return sum; +} + +// Pc=Pa-Pb +Status Algo_2_40(SqPoly Pa, SqPoly Pb, SqPoly* Pc) { + int i, j, k, sum; + + (*Pc).data = (PolyTerm*) malloc((Pa.last + Pb.last) * sizeof(PolyTerm)); + if((*Pc).data == NULL) { + exit(OVERFLOW); + } + + i = j = k = 0; + + // PaPbĹ + while(i < Pa.last && j < Pb.last) { + // PaָСPa + if(Pa.data[i].exp < Pb.data[j].exp) { + (*Pc).data[k++] = Pa.data[i]; + i++; + // PaָϴPbֻ򵥸ıϵž + } else if(Pa.data[i].exp > Pb.data[j].exp) { + (*Pc).data[k].coef = -Pb.data[j].coef; //Ÿı + (*Pc).data[k].exp = Pb.data[j].exp; + k++; + j++; + // ָʱҪ + } else { + sum = Pa.data[i].coef - Pb.data[j].coef; + + // ԴЧ + if(sum != 0) { + (*Pc).data[k].coef = sum; + (*Pc).data[k].exp = Pa.data[i].exp; + k++; + } + + i++; + j++; + } + } + + // Paδɨ꣬PbɨˣPaʣಿִ浽Pc + while(i < Pa.last) { + (*Pc).data[k++] = Pa.data[i]; + i++; + } + + // Pbδɨ꣬Ҫϵת浽Pc + while(j < Pb.last) { + (*Pc).data[k].coef = -Pb.data[j].coef; + (*Pc).data[k].exp = Pb.data[j].exp; + k++; + j++; + } + + // ¼ + (*Pc).last = k; + + return OK; +} + +Status CreatPoly(SqPoly* P, PolyTerm Data[], int n) { + int i; + + (*P).data = (PolyTerm*) malloc(n * sizeof(PolyTerm)); + if((*P).data == NULL) { + exit(OVERFLOW); + } + (*P).last = n; + + for(i = 0; i < n; i++) { + (*P).data[i] = Data[i]; + } + + return OK; +} + +void OutputPoly(SqPoly P) { + int i; + + for(i = 0; i < P.last; i++) { + if(i == 0) { + printf("%d", P.data[i].coef); + } else { + if(P.data[i].coef < 0) { + printf(" - "); + printf("%d", -P.data[i].coef); + } else { + printf(" + "); + printf("%d", P.data[i].coef); + } + } + + if(P.data[i].exp) { + printf("x"); + + if(P.data[i].exp != 1) { + printf("^%d", P.data[i].exp); + } + } + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj b/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj new file mode 100644 index 0000000..ab2cd54 --- /dev/null +++ b/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {C825A5F6-1A8E-4FFD-AEE9-D097DA14DCF3} + My02390240 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj.filters b/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj.filters new file mode 100644 index 0000000..a8a7b3a --- /dev/null +++ b/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj.user b/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.39-02.40/02.39-02.40.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.c b/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.c new file mode 100644 index 0000000..066e422 --- /dev/null +++ b/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.c @@ -0,0 +1,215 @@ +#include +#include // ṩmallocreallocfreeexitԭ +#include "Status.h" //**01 **// + +// ϡʽ +typedef struct { + int coef; // ϵ + int exp; // ָ +} PolyTerm; + +// ϡʽʽṹѭṹ +typedef struct PolyNode { + PolyTerm data; + struct PolyNode* next; +} PolyNode; + +typedef PolyNode* PolyLink; +typedef PolyLink LinkedPoly; + + +/* + * 2.41 + * + * ʽĵ + */ +Status Algo_2_41(LinkedPoly P); + +/* + * 2.42 + * + * ָżԲֶʽ + */ +Status Algo_2_42(LinkedPoly* P, LinkedPoly* P_Odd, LinkedPoly* P_Even); + +// ϡʽ +Status CreatPoly(LinkedPoly* P, PolyTerm Data[], int n); + +// ϡʽ +void OutputPoly(LinkedPoly P); + + +int main(int argc, char* argv[]) { + LinkedPoly P1, P2; + PolyTerm a[7] = {{-2, 1}, {4, 2}, {2, 3}, {11, 5}, {-7, 6}, {8, 9}, {-3, 10}}; + + // ׼ + CreatPoly(&P1, a, 7); + CreatPoly(&P2, a, 7); + printf("Pn(x) = "); + OutputPoly(P1); + printf("\n"); + + printf(" 2.41 ֤...\n"); + { + + Algo_2_41(P1); + printf(" ʽĵ֮...\n"); + printf(" Pn(x) = "); + OutputPoly(P1); + printf("\n"); + } + + printf(" 2.42 ֤...\n"); + { + LinkedPoly P_odd, P_even; + Algo_2_42(&P2, &P_odd, &P_even); + printf(" ָżԲֶʽ֮...\n"); + printf(" P_odd = "); + OutputPoly(P_odd); + printf(" ż P_even = "); + OutputPoly(P_even); + } + + return 0; +} + + +// ʽĵ +Status Algo_2_41(LinkedPoly P) { + LinkedPoly r, pre; + + if(P == NULL || P->next == P) { + return ERROR; + } + + pre = P; + r = P->next; + + while(r != P) { + // ڲΪ0ָ + if(r->data.exp != 0) { + r->data.coef *= r->data.exp; // ϵָ + r->data.exp--; // ָһ + pre = r; + + // ָΪ0ʱ󵼺Ϊ0Ҫɾǰ + } else { + pre->next = r->next; + free(r); + } + + r = pre->next; + } + + return OK; +} + +// ָżԲֶʽ +Status Algo_2_42(LinkedPoly* P, LinkedPoly* P_Odd, LinkedPoly* P_Even) { + LinkedPoly r, s, p, q; + + // ͷ + *P_Odd = (LinkedPoly) malloc(sizeof(PolyNode)); + *P_Even = (LinkedPoly) malloc(sizeof(PolyNode)); + if(*P_Odd == NULL || *P_Even == NULL) { + exit(OVERFLOW); + } + (*P_Odd)->next = *P_Odd; + (*P_Even)->next = *P_Even; + + if(P == NULL || *P == NULL) { + return ERROR; + } + + p = *P_Odd; + q = *P_Even; + r = (*P)->next; + + // ʽ + while(r != (*P)) { + s = r; + r = r->next; + + // ָΪ + if(s->data.exp % 2 != 0) { + s->next = p->next; + p->next = s; + p = p->next; + + // ָΪż + } else { + s->next = q->next; + q->next = s; + q = q->next; + } + } + + // ԭĶʽ + free(*P); + *P = NULL; + + return OK; +} + +// ϡʽ +Status CreatPoly(LinkedPoly* P, PolyTerm Data[], int n) { + int i; + LinkedPoly s, r; + + // ͷ + *P = (LinkedPoly) malloc(sizeof(PolyNode)); + if(*P == NULL) { + exit(OVERFLOW); + } + (*P)->next = *P; + + for(i = 0, r = *P; i < n; i++) { + s = (LinkedPoly) malloc(sizeof(PolyNode)); + if(s == NULL) { + exit(OVERFLOW); + } + s->data = Data[i]; + + // ӵʽ + s->next = r->next; + r->next = s; + + r = r->next; + } + + return OK; +} + +// ϡʽ +void OutputPoly(LinkedPoly P) { + LinkedPoly r; + + if(P == NULL || P->next == P) { + return; + } + + for(r = P->next; r != P; r = r->next) { + if(r == P->next) { + printf("%d", r->data.coef); + } else { + if(r->data.coef < 0) { + printf(" - "); + printf("%d", -r->data.coef); + } else { + printf(" + "); + printf("%d", r->data.coef); + } + } + + if(r->data.exp) { + printf("x"); + + if(r->data.exp != 1) { + printf("^%d", r->data.exp); + } + } + } + + printf("\n"); +} diff --git a/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj b/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj new file mode 100644 index 0000000..f7f333b --- /dev/null +++ b/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj @@ -0,0 +1,72 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + {40DA8411-A6E0-488C-83B2-00ED82B716AC} + My02410242 + + + + Application + true + MultiByte + + + Application + false + true + MultiByte + + + + + + + + + + + + + $(SolutionDir)\..\Status;$(IncludePath) + + + + Level3 + Disabled + + + true + $(SolutionDir)\..\Status\Status.lib;%(AdditionalDependencies) + Console + + + + + Level3 + MaxSpeed + true + true + + + true + true + true + + + + + + + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj.filters b/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj.filters new file mode 100644 index 0000000..de4b2db --- /dev/null +++ b/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj.user b/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/ExerciseBook/02.41-02.42/02.41-02.42.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/ExerciseBook/ExerciseBook.sdf b/VisualC++/ExerciseBook/ExerciseBook.sdf new file mode 100644 index 0000000..baa3716 Binary files /dev/null and b/VisualC++/ExerciseBook/ExerciseBook.sdf differ diff --git a/VisualC++/ExerciseBook/ExerciseBook.sln b/VisualC++/ExerciseBook/ExerciseBook.sln new file mode 100644 index 0000000..b340daa --- /dev/null +++ b/VisualC++/ExerciseBook/ExerciseBook.sln @@ -0,0 +1,194 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual C++ Express 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01.16", "01.16\01.16.vcxproj", "{5D2C546F-8544-475E-8060-44A929F48A65}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01.17", "01.17\01.17.vcxproj", "{D604D310-9601-49FB-ABEE-48D81E6A2724}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01.19", "01.19\01.19.vcxproj", "{F30CB20D-C44F-45FF-AA39-D459E6EB16B9}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "01.20", "01.20\01.20.vcxproj", "{A6883C77-6D02-44B1-B492-965B019E15C2}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.10", "02.10\02.10.vcxproj", "{00719F0C-F124-42BE-9297-711FF153A064}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.11", "02.11\02.11.vcxproj", "{52058BF7-48EF-4058-A47D-C358600A3D43}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.12", "02.12\02.12.vcxproj", "{BB137EB3-5250-427B-95D7-0D26A73234C7}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.13", "02.13\02.13.vcxproj", "{F9D880FE-6305-4B6A-AF56-0BE0C976D006}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.14", "02.14\02.14.vcxproj", "{AA43C2F9-4ADF-41F2-89ED-47843643C4A3}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.15", "02.15\02.15.vcxproj", "{D14B8DD0-5CF1-4D80-8B2E-71E53670E7DA}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.16-02.18", "02.16-02.18\02.16-02.18.vcxproj", "{F3E461F8-2545-4922-AF95-C0FAC35EDF8D}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.19-02.20", "02.19-02.20\02.19-02.20.vcxproj", "{A0DE4DB7-5E42-412A-896E-8CD17902142C}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.21", "02.21\02.21.vcxproj", "{2DC8B8E0-D90F-40F6-B0F0-D951DDCA408E}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.22", "02.22\02.22.vcxproj", "{479F8705-7B4A-413F-939D-5A68C82C7E6A}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.23", "02.23\02.23.vcxproj", "{9B913BF8-0766-462F-B982-8D5020815B34}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.24", "02.24\02.24.vcxproj", "{69D091DF-26ED-4578-91BB-328FE9BAAF2D}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.25", "02.25\02.25.vcxproj", "{6694823F-5439-4003-B718-84A60147E5F3}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.26", "02.26\02.26.vcxproj", "{4F184A85-5203-4DED-BFA9-0F2799F9AF12}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.27", "02.27\02.27.vcxproj", "{94F9896A-E87A-47EB-B598-C1E60F16F9A7}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.28", "02.28\02.28.vcxproj", "{CDC6D120-D68F-47B6-A9E7-A5A461133DFA}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.29", "02.29\02.29.vcxproj", "{D051583F-72E8-4F2E-A5FA-AAEED0793C86}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.30", "02.30\02.30.vcxproj", "{267890F4-9F75-4F76-972B-9D621336FAB8}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.31", "02.31\02.31.vcxproj", "{C02C7FFC-6B3F-42AD-85A9-9E085BF0168C}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.32", "02.32\02.32.vcxproj", "{21A0126B-82E0-45B8-94BF-2FEC0216F99F}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.33", "02.33\02.33.vcxproj", "{F8AA03E3-9F5C-42BF-B105-3E89041A14F8}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.34-02.36", "02.34-02.36\02.34-02.36.vcxproj", "{34443CD7-11AB-4846-A502-111ECDF91619}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.37", "02.37\02.37.vcxproj", "{6F8F4D0B-E744-43AB-9B26-B5CD540CC32C}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.38", "02.38\02.38.vcxproj", "{CF7E8C5D-B306-4A9A-9029-64B7A3A19FED}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.39-02.40", "02.39-02.40\02.39-02.40.vcxproj", "{C825A5F6-1A8E-4FFD-AEE9-D097DA14DCF3}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "02.41-02.42", "02.41-02.42\02.41-02.42.vcxproj", "{40DA8411-A6E0-488C-83B2-00ED82B716AC}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {5D2C546F-8544-475E-8060-44A929F48A65}.Debug|Win32.ActiveCfg = Debug|Win32 + {5D2C546F-8544-475E-8060-44A929F48A65}.Debug|Win32.Build.0 = Debug|Win32 + {5D2C546F-8544-475E-8060-44A929F48A65}.Release|Win32.ActiveCfg = Release|Win32 + {5D2C546F-8544-475E-8060-44A929F48A65}.Release|Win32.Build.0 = Release|Win32 + {D604D310-9601-49FB-ABEE-48D81E6A2724}.Debug|Win32.ActiveCfg = Debug|Win32 + {D604D310-9601-49FB-ABEE-48D81E6A2724}.Debug|Win32.Build.0 = Debug|Win32 + {D604D310-9601-49FB-ABEE-48D81E6A2724}.Release|Win32.ActiveCfg = Release|Win32 + {D604D310-9601-49FB-ABEE-48D81E6A2724}.Release|Win32.Build.0 = Release|Win32 + {F30CB20D-C44F-45FF-AA39-D459E6EB16B9}.Debug|Win32.ActiveCfg = Debug|Win32 + {F30CB20D-C44F-45FF-AA39-D459E6EB16B9}.Debug|Win32.Build.0 = Debug|Win32 + {F30CB20D-C44F-45FF-AA39-D459E6EB16B9}.Release|Win32.ActiveCfg = Release|Win32 + {F30CB20D-C44F-45FF-AA39-D459E6EB16B9}.Release|Win32.Build.0 = Release|Win32 + {A6883C77-6D02-44B1-B492-965B019E15C2}.Debug|Win32.ActiveCfg = Debug|Win32 + {A6883C77-6D02-44B1-B492-965B019E15C2}.Debug|Win32.Build.0 = Debug|Win32 + {A6883C77-6D02-44B1-B492-965B019E15C2}.Release|Win32.ActiveCfg = Release|Win32 + {A6883C77-6D02-44B1-B492-965B019E15C2}.Release|Win32.Build.0 = Release|Win32 + {00719F0C-F124-42BE-9297-711FF153A064}.Debug|Win32.ActiveCfg = Debug|Win32 + {00719F0C-F124-42BE-9297-711FF153A064}.Debug|Win32.Build.0 = Debug|Win32 + {00719F0C-F124-42BE-9297-711FF153A064}.Release|Win32.ActiveCfg = Release|Win32 + {00719F0C-F124-42BE-9297-711FF153A064}.Release|Win32.Build.0 = Release|Win32 + {52058BF7-48EF-4058-A47D-C358600A3D43}.Debug|Win32.ActiveCfg = Debug|Win32 + {52058BF7-48EF-4058-A47D-C358600A3D43}.Debug|Win32.Build.0 = Debug|Win32 + {52058BF7-48EF-4058-A47D-C358600A3D43}.Release|Win32.ActiveCfg = Release|Win32 + {52058BF7-48EF-4058-A47D-C358600A3D43}.Release|Win32.Build.0 = Release|Win32 + {BB137EB3-5250-427B-95D7-0D26A73234C7}.Debug|Win32.ActiveCfg = Debug|Win32 + {BB137EB3-5250-427B-95D7-0D26A73234C7}.Debug|Win32.Build.0 = Debug|Win32 + {BB137EB3-5250-427B-95D7-0D26A73234C7}.Release|Win32.ActiveCfg = Release|Win32 + {BB137EB3-5250-427B-95D7-0D26A73234C7}.Release|Win32.Build.0 = Release|Win32 + {F9D880FE-6305-4B6A-AF56-0BE0C976D006}.Debug|Win32.ActiveCfg = Debug|Win32 + {F9D880FE-6305-4B6A-AF56-0BE0C976D006}.Debug|Win32.Build.0 = Debug|Win32 + {F9D880FE-6305-4B6A-AF56-0BE0C976D006}.Release|Win32.ActiveCfg = Release|Win32 + {F9D880FE-6305-4B6A-AF56-0BE0C976D006}.Release|Win32.Build.0 = Release|Win32 + {AA43C2F9-4ADF-41F2-89ED-47843643C4A3}.Debug|Win32.ActiveCfg = Debug|Win32 + {AA43C2F9-4ADF-41F2-89ED-47843643C4A3}.Debug|Win32.Build.0 = Debug|Win32 + {AA43C2F9-4ADF-41F2-89ED-47843643C4A3}.Release|Win32.ActiveCfg = Release|Win32 + {AA43C2F9-4ADF-41F2-89ED-47843643C4A3}.Release|Win32.Build.0 = Release|Win32 + {D14B8DD0-5CF1-4D80-8B2E-71E53670E7DA}.Debug|Win32.ActiveCfg = Debug|Win32 + {D14B8DD0-5CF1-4D80-8B2E-71E53670E7DA}.Debug|Win32.Build.0 = Debug|Win32 + {D14B8DD0-5CF1-4D80-8B2E-71E53670E7DA}.Release|Win32.ActiveCfg = Release|Win32 + {D14B8DD0-5CF1-4D80-8B2E-71E53670E7DA}.Release|Win32.Build.0 = Release|Win32 + {F3E461F8-2545-4922-AF95-C0FAC35EDF8D}.Debug|Win32.ActiveCfg = Debug|Win32 + {F3E461F8-2545-4922-AF95-C0FAC35EDF8D}.Debug|Win32.Build.0 = Debug|Win32 + {F3E461F8-2545-4922-AF95-C0FAC35EDF8D}.Release|Win32.ActiveCfg = Release|Win32 + {F3E461F8-2545-4922-AF95-C0FAC35EDF8D}.Release|Win32.Build.0 = Release|Win32 + {A0DE4DB7-5E42-412A-896E-8CD17902142C}.Debug|Win32.ActiveCfg = Debug|Win32 + {A0DE4DB7-5E42-412A-896E-8CD17902142C}.Debug|Win32.Build.0 = Debug|Win32 + {A0DE4DB7-5E42-412A-896E-8CD17902142C}.Release|Win32.ActiveCfg = Release|Win32 + {A0DE4DB7-5E42-412A-896E-8CD17902142C}.Release|Win32.Build.0 = Release|Win32 + {2DC8B8E0-D90F-40F6-B0F0-D951DDCA408E}.Debug|Win32.ActiveCfg = Debug|Win32 + {2DC8B8E0-D90F-40F6-B0F0-D951DDCA408E}.Debug|Win32.Build.0 = Debug|Win32 + {2DC8B8E0-D90F-40F6-B0F0-D951DDCA408E}.Release|Win32.ActiveCfg = Release|Win32 + {2DC8B8E0-D90F-40F6-B0F0-D951DDCA408E}.Release|Win32.Build.0 = Release|Win32 + {479F8705-7B4A-413F-939D-5A68C82C7E6A}.Debug|Win32.ActiveCfg = Debug|Win32 + {479F8705-7B4A-413F-939D-5A68C82C7E6A}.Debug|Win32.Build.0 = Debug|Win32 + {479F8705-7B4A-413F-939D-5A68C82C7E6A}.Release|Win32.ActiveCfg = Release|Win32 + {479F8705-7B4A-413F-939D-5A68C82C7E6A}.Release|Win32.Build.0 = Release|Win32 + {9B913BF8-0766-462F-B982-8D5020815B34}.Debug|Win32.ActiveCfg = Debug|Win32 + {9B913BF8-0766-462F-B982-8D5020815B34}.Debug|Win32.Build.0 = Debug|Win32 + {9B913BF8-0766-462F-B982-8D5020815B34}.Release|Win32.ActiveCfg = Release|Win32 + {9B913BF8-0766-462F-B982-8D5020815B34}.Release|Win32.Build.0 = Release|Win32 + {69D091DF-26ED-4578-91BB-328FE9BAAF2D}.Debug|Win32.ActiveCfg = Debug|Win32 + {69D091DF-26ED-4578-91BB-328FE9BAAF2D}.Debug|Win32.Build.0 = Debug|Win32 + {69D091DF-26ED-4578-91BB-328FE9BAAF2D}.Release|Win32.ActiveCfg = Release|Win32 + {69D091DF-26ED-4578-91BB-328FE9BAAF2D}.Release|Win32.Build.0 = Release|Win32 + {6694823F-5439-4003-B718-84A60147E5F3}.Debug|Win32.ActiveCfg = Debug|Win32 + {6694823F-5439-4003-B718-84A60147E5F3}.Debug|Win32.Build.0 = Debug|Win32 + {6694823F-5439-4003-B718-84A60147E5F3}.Release|Win32.ActiveCfg = Release|Win32 + {6694823F-5439-4003-B718-84A60147E5F3}.Release|Win32.Build.0 = Release|Win32 + {4F184A85-5203-4DED-BFA9-0F2799F9AF12}.Debug|Win32.ActiveCfg = Debug|Win32 + {4F184A85-5203-4DED-BFA9-0F2799F9AF12}.Debug|Win32.Build.0 = Debug|Win32 + {4F184A85-5203-4DED-BFA9-0F2799F9AF12}.Release|Win32.ActiveCfg = Release|Win32 + {4F184A85-5203-4DED-BFA9-0F2799F9AF12}.Release|Win32.Build.0 = Release|Win32 + {94F9896A-E87A-47EB-B598-C1E60F16F9A7}.Debug|Win32.ActiveCfg = Debug|Win32 + {94F9896A-E87A-47EB-B598-C1E60F16F9A7}.Debug|Win32.Build.0 = Debug|Win32 + {94F9896A-E87A-47EB-B598-C1E60F16F9A7}.Release|Win32.ActiveCfg = Release|Win32 + {94F9896A-E87A-47EB-B598-C1E60F16F9A7}.Release|Win32.Build.0 = Release|Win32 + {CDC6D120-D68F-47B6-A9E7-A5A461133DFA}.Debug|Win32.ActiveCfg = Debug|Win32 + {CDC6D120-D68F-47B6-A9E7-A5A461133DFA}.Debug|Win32.Build.0 = Debug|Win32 + {CDC6D120-D68F-47B6-A9E7-A5A461133DFA}.Release|Win32.ActiveCfg = Release|Win32 + {CDC6D120-D68F-47B6-A9E7-A5A461133DFA}.Release|Win32.Build.0 = Release|Win32 + {D051583F-72E8-4F2E-A5FA-AAEED0793C86}.Debug|Win32.ActiveCfg = Debug|Win32 + {D051583F-72E8-4F2E-A5FA-AAEED0793C86}.Debug|Win32.Build.0 = Debug|Win32 + {D051583F-72E8-4F2E-A5FA-AAEED0793C86}.Release|Win32.ActiveCfg = Release|Win32 + {D051583F-72E8-4F2E-A5FA-AAEED0793C86}.Release|Win32.Build.0 = Release|Win32 + {267890F4-9F75-4F76-972B-9D621336FAB8}.Debug|Win32.ActiveCfg = Debug|Win32 + {267890F4-9F75-4F76-972B-9D621336FAB8}.Debug|Win32.Build.0 = Debug|Win32 + {267890F4-9F75-4F76-972B-9D621336FAB8}.Release|Win32.ActiveCfg = Release|Win32 + {267890F4-9F75-4F76-972B-9D621336FAB8}.Release|Win32.Build.0 = Release|Win32 + {C02C7FFC-6B3F-42AD-85A9-9E085BF0168C}.Debug|Win32.ActiveCfg = Debug|Win32 + {C02C7FFC-6B3F-42AD-85A9-9E085BF0168C}.Debug|Win32.Build.0 = Debug|Win32 + {C02C7FFC-6B3F-42AD-85A9-9E085BF0168C}.Release|Win32.ActiveCfg = Release|Win32 + {C02C7FFC-6B3F-42AD-85A9-9E085BF0168C}.Release|Win32.Build.0 = Release|Win32 + {21A0126B-82E0-45B8-94BF-2FEC0216F99F}.Debug|Win32.ActiveCfg = Debug|Win32 + {21A0126B-82E0-45B8-94BF-2FEC0216F99F}.Debug|Win32.Build.0 = Debug|Win32 + {21A0126B-82E0-45B8-94BF-2FEC0216F99F}.Release|Win32.ActiveCfg = Release|Win32 + {21A0126B-82E0-45B8-94BF-2FEC0216F99F}.Release|Win32.Build.0 = Release|Win32 + {F8AA03E3-9F5C-42BF-B105-3E89041A14F8}.Debug|Win32.ActiveCfg = Debug|Win32 + {F8AA03E3-9F5C-42BF-B105-3E89041A14F8}.Debug|Win32.Build.0 = Debug|Win32 + {F8AA03E3-9F5C-42BF-B105-3E89041A14F8}.Release|Win32.ActiveCfg = Release|Win32 + {F8AA03E3-9F5C-42BF-B105-3E89041A14F8}.Release|Win32.Build.0 = Release|Win32 + {34443CD7-11AB-4846-A502-111ECDF91619}.Debug|Win32.ActiveCfg = Debug|Win32 + {34443CD7-11AB-4846-A502-111ECDF91619}.Debug|Win32.Build.0 = Debug|Win32 + {34443CD7-11AB-4846-A502-111ECDF91619}.Release|Win32.ActiveCfg = Release|Win32 + {34443CD7-11AB-4846-A502-111ECDF91619}.Release|Win32.Build.0 = Release|Win32 + {6F8F4D0B-E744-43AB-9B26-B5CD540CC32C}.Debug|Win32.ActiveCfg = Debug|Win32 + {6F8F4D0B-E744-43AB-9B26-B5CD540CC32C}.Debug|Win32.Build.0 = Debug|Win32 + {6F8F4D0B-E744-43AB-9B26-B5CD540CC32C}.Release|Win32.ActiveCfg = Release|Win32 + {6F8F4D0B-E744-43AB-9B26-B5CD540CC32C}.Release|Win32.Build.0 = Release|Win32 + {CF7E8C5D-B306-4A9A-9029-64B7A3A19FED}.Debug|Win32.ActiveCfg = Debug|Win32 + {CF7E8C5D-B306-4A9A-9029-64B7A3A19FED}.Debug|Win32.Build.0 = Debug|Win32 + {CF7E8C5D-B306-4A9A-9029-64B7A3A19FED}.Release|Win32.ActiveCfg = Release|Win32 + {CF7E8C5D-B306-4A9A-9029-64B7A3A19FED}.Release|Win32.Build.0 = Release|Win32 + {C825A5F6-1A8E-4FFD-AEE9-D097DA14DCF3}.Debug|Win32.ActiveCfg = Debug|Win32 + {C825A5F6-1A8E-4FFD-AEE9-D097DA14DCF3}.Debug|Win32.Build.0 = Debug|Win32 + {C825A5F6-1A8E-4FFD-AEE9-D097DA14DCF3}.Release|Win32.ActiveCfg = Release|Win32 + {C825A5F6-1A8E-4FFD-AEE9-D097DA14DCF3}.Release|Win32.Build.0 = Release|Win32 + {40DA8411-A6E0-488C-83B2-00ED82B716AC}.Debug|Win32.ActiveCfg = Debug|Win32 + {40DA8411-A6E0-488C-83B2-00ED82B716AC}.Debug|Win32.Build.0 = Debug|Win32 + {40DA8411-A6E0-488C-83B2-00ED82B716AC}.Release|Win32.ActiveCfg = Release|Win32 + {40DA8411-A6E0-488C-83B2-00ED82B716AC}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/VisualC++/ExerciseBook/ExerciseBook.suo b/VisualC++/ExerciseBook/ExerciseBook.suo new file mode 100644 index 0000000..6aaf49c Binary files /dev/null and b/VisualC++/ExerciseBook/ExerciseBook.suo differ diff --git a/VisualC++/README.md b/VisualC++/README.md index 52ef2b4..0e50d27 100644 --- a/VisualC++/README.md +++ b/VisualC++/README.md @@ -8,3 +8,29 @@ > **Microsoft Visual C++** [2010] > **MSVC++** [10.0] + +## 使用说明 + +1. 确保 **Microsoft Visual C++ 2010** 已安装完毕（也可使用更高版本的Visual系列的软件） + +2. 启动Microsoft Visual C++ 2010，选择"打开项目" +![VC01](image/VC01.png) + +3. 选择目标项目，并启动它 +![VC02](image/VC02.png) + +4. 选择要测试项目运行即可 + +## 注意事项 + +1. 教材源码CourseBook跟习题集源码ExerciseBook是放在**两个项目**当中的 +2. VisualC++版本的源码，其文件编码格式使用了GB2312 +3. 新版本的Microsoft Visual已经支持gcc编译环境，即使用类似CLion中的CMakeLists.txt文件指定编译规则，配置方式请自行搜索 +4. Microsoft Visual C++ 2010中静态库的配置方式如下图： + + ![VC03](image/VC03.png) + + ![VC04](image/VC04.png) + + ![VC05](image/VC05.png) + \ No newline at end of file diff --git a/VisualC++/Status/Status.c b/VisualC++/Status/Status.c new file mode 100644 index 0000000..085e030 --- /dev/null +++ b/VisualC++/Status/Status.c @@ -0,0 +1,164 @@ +#include +#include +#include // ṩva_listva_startva_argva_end +#include // ṩisprintԭ + +/* + * Զ¼뺯ڴļfpжȡʽ + * fscanf֮ͬڴ˺ֻȡַַ + * + * ע + * 1. ԼиʽΪʽ磺%d%c%sȣ%2d%5s + * 2. ȡַʱոǴӡַֹͣȡ + */ +int ReadData(FILE* fp, char* format, ...) { + int* i; // 洢ȡ + float* f; // 洢ȡĸ + char* ch; // 洢ȡַ + char* s; // 洢ȡַ + + int n; // 洢ַַ + + int len; // ʽformatij + int k; // ʽʱα + + int tmp; // ݴļжȡַ + + va_list ap; // ɱָ룬ָ洢ݵı + + // ۼƳɹȡַ + int count = 0; + + + /* + * ȡʽij + * Ԥʽɼ + */ + len = strlen(format); + + // apָ׸ɱ + va_start(ap, format); + + // ֻΪż¶% + for(k = 1; k <= len; k = k + 2) { + // зַ + while((tmp = getc(fp)) != EOF) { + // ׸ַַ· + if((tmp >= 0 && tmp <= 127)) { + ungetc(tmp, fp); + break; + } + } + + // Ѷļβȡ + if(tmp == EOF) { + break; + } + + // "%c"Ӧöȡַ + if(format[k] == 'c') { + ch = va_arg(ap, char*); + + count += fscanf(fp, "%c", ch); + } + + // "%d"Ӧöȡ + if(format[k] == 'd') { + i = va_arg(ap, int*); + + while((tmp = getc(fp)) != EOF) { + // Ѱ + if((tmp >= '0' && tmp <= '9') || tmp == '-' || tmp == '+') { + ungetc(tmp, fp); + break; + } + } + + if(tmp != EOF) { + count += fscanf(fp, "%d", i); + } + } + + // ȡͣһɴ洢Ϊdouble + if(format[k] == 'f') { + f = va_arg(ap, float*); + + while((tmp = getc(fp)) != EOF) { + if((tmp >= '0' && tmp <= '9') || tmp == '-' || tmp == '+' || tmp == '.') { + ungetc(tmp, fp); + break; + } + } + + if(tmp != EOF) { + count += fscanf(fp, "%f", f); + } + } + + // ȡַ + if(format[k] == 's') { + s = va_arg(ap, char*); + + n = 0; + + // ųոĿɴӡַ + while((tmp = getc(fp)) != EOF && (!isprint(tmp) || tmp == ' ')) { + } + + // δļβ + if(!feof(fp)) { + + // ַ· + ungetc(tmp, fp); + + while((tmp = getc(fp)) != EOF) { + // 洢ųոĿɴӡַ + if(isprint(tmp) && tmp != ' ') { + s[n++] = tmp; + } else { + ungetc(tmp, fp); + break; + } + } + + count++; + } + + // ַһַΪַ + s[n] = '\0'; + } + }// for + + va_end(ap); + + return count; +} + +// »سԼ +void PressEnterToContinue() { + int debug = 1; + + fflush(stdin); + + printf("\nPress Enter to Continue..."); + + // ڲԽ׶ʱdebug=1ԶӻУڲ + if(debug) { + printf("\n"); + + // ʱdebug=0ֶ뻻Уóͣ۲ÿһ + } else { + getchar(); + } + + fflush(stdin); +} + +// ͣһʱ䣬timeʱ +void Wait(long time) { + double i; + + for(i = 0.01; i <= 100000.0 * time; i += 0.01) { + // ѭ + } +} diff --git a/VisualC++/Status/Status.h b/VisualC++/Status/Status.h new file mode 100644 index 0000000..b81e11c --- /dev/null +++ b/VisualC++/Status/Status.h @@ -0,0 +1,43 @@ +/* + * ע + * ޶Ŀİϣȡÿģ鶼Ե + * Statusģᱻģãôܶࡣ + * ֱӽStatusģ鸴ƵģУᵼ̫ظ룬 + * һ̬ģ鹲Ƚϻ + */ + +#ifndef STATUS_H +#define STATUS_H + +#include + +/* ״̬ */ +#define TRUE 1 // / +#define FALSE 0 // / +#define OK 1 // ͨ/ɹ +#define ERROR 0 // /ʧ + +//ϵͳд״̬붨壬Ҫֹͻ +#ifndef OVERFLOW +#define OVERFLOW -2 //ջ +#endif + +//ϵͳд״̬붨壬Ҫֹͻ +#ifndef NULL +#define NULL ((void*)0) +#endif + +/* ״̬ */ +typedef int Status; + + +// ȡ +int ReadData(FILE* fp, char* format, ...); + +// »سԼ +void PressEnterToContinue(); + +// ͣһʱ䣬timeʱ +void Wait(long time); + +#endif diff --git a/VisualC++/Status/Status.lib b/VisualC++/Status/Status.lib new file mode 100644 index 0000000..f24c6ff Binary files /dev/null and b/VisualC++/Status/Status.lib differ diff --git a/VisualC++/Status/Status.sdf b/VisualC++/Status/Status.sdf new file mode 100644 index 0000000..506400c Binary files /dev/null and b/VisualC++/Status/Status.sdf differ diff --git a/VisualC++/Status/Status.sln b/VisualC++/Status/Status.sln new file mode 100644 index 0000000..45d673c --- /dev/null +++ b/VisualC++/Status/Status.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual C++ Express 2010 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Status", "Status.vcxproj", "{34C24AFA-DBFA-4862-AE16-17E56B54DDEB}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {34C24AFA-DBFA-4862-AE16-17E56B54DDEB}.Debug|Win32.ActiveCfg = Debug|Win32 + {34C24AFA-DBFA-4862-AE16-17E56B54DDEB}.Debug|Win32.Build.0 = Debug|Win32 + {34C24AFA-DBFA-4862-AE16-17E56B54DDEB}.Release|Win32.ActiveCfg = Release|Win32 + {34C24AFA-DBFA-4862-AE16-17E56B54DDEB}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/VisualC++/Status/Status.suo b/VisualC++/Status/Status.suo new file mode 100644 index 0000000..2d410dc Binary files /dev/null and b/VisualC++/Status/Status.suo differ diff --git a/VisualC++/Status/Status.vcxproj b/VisualC++/Status/Status.vcxproj new file mode 100644 index 0000000..4d57d83 --- /dev/null +++ b/VisualC++/Status/Status.vcxproj @@ -0,0 +1,80 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + + + + + + + + {34C24AFA-DBFA-4862-AE16-17E56B54DDEB} + Win32Proj + Status + + + + StaticLibrary + true + Unicode + + + StaticLibrary + false + true + Unicode + + + + + + + + + + + + + + + + + Level3 + Disabled + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + + + Windows + true + + + + + Level3 + + + MaxSpeed + true + true + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + + + Windows + true + true + true + + + + + + \ No newline at end of file diff --git a/VisualC++/Status/Status.vcxproj.filters b/VisualC++/Status/Status.vcxproj.filters new file mode 100644 index 0000000..670249c --- /dev/null +++ b/VisualC++/Status/Status.vcxproj.filters @@ -0,0 +1,27 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 头文件 + + + + + 源文件 + + + \ No newline at end of file diff --git a/VisualC++/Status/Status.vcxproj.user b/VisualC++/Status/Status.vcxproj.user new file mode 100644 index 0000000..ace9a86 --- /dev/null +++ b/VisualC++/Status/Status.vcxproj.user @@ -0,0 +1,3 @@ + + + \ No newline at end of file diff --git a/VisualC++/image/VC01.png b/VisualC++/image/VC01.png new file mode 100644 index 0000000..63eaba3 Binary files /dev/null and b/VisualC++/image/VC01.png differ diff --git a/VisualC++/image/VC02.png b/VisualC++/image/VC02.png new file mode 100644 index 0000000..8c8e68f Binary files /dev/null and b/VisualC++/image/VC02.png differ diff --git a/VisualC++/image/VC03.png b/VisualC++/image/VC03.png new file mode 100644 index 0000000..e63d560 Binary files /dev/null and b/VisualC++/image/VC03.png differ diff --git a/VisualC++/image/VC04.png b/VisualC++/image/VC04.png new file mode 100644 index 0000000..4708d71 Binary files /dev/null and b/VisualC++/image/VC04.png differ diff --git a/VisualC++/image/VC05.png b/VisualC++/image/VC05.png new file mode 100644 index 0000000..c890ec0 Binary files /dev/null and b/VisualC++/image/VC05.png differ diff --git a/习题解析/01 绪论/_v_images/20181124235559962_1540.png b/习题解析/01 绪论/_v_images/20181124235559962_1540.png new file mode 100644 index 0000000..927853b Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181124235559962_1540.png differ diff --git a/习题解析/01 绪论/_v_images/20181124235659821_31062.png b/习题解析/01 绪论/_v_images/20181124235659821_31062.png new file mode 100644 index 0000000..a8f29c9 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181124235659821_31062.png differ diff --git a/习题解析/01 绪论/_v_images/20181124235736015_5587.png b/习题解析/01 绪论/_v_images/20181124235736015_5587.png new file mode 100644 index 0000000..8fa4bd3 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181124235736015_5587.png differ diff --git a/习题解析/01 绪论/_v_images/20181124235749817_29555.png b/习题解析/01 绪论/_v_images/20181124235749817_29555.png new file mode 100644 index 0000000..61f6190 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181124235749817_29555.png differ diff --git a/习题解析/01 绪论/_v_images/20181125001012797_15869.png b/习题解析/01 绪论/_v_images/20181125001012797_15869.png new file mode 100644 index 0000000..c378391 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125001012797_15869.png differ diff --git a/习题解析/01 绪论/_v_images/20181125001057524_32274.png b/习题解析/01 绪论/_v_images/20181125001057524_32274.png new file mode 100644 index 0000000..263d557 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125001057524_32274.png differ diff --git a/习题解析/01 绪论/_v_images/20181125001138318_16618.png b/习题解析/01 绪论/_v_images/20181125001138318_16618.png new file mode 100644 index 0000000..c5b80ed Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125001138318_16618.png differ diff --git a/习题解析/01 绪论/_v_images/20181125002335576_8701.png b/习题解析/01 绪论/_v_images/20181125002335576_8701.png new file mode 100644 index 0000000..5dcdeca Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125002335576_8701.png differ diff --git a/习题解析/01 绪论/_v_images/20181125002344865_51.png b/习题解析/01 绪论/_v_images/20181125002344865_51.png new file mode 100644 index 0000000..418583c Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125002344865_51.png differ diff --git a/习题解析/01 绪论/_v_images/20181125003217769_19055.png b/习题解析/01 绪论/_v_images/20181125003217769_19055.png new file mode 100644 index 0000000..0210c8b Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125003217769_19055.png differ diff --git a/习题解析/01 绪论/_v_images/20181125003411487_11601.png b/习题解析/01 绪论/_v_images/20181125003411487_11601.png new file mode 100644 index 0000000..f0f7c95 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125003411487_11601.png differ diff --git a/习题解析/01 绪论/_v_images/20181125003506946_12124.png b/习题解析/01 绪论/_v_images/20181125003506946_12124.png new file mode 100644 index 0000000..5421a4c Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125003506946_12124.png differ diff --git a/习题解析/01 绪论/_v_images/20181125003527776_6872.png b/习题解析/01 绪论/_v_images/20181125003527776_6872.png new file mode 100644 index 0000000..970db8f Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125003527776_6872.png differ diff --git a/习题解析/01 绪论/_v_images/20181125003543569_28283.png b/习题解析/01 绪论/_v_images/20181125003543569_28283.png new file mode 100644 index 0000000..a4539a5 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125003543569_28283.png differ diff --git a/习题解析/01 绪论/_v_images/20181125003604248_12415.png b/习题解析/01 绪论/_v_images/20181125003604248_12415.png new file mode 100644 index 0000000..1e01df2 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125003604248_12415.png differ diff --git a/习题解析/01 绪论/_v_images/20181125003616918_30233.png b/习题解析/01 绪论/_v_images/20181125003616918_30233.png new file mode 100644 index 0000000..3ce6c32 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125003616918_30233.png differ diff --git a/习题解析/01 绪论/_v_images/20181125004220502_31495.png b/习题解析/01 绪论/_v_images/20181125004220502_31495.png new file mode 100644 index 0000000..f22d1c1 Binary files /dev/null and b/习题解析/01 绪论/_v_images/20181125004220502_31495.png differ diff --git a/习题解析/01 绪论/第01章 绪论.md b/习题解析/01 绪论/第01章 绪论.md new file mode 100644 index 0000000..56a416d --- /dev/null +++ b/习题解析/01 绪论/第01章 绪论.md @@ -0,0 +1,396 @@ +# 第1章 绪论 + +## 一、基础知识题 + +### 1.1 简述下列术语：数据、数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 + +> **数据**(data)是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。 +> **数据元素**(data element)是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 +> **数据对象**(data object)是性质相同的数据元素的集合，是数据的一个子集。 +> **数据结构**(data structure)是相互之间存在一种或多种特定关系的数据元素的集合。 +> **存储结构**（**物理结构**）是数据结构在计算机中的表示（又称映像）。 +> **数据类型**(data type)是一个值的集合和定义在这个值集上的一组操作的总称。 +> **抽象数据类型**(Abstract Data Type)是指一个数学模型以及定义在该模型上的一组操作。 + +### 1.2 试描述数据结构和抽象数据类型的概念与程序设计语言中数据类型概念的区别。 + +> 简单地说，数据结构定义了一组按某些关系结合在一起的数组元素。数据类型不仅定义了一组带结构的数据元素，而且还在其上定义了一组操作。 + +### 1.3 设有数据结构（D，R），其中：D={d1,d2,d3,d4}，R={r}，r={(d1,d2),(d2,d3),(d3,d4)}。试按图论中图的画法惯例画出其逻辑结构图。 + +![1.3](_v_images/20181124235659821_31062.png) + +### 1.4 试仿照三元组的抽象数据类型分别写出抽象数据类型复数和有理数的定义（有理数是其分子、分母均为自然数且分母不为零的分数）。 + +```c +复数定义： +ADT Complex //复数定义 a±bi +{ + 数据对象：D = {a, b | a,b为实数} + 数据关系：R = {} + 基本操作： + InitComplex(&C, re, im) + 操作结果：构造一个复数C，其实部和虚部分别为re和im + DestroyCmoplex(&C) + 操作结果：销毁复数C + Get(C, k, &e) + 初始条件：复数C已存在 + 操作结果：用e返回复数C的第k元的值 + Put(&C, k, e) + 初始条件：复数C已存在 + 操作结果：改变复数C的第k元的值为e + IsAscending(C) + 初始条件：复数C已存在 + 操作结果：如果复数C的两个元素按升序排列，则返回1，否则返回0 + IsDescending(C) + 初始条件：复数C已存在 + 操作结果：如果复数C的两个元素按降序排列，则返回1，否则返回0 + Max(C, &e) + 初始条件：复数C已存在 + 操作结果：用e返回复数C的两个元素中值较大的一个 + Min(C, &e) + 初始条件：复数C已存在 + 操作结果：用e返回复数C的两个元素中值较小的一个 +}ADT Complex + +``` + +```c +有理数定义： +ADT RationalNumber //有理数定义 +{ + 数据对象：D={s, m | s,m为自然数，且m不为0} + 数据关系：R={} + 基本操作： + InitRationalNumber(&R, s, m) + 操作结果：构造一个有理数R，其分子和分母分别为s和m + DestroyRationalNumber(&R) + 操作结果：销毁有理数R + Get(R, k, &e) + 初始条件：有理数R已存在 + 操作结果：用e返回有理数R的第k元的值 + Put(&R, k, e) + 初始条件：有理数R已存在 + 操作结果：改变有理数R的第k元的值为e + IsAscending(R) + 初始条件：有理数R已存在 + 操作结果：若有理数R的两个元素按升序排列，则返回1，否则返回0 + IsDescending(R) + 初始条件：有理数R已存在 + 操作结果：若有理数R的两个元素按降序排列，则返回1，否则返回0 + Max(R, &e) + 初始条件：有理数R已存在 + 操作结果：用e返回有理数R的两个元素中值较大的一个 + Min(R, &e) + 初始条件：有理数R已存在 + 操作结果：用e返回有理数R的两个元素中值较小的一个 +}ADT RationalNumber +``` + +### 1.5 试画出与下列程序段等价的框图。 + +**(1)** + +```c +product = 1; +i = 1; +while(i<=n) +{ + product *= i; + i++; +} +``` + +![1.5.1](_v_images/20181124235559962_1540.png) + +**(2)** + +```c +i=0; +do +{ + i++; +}while((i!=n) && (a[i]!=x)); +``` + +![1.5.2](_v_images/20181124235736015_5587.png) + +**(3)** + +```c +switch +{ + case x （1）exit常用于严重错误处理，它可以强行中断程序的执行，返回操作系统。优点是可以在程序的任何地方关闭程序，缺点是隐藏了故障信息。 +> （2）以函数的返回值判断正确与否常用于子程序的测试，便于实现程序的局部控制。 +> （3）用整型变量进行错误处理的优点是可以给出错误类型，便于迅速定位错误。 + +### 1.7 在程序设计中，可采用下列三种方法实现输出和输入： +#### （1）通过scanf和printf语句； +#### （2）通过函数的参数显式传递； +#### （3）通过全局变量隐式传递。 +### 试讨论这三种方法的优缺点。 + +> （1）用scanf和printf直接进行输入输出的好处是形象、直观，但缺点是需要对其进行格式控制，较为烦琐，如果出现错误，则会引起整个系统的崩溃。 +> （2）通过函数的参数传递进行输入输出，便于实现信息的隐蔽，减少出错的可能。 +> （3）通过全局变量的隐式传递进行输入输出最为方便，只需修改变量的值即可，但过多的全局变量使程序的维护较为困难。 + +### 1.8 设n为正整数。试确定下列各程序段中前置以记号@的语句的频度： + +**（1）** + +```c +i = 1; k = 0; +while(i <= n-1) +{ +@ k += 10 * i; + i++; +} +``` + +> n-1 + +**（2）** + +```c +i = 1; k = 0; +do +{ +@ k += 10 * i; + i++; +}while(i <= n-1); +``` + +> n-1 + +**（3）** + +```c +i = 1; k = 0; +while(i <= n-1) +{ + i++; +@ k += 10 * i; +} +``` + +> n-1 + +**（4）** + +```c +k = 0; +for(i=1; i<=n; i++) +{ + for(j=i; j<=n; j++) +@ k++; +} +``` + +> ![1.8.4](_v_images/20181125001012797_15869.png) + +**（5）** + +```c +for(i=1; i<=n; i++) + for(j=1; j<=i; j++) + for(k=1; k<=j; k++) +@ x += 1; +``` + +> ![1.8.5](_v_images/20181125001057524_32274.png) + +**（6）** + +```c +i = 1; j = 0; +while(i+j <= n) +{ +@ if(i>j) + j++; + else + i++; +} +``` + +> n + +**（7）** + +```c +x = n; y = 0; //n是不小于1的常数 +while(x >= (y+1)*(y+1)) +@ y++; +``` + +> ![1.8.7](_v_images/20181125001138318_16618.png) + +**（8）** + +```c +x = 91; y = 100; +while(y>0) +{ +@ if(x>100) + { + x -= 10; + y--; + } + else + x++ ; +} +``` + +> 1100 + +### 1.9 假设n为2的乘幂，并且n>2,试求下列算法的时间复杂度及变量count的值（以n的函数形式表示）。 + +```c +int Time (int n) +{ + count = 0; + x = 2; + while(x 时间复杂度：O(log2n) +> count = log2n - 2 + +### 1.10 按增长率由小至大的顺序排列下列各函数： +#### 2100，(3/2)n，(2/3)n，(4/3)n，nn，n3/2，n2/3，√n，n！，n，log2n，n/log2n，log22n，log2(log2n)，nlog2n，nlog2n + +> 各函数的排列次序如下： +![1.10.1](_v_images/20181125002335576_8701.png) +![1.10.2](_v_images/20181125002344865_51.png) + +### 1.11 已知有实现同一功能的两个算法，其时间复杂度分别为O(2n)和O(n10)，假设现实计算机可连续运算的时间为107秒（100多天），又每秒可执行基本操作（根据这些操作来估算算法时间复杂度）105次。试问在此条件下，这两个算法可解问题的规模（即n值的范围）各为多少？哪个算法更适宜？请说明理由。 + +> 2n=1012，求得n=40 +> n10=1012，求得n=16 +> 故第一种算法较适宜。因为在同样的算力下，第一种算法可解的n值较大。 +> 由此可见，虽然一般情况下多项式阶的算法优于指数阶的算法，但高次多项式的算法在n的很大范围内不如某些指数阶的算法。 + +### 1.12 设有以下三个函数： +##### f(n)=21n4+n2+1000，g(n)=15n4+500n2，h(n)=5000n3.5+nlogn +### 请判断以下断言正确与否： +##### （1）f(n)是O(g(n)) +##### （2）h(n)是O(f(n)) +##### （3）g(n)是O(h(n)) +##### （4）h(n)是O(n3.5) +##### （5）h(n)是O(nlogn) + +> (1) 对 (2) 错 (3) 错 (4) 对 (5) 错 + +### 1.13 试设定若干n值，比较两函数n2和50nlog2n的增长趋势，并确定n在什么范围内时n2的值大于50nlog2n。 + +> 大约在n>450时 ，函数n2的值才大于函数50nlog2n的值。 + +![1.13](_v_images/20181125003217769_19055.png) + +### 1.14 判断下列各对函数f(n)和g(n)，当n→∞时，哪个函数增长更快？ + +![1.14](_v_images/20181125003411487_11601.png) + +> (1) g(n)快 (2) g(n)快 (3) f(n)快 (4) f(n)快 + +### 1.15 试用数学归纳法证明： + +![1.15](_v_images/20181125003506946_12124.png) + +![1.15.1](_v_images/20181125003527776_6872.png) + +![1.15.2](_v_images/20181125003543569_28283.png) + +![1.15.3](_v_images/20181125003604248_12415.png) + +![1.15.4](_v_images/20181125003616918_30233.png) + +## 二、算法设计题 + +### 1.16 试写一算法，自大到小依次输出顺序读入的三个整数X，Y和Z的值。 + +---------- + +### 1.17 已知k阶斐波那契序列的定义为 +``` +f0=0, f1=0, …, fk-2=0, fk-1=1; +fn=fn-1+fn-2+…+fn-k, n=k,k+1,… +``` +### 试编写求k阶斐波那契序列的第m项值的函数算法，k和m均以值调用的形式在函数参数表中出现。 + +---------- + +### 1.18 假设有A、B、C、D、E五个高等院校进行田径对抗赛，各院校的单项成绩均已存入计算机，并构成一张表，表中每一行的形式为： +|项目名称|性别|校名|成绩|得分| +|---------|-----|----|-----|----| +| | | | | | +### 编写算法，处理上述表格，以统计各院校的男、女总分和团体总分，并输出。 + +```c +typedef enum {A, B, C, D, E} SchoolName; +typedef enum {FEMALE, MALE} SexType; +typedef enum {X, Y, Z} Event; +typedef struct +{ + Event e; //项目名称 + SexType sex; //性别 + SchoolName school; //校名 + int score; //得分 +}Component; + +typedef struct +{ + int malesum; //男团总分 + int femalesum; //女团总分 + int totalsum; //团体总分 +}Sum; + +Component report[n]; //n条记录 +Sum result[5]; + +//算法过程体中主要结构 +for(i=0; ii的值并存入数组a[0..arrsize-1]的第i-1个分量中(i=1,2,…,n)。假设计算机中允许的整数最大值为maxint，则当n>arrsize或对某个k(1≤k≤n)使k!*2k>maxint时，应按出错处理。注意选择你认为较好的出错处理方法。 + +---------- + +### 1.20 试编写算法求一元多项式： +![1.20](_v_images/20181125004220502_31495.png) +### 的值Pn(x)，并确定算法中每一语句的执行次数和整个算法的时间复杂度。注意选择你认为较好的输入和输出方法。本题的输入为ai(i=0,1,…,n)，x0和n，输出为Pn(x0)。 + +---------- diff --git a/习题解析/02 线性表/_v_images/20181125013824965_16208.png b/习题解析/02 线性表/_v_images/20181125013824965_16208.png new file mode 100644 index 0000000..822b1d7 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125013824965_16208.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014137666_10327.png b/习题解析/02 线性表/_v_images/20181125014137666_10327.png new file mode 100644 index 0000000..40cf12c Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014137666_10327.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014156819_4098.png b/习题解析/02 线性表/_v_images/20181125014156819_4098.png new file mode 100644 index 0000000..dd1b7cf Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014156819_4098.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014215622_10158.png b/习题解析/02 线性表/_v_images/20181125014215622_10158.png new file mode 100644 index 0000000..45ae4e0 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014215622_10158.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014234236_4049.png b/习题解析/02 线性表/_v_images/20181125014234236_4049.png new file mode 100644 index 0000000..b642f28 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014234236_4049.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014248274_14430.png b/习题解析/02 线性表/_v_images/20181125014248274_14430.png new file mode 100644 index 0000000..cbc41ce Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014248274_14430.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014311773_4232.png b/习题解析/02 线性表/_v_images/20181125014311773_4232.png new file mode 100644 index 0000000..d19fee5 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014311773_4232.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014323122_29833.png b/习题解析/02 线性表/_v_images/20181125014323122_29833.png new file mode 100644 index 0000000..d19fee5 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014323122_29833.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014418601_7477.png b/习题解析/02 线性表/_v_images/20181125014418601_7477.png new file mode 100644 index 0000000..06667e9 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014418601_7477.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014438821_5785.png b/习题解析/02 线性表/_v_images/20181125014438821_5785.png new file mode 100644 index 0000000..20164cf Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014438821_5785.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014451902_15334.png b/习题解析/02 线性表/_v_images/20181125014451902_15334.png new file mode 100644 index 0000000..170dc6e Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014451902_15334.png differ diff --git a/习题解析/02 线性表/_v_images/20181125014506111_5250.png b/习题解析/02 线性表/_v_images/20181125014506111_5250.png new file mode 100644 index 0000000..9d3999a Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125014506111_5250.png differ diff --git a/习题解析/02 线性表/_v_images/20181125021743781_1329.png b/习题解析/02 线性表/_v_images/20181125021743781_1329.png new file mode 100644 index 0000000..89656e4 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125021743781_1329.png differ diff --git a/习题解析/02 线性表/_v_images/20181125021828395_8351.png b/习题解析/02 线性表/_v_images/20181125021828395_8351.png new file mode 100644 index 0000000..8fdf9c1 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125021828395_8351.png differ diff --git a/习题解析/02 线性表/_v_images/20181125021843504_17730.png b/习题解析/02 线性表/_v_images/20181125021843504_17730.png new file mode 100644 index 0000000..de8119d Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125021843504_17730.png differ diff --git a/习题解析/02 线性表/_v_images/20181125021854448_14854.png b/习题解析/02 线性表/_v_images/20181125021854448_14854.png new file mode 100644 index 0000000..cfc3d81 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125021854448_14854.png differ diff --git a/习题解析/02 线性表/_v_images/20181125021917117_7519.png b/习题解析/02 线性表/_v_images/20181125021917117_7519.png new file mode 100644 index 0000000..60309a2 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125021917117_7519.png differ diff --git a/习题解析/02 线性表/_v_images/20181125021939528_12633.png b/习题解析/02 线性表/_v_images/20181125021939528_12633.png new file mode 100644 index 0000000..89ca785 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125021939528_12633.png differ diff --git a/习题解析/02 线性表/_v_images/20181125022000822_29327.png b/习题解析/02 线性表/_v_images/20181125022000822_29327.png new file mode 100644 index 0000000..e09d869 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125022000822_29327.png differ diff --git a/习题解析/02 线性表/_v_images/20181125022414116_20977.png b/习题解析/02 线性表/_v_images/20181125022414116_20977.png new file mode 100644 index 0000000..61876ed Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125022414116_20977.png differ diff --git a/习题解析/02 线性表/_v_images/20181125022508237_15214.png b/习题解析/02 线性表/_v_images/20181125022508237_15214.png new file mode 100644 index 0000000..63dc703 Binary files /dev/null and b/习题解析/02 线性表/_v_images/20181125022508237_15214.png differ diff --git a/习题解析/02 线性表/第02章 线性表.md b/习题解析/02 线性表/第02章 线性表.md new file mode 100644 index 0000000..c0566db --- /dev/null +++ b/习题解析/02 线性表/第02章 线性表.md @@ -0,0 +1,498 @@ +# 第2章 线性表 + +## 一、基础知识题 + +### 2.1 描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。 + +> **首元结点**是指链表中存储线性表中第一个数据元素a1的结点。 +> **头结点**是为了操作方便，在链表的首元结点之前附设的一个结点，该结点的数据域中不存储线性表的数据元素，其作用是为了对链表进行操作时，可以对空表、非空表的情况以及对首元结点进行统一处理。 +> **头指针**是指向链表中第一个结点（或为头结点或为首元结点）的指针。若链表中附设头结点，则不管线性表是否为空表，头指针均不为空，否则表示空表的链表的头指针为空。 +> 这三个概念对单链表、双向链表和循环链表均适用。是否设置头结点，是不同的存储结构表示同一逻辑结构的问题。 + +### 2.2 填空题 + +>（1）在顺序表中插入或删除一个元素，需要平均移动 表中一半 元素，具体移动的元素个数与 该元素的位置 有关。 +>（2）顺序表中逻辑上相邻的元素的物理位置 必定 相邻。单链表中逻辑上相邻的元素在物理位置 不一定 相邻。 +>（3）在单链表中，除了首元结点外，任一结点的存储位置由 其直接前驱结点的链域的值 指示。 +>（4）在单链表中设置头结点的作用是 插入和删除首元素时不必进行特殊处理。 + +### 2.3 在什么情况下用顺序表比链表好？ + +> 当不需频繁在存储的元素间进行插入和删除操作时，用顺序表较好。 + +### 2.4 对以下单链表分别执行下列各程序段，并画出结果示意图。 + +![2.4](_v_images/20181125013824965_16208.png) + +**（1）** + +```c +Q=P->next; +``` + +![2.4.1](_v_images/20181125014137666_10327.png) + +**（2）** + +```c +L=P->next; +``` + +![2.4.2](_v_images/20181125014156819_4098.png) + +**（3）** + +```c +R->data=P->data; +``` + +![2.4.3](_v_images/20181125014215622_10158.png) + +**（4）** + +```c +R->data=P->next->data; +``` + +![2.4.4](_v_images/20181125014234236_4049.png) + +**（5）** + +```c +P->next->next->next->data=P->data; +``` + +![2.4.5](_v_images/20181125014248274_14430.png) + +**（6）** + +```c +T=P; +while(T!=NULL) +{ + T->data=T->data*2; + T=T->next; +} +``` + +![2.4.6](_v_images/20181125014311773_4232.png) + +**（7）** + +```c +T=P; +while(T->next!=NULL) +{ + T->data=T->data*2; + T=T->next; +} +``` + +![2.4.7](_v_images/20181125014323122_29833.png) + +### 2.5 画出执行下列各行语句后各指针及链表的示意图。 + +```c +L = (LinkList) malloc (sizeof(LNode)); +P = L; +for(i=1; i<=4; i++) +{ + P->next= (LinkList) malloc (sizeof(LNode)); + P = P->next; + P->data = i*2-1; +} +P->next = NULL; +for(i=4; i>=1; i--) + Ins_LinkList(L, i+1, i*2); +for(i=1; i<=3; i++) + Del_LinkList(L, i); +``` + +![2.5.1](_v_images/20181125014418601_7477.png) +![2.5.2](_v_images/20181125014438821_5785.png) +![2.5.3](_v_images/20181125014451902_15334.png) +![2.5.4](_v_images/20181125014506111_5250.png) + +### 2.6 已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。 +>a.在P结点后插入S结点的语句序列是 （4）（1）。 +>b.在P结点前插入S结点的语句序列是 （7）（11）（8）（4）（1）。 +>c.在表首插入S结点的语句序列是 （5）（12）。 +>d.在表尾插入S结点的语句序列是 （9）（1）（6）。 +> +>（1）P->next=S; +>（2）P->next=P->next->next; +>（3）P->next=S->next; +>（4）S->next=P->next; +>（5）S->next=L; +>（6）S->next=NULL; +>（7）Q=P; +>（8）while(P->next!=Q) +>          P=P->next; +>（9）while(P->next!=NULL) +>          P=P->next; +>（10）P=Q; +>（11）P=L; +>（12）L=S; +>（13）L=P; + +### 2.7 已知L是带表头结点的非空单链表，且P结点既不是首元结点，也不是尾元结点，试从下列提供的答案中选择合适的语句序列。 + +>a.删除P结点的直接后继结点的语句序列是 （11）（3）（14）。 +>b.删除P结点的直接前驱结点的语句序列是 （10）（12）（8）（3）（14）。 +>c.删除P结点的语句序列是 （10）（12）（7）（3）（14）。 +>d.删除首元结点的语句序列是 （12）（11）（3）（14）。 +>e.删除尾元结点的语句序列是 （9）（11）（3）（14）。 +> +>（1）P=P->next; +>（2）P->next=P; +>（3）P->next=P->next->next; +>（4）P=P->next->next; +>（5）while(P!=NULL) +>          P=P->next; +>（6）while(Q->next!=NULL) +>        { +>          P=Q; +>          Q=Q->next; +>        } +>（7）while(P->next!=Q) +>          P=P->next; +>（8）while(P->next->next!=Q) +>          P=P->next; +>（9）while(P->next->next!=NULL) +>          P=P->next; +>（10）Q=P; +>（11）Q=P->next; +>（12）P=L; +>（13）L=L->next; +>（14）free(Q); + +### 2.8 已知P结点是某双向链表的中间结点，试从下列提供的答案中选择合适的语句序列。 + +>a.在P结点后插入S结点的语句序列是 （7）（12）（3）（6）。 +>b.在P结点前插入S结点的语句序列是 （8）（4）（5）（13）。 +>c.删除P结点的直接后继结点的语句序列是 （15）（1）（11）（18）。 +>d.删除P结点的直接前驱结点的语句序列是 （16）（2）（10）（18）。 +>e.删除P结点的语句序列是 （14）（9）（17）。 +> +>（1）P->next=P->next->next; +>（2）P->priou=P->priou->priou; +>（3）P->next=S; +>（4）P->priou=S; +>（5）S->next=P; +>（6）S->priou=P; +>（7）S->next=P->next; +>（8）S->priou=P-priou; +>（9）P->priou->next=P->next; +>（10）P->priou->next=P; +>（11）P->next->priou=P; +>（12）P->next->priou=S; +>（13）P->priou->next=S; +>（14）P->next->priou=P->priou; +>（15）Q=P->next; +>（16）Q=P->priou; +>（17）free(P); +>（18）free(Q); + +### 2.9 简述下列算法的功能。 + +**（1）** + +```c +Status A(LinkedList L) //L是无表头结点的单链表 +{ + if(L&&L->next) + { + Q=L; + L=L->next; + P=L; + while(P->next) + P=P->next; + P->next=Q; + Q->next=NULL; + } + return OK; +}//A +``` + +> （1）如果L的长度不小于2，则将首元结点删去并插入表尾。 + +**（2）** + +```c +void BB(LNode *s, LNode *q) +{ + p=s; + while(p->next!=q) + p=p->next; + p->next=s; +}//BB +void AA(LNode *pa, LNode *pb) +{//pa和pb分别指向单循环链表中的两个结点 + BB(pa, pb); + BB(pb, pa); +}//AA +``` + +> （2）将单循环链表拆成两个单循环链表。 + +## 二、算法设计题 + +##### 本章算法题目涉及的顺序表和线性链表的类型定义如下： + +```c +#define LIST_INIT_SIZE 100 +#define LISTINCREMENT 10 +typedef struct +{ + ElemType *elem; //存储空间基址 + int length; //当前长度 + int listsize; //当前分配的存储容量 +}SqList; //顺序表类型 + +// 注：此文档中，ElemType被定义为int类型。 + +typedef struct LNode +{ + ElemType data; + Struct Lnode *next; +}LNode, *LinkList; //线性链表类型 +``` + +### 2.10 指出以下算法的错误和低效（即费时）之处，并将它改写为一个既正确又高效的算法。 + +```c +Status DeleteK(SqList &a, int i, int k) +{ //本过程从顺序存储结构的线性表a中删除第i个元素起的k个元素 + if(i<1 || k<0 || i+k>a.length) + return INFEASIBLE; //参数不合法 + else + for(count=1; count=i+1; j--) + a.elem[j-1] = a.elem[j]; + a.length--; + } + return OK; +} //DeleteK +``` + +>错误有两处： +>（1）参数不合法的判别条件不完整。合法的入口参数条件为：(0（2）第二个for语句中，元素前移的次序错误。 +>         低效之处是每次删除一个元素的策略。 + +---------- + +### 2.11 设顺序表va中的数据元素递增有序。试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性。 + +---------- + +### 2.12 设A=(a1,...,an)和B=(b1,...,bn)均为顺序表，A'和B'分别为A和B中除去最大共同前缀后的子表（例如，A=(x,y,y,z,x,z)，B=(x,y,y,z,y,x,x,z)，则两者中最大的共同前缀为(x,y,y,z)，在两表中除去最大共同前缀后的子表分别为A'=(x,z)和B'=(y,x,x,z)）。若A'=B'=空表，则A=B；若A'=空表，而B'≠空表，或者两者均不为空表，且A'的首元小于B'的首元，则AB。试写一个比较A，B大小的算法（请注意：在算法中，不要破坏原表A和B，并且，也不一定先求得A'和B'才进行比较）。 + +---------- + +### 2.13 试写一算法在带头结点的单链表结构上实现线性表操作LOCATE(L,X)。 + +---------- + +### 2.14 试写一算法在带头结点的单链表结构上实现线性表操作LENGTH(L)。 + +---------- + +### 2.15 已知指针ha和hb分别指向两个单链表的头结点，并且已知两个链表的长度分别为m和n。试写一算法将这两个链表连接在一起（即令其中一个表的首元结点连在另一个表的最后一个结点之后），假设指针hc指向连接后的链表的头结点，并要求算法以尽可能短的时间完成连接运算。请分析你的算法和时间复杂度。 + +---------- + +### 2.16 已知指针la和lb分别指向两个无头结点单链表中的首元结点。下列算法是从表la中删除自第i个元素起共len个元素后，将它们插入到表lb中的第j个元素之前。试问此算法是否正确？如有错，则请改正之。 + +```c +Status DeleteAndInsertSub (LinkedList la, LinkedList lb, int i, int j, int len) +{ + if(i<0 || j<0 || len<0) + return INFEASIBLE; + p=la; k=1; + while(knext; + k++; + } + q=p; + while(k<=len) + { + q=q->next; + k++; + } + s=lb; + k=1; + while(knext; + k++; + } + s->next=p; + q->next=s->next; + return OK; +} //DeleteAndInsertSub +``` + +### 2.17 试写一算法，在无头结点的动态单链表上实现线性表操作INSERT(L, i, b)，并和在带头结点的动态单链表上实现相同操作的算法进行比较。 + +### 2.18 同2.17题要求。试写一算法，实现线性表操作DELETE(L, i)。 + +---------- + +### 2.19 已知线性表中的元素以值递增有序排列，并以单链表作存储结构。试写一高效的算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素），同时释放被删结点空间，并分析你的算法的时间复杂度（注意：mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。 + +> 时间复杂度分析：最坏的情况是全部扫描完也没找到适合的元素，故时间复杂度与链表长度有关，为O(Length(L))。 + +### 2.20 同2.19题条件（递增有序排列），试写一高效的算法，删除表中所有值相同的多余元素（使得操作后的线性表中所有元素的值均不相同），同时释放被删结点空间，并分析你的算法的时间复杂度。 + +---------- + +### 2.21 试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表(a1, a2, ..., an)逆置为(an, an-1, ..., a1)。 + +---------- + +### 2.22 试写一算法，对单链表实现就地逆置。 + +---------- + +### 2.23 设线性表A=(a1, a2, ..., am)，B=(b1, b2, ..., bn)，试写一个按下列规则合并A，B为线性表C的算法，即使得 +######             C=(a1, b1, ..., am, bm, bm+1, ..., bn) 当m<=n时； +###### 或者     C=(a1, b1, ..., an, bn, an+1, ..., am) 当m>n时。 +### 线性表A，B和C均以单链表作存储结构，且C表利用A表和B表中的结点空间构成。注意：单链表的长度值m和n均未显式存储。 + +---------- + +### 2.24 假设有两个按元素值递增有序排列的线性表A和B，均以单链表作存储结构，请编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许表中含有值相同的元素）排列的线性表C，并要求利用原表（即A表和B表）的结点空间构造C表。 + +---------- + +### 2.25 假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合（即同一表中的元素值各不相同），现要求另辟空间构成一个线性表C，其元素为A和B中元素的交集，且表C中的元素也依值递增有序排列。试对顺序表编写求C的算法。 + +---------- + +### 2.26 要求同2.25题。试对单链表编写求C的算法。 + +---------- + +### 2.27 对2.25题的条件作以下修改，对顺序表重新编写求得表C的算法。 +###### （1）假设在同一表（A或B）中可能存在值相同的元素，但要求新生成的表C中的元素值各不相同； +###### （2）利用A表空间存放表C。 + +---------- + +### 2.28 对2.25题的条件作以下两点修改，对单链表重新编写求得表C的算法。 +###### （1）假设在同一表（A或B）中可能存在值相同的元素，但要求新生成的表C中的元素值各不相同。 +###### （2）利用原表（A表或B表）中的结点构造表C，并释放A表中的无用结点空间。 + +---------- + +### 2.29 已知A，B和C为三个递增有序的线性表，现要求对A表作如下操作：删去那些既在B表中出现，又在C表中出现的元素。试对顺序表编写实现上述操作的算法，并分析你的算法的时间复杂度（注意：同一表中各元素值可能相同）。 + +---------- + +### 2.30 要求同2.29题。试对单链表编写算法，请释放A表中的无用结点空间。 + +---------- + +### 2.31 假设某个单向循环链表的长度大于1，且表中既无头结点也无头指针。已知s为指向链表中某个结点的指针，试编写算法在链表中删除指针s所指结点的前驱结点。 + +---------- + +### 2.32 已知有一个单向循环链表，其每个结点中含三个域：pre，data和next，其中data为数据域，next为指向后继结点的指针域，pre也为指针域，但它的值为空(NULL)，试编写算法将此单向循环链表改为双向循环链表，即使pre称为指向前驱结点的指针域。 + +---------- + +### 2.33 已知由一个线性链表表示的线性表中含有三类字符的数据元素（如：字母字符、数字字符和其他字符），试编写算法将该线性链表分割为三个循环链表，其中每个循环链表表示的线性表中均只含一类字符。 + +---------- + +##### 在2.34至2.36题中，“异或指针双向链表”类型`XorLinkedList`和指针异或函数`XorP`定义为： + +```c +typedef struct XorNode +{ + char data; + struct XorNode LRPtr; +} XorNode, *XorPointer; + +//无头结点的异或指针双向链表 +typedef struct +{ + XorPointer Left, Right; //分别指向链表的左端和右端 +} XorLinkedList; + +XorPointer XorP(XorPointer p, XorPointer q); //指针异或函数XorP返回指针p和q的异或(XOR)值 +``` + +##### 异或表 + +![异或表](_v_images/20181125021743781_1329.png) + +##### 异或指针链表的动态创建过程 + +![异或1](_v_images/20181125021828395_8351.png) +![异或2](_v_images/20181125021843504_17730.png) +![异或3](_v_images/20181125021854448_14854.png) +![异或4](_v_images/20181125021917117_7519.png) +![异或5](_v_images/20181125021939528_12633.png) +![异或6](_v_images/20181125022000822_29327.png) + +### 2.34 假设在算法描述语言中引入指针的二元运算“异或”（用“⊕”表示），若a和b为指针，则a⊕b的运算结果仍为原指针类型，且： +##### a⊕(a⊕b)=(a⊕a)⊕b=b +##### (a⊕b)⊕b=a⊕(b⊕b)=a +### 则可利用一个指针域来实现双向链表L。链表L中的每个结点只含两个域：data域和LRPtr域，其中LRPtr域存放该结点的左邻与右邻结点指针（不存在时为NULL）的异或。若设指针L.Left指向链表中的最左结点，L.Right指向链表中的最右结点，则可实现从左向右或从右向左遍历此双向链表的操作。试写一算法按任一方向依次输出链表中各元素的值。 + +### 2.35 采用2.34题所述的存储结构，写出在第i个结点之前插入一个结点的算法。 + +### 2.36 采用2.34题所述的存储结构，写出删除第i个结点的算法。 + +---------- + +### 2.37 设以带头结点的双向循环链表表示的线性表L=(a1, a2, ..., an)，试写一时间复杂度为O(n)的算法，将L改造为L=(a1, a3, ..., an, ..., a4, a2)。 + +---------- + +### 2.38 设有一个双向循环链表，每个结点中除有pre，data和next三个域外，还增设了一个访问频度域freq。在链表被起用之前，频度域freq的值均初始化为零，而每当对链表进行一次LOCATE(L, x)的操作后，被访问的结点（即元素值等于x的结点）中的频度域freq的值便增1，同时调整链表中结点之间的次序，使其按访问频度非递增的次序顺序排列，以便始终保持被频繁访问的结点总是靠近表头结点，试编写符合上述要求的LOCATE操作的算法。 + +---------- + +##### 在2.39至2.40题中，稀疏多项式采用的顺序存储结构SqPoly定义为 + +```c +typedef struct +{ + int coef; + int exp; +} PolyTerm; +typedef struct +{ //多项式的顺序存储结构 + PolyTerm *data; + int last; +} SqPoly; +``` + +### 2.39 已知稀疏多项式：![2.39](_v_images/20181125022414116_20977.png)，其中n=em>em-1>…>e1≥0，ci≠0(i=1,2,...,m),m≥1。试采用存储量同多项式项数m成正比的顺序存储结构，编写求Pn(x0)的算法(x0为给定值)，并分析你的算法的时间复杂度。 + +> 时间复杂度为O(n)，只与顺序表长度有关。 +### 2.40 采用2.39题给定的条件和存储结构，编写求![2.40](_v_images/20181125022508237_15214.png)的算法，将结果多项式存放在新辟的空间中，并分析你的算法的时间复杂度。 + +---------- + +##### 在2.41至2.42题中，稀疏多项式采用的循环链表存储结构LinkedPoly定义为 + +```c +typedef struct PolyNode +{ + PolyTerm data; + struct PolyNode *next; +} PolyNode, *PolyLink; +typedef PolyLink LinkedPoly; +``` + +### 2.41 试以循环链表作稀疏多项式的存储结构，编写求其导函数的算法，要求利用原多项式中的结点空间存放其导函数（多项式），同时释放所有无用（被删）结点。 + +### 2.42 试编写算法，将一个用循环链表表示的稀疏多项式分解成两个多项式，使这两个多项式中各自仅含奇次项或偶次项，并要求利用原链表中的结点空间构成这两个链表。 + +----------