From 7ba41a35c65995ba5de6844d3bc22721ca7fd6a8 Mon Sep 17 00:00:00 2001 From: Didnelpsun <2675350965@qq.com> Date: Fri, 13 Aug 2021 11:02:33 +0800 Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 12 +- Code/C-Code/C-Code.sln | 31 ++ Code/C-Code/C-Code.vcxproj | 153 +++++++++ Code/C-Code/C-Code.vcxproj.filters | 36 ++ .../C-Code.vcxproj.user} | 0 {CPP-Code => Code/C-Code}/head/head.h | 0 Code/C-Code/head/link_list.h | 114 +++++++ Code/C-Code/head/sequence_list.h | 322 ++++++++++++++++++ Code/C-Code/source/main.c | 10 + Code/C-Code/source/test.c | 45 +++ {CPP-Code => Code/CPP-Code}/CMakeLists.txt | 0 .../CPP-Code}/CMakeSettings.json | 0 Code/{ => CPP-Code/head}/head.h | 0 {CPP-Code => Code/CPP-Code}/head/link_list.h | 0 .../CPP-Code}/head/sequence_list.h | 0 {CPP-Code => Code/CPP-Code}/source/main.cpp | 0 {CPP-Code => Code/CPP-Code}/source/test.cpp | 0 Code/{ => Code}/Code.sln | 0 Code/{ => Code}/Code.vcxproj | 0 Code/{ => Code}/Code.vcxproj.filters | 0 Code/Code/Code.vcxproj.user | 4 + Code/{ => Code}/double_link_list.h | 0 Code/{ => Code}/graph.h | 0 Code/Code/head.h | 8 + Code/{ => Code}/link_list.h | 0 Code/{ => Code}/link_queue.h | 0 Code/{ => Code}/link_stack.h | 0 Code/{ => Code}/link_string.h | 0 Code/{ => Code}/link_tree.h | 0 Code/{ => Code}/main.c | 0 Code/{ => Code}/search.h | 0 Code/{ => Code}/sequence_list.h | 0 Code/{ => Code}/sequence_queue.h | 0 Code/{ => Code}/sequence_stack.h | 0 Code/{ => Code}/sequence_string.h | 0 Code/{ => Code}/sequence_tree.h | 0 Code/{ => Code}/sort.h | 0 Code/{ => Code}/static_link_list.h | 0 Code/{ => Code}/test.c | 0 Code/{ => Code}/thread_tree.h | 0 Operate-System/0-summary-ex.md | 20 ++ 41 files changed, 749 insertions(+), 6 deletions(-) create mode 100644 Code/C-Code/C-Code.sln create mode 100644 Code/C-Code/C-Code.vcxproj create mode 100644 Code/C-Code/C-Code.vcxproj.filters rename Code/{Code.vcxproj.user => C-Code/C-Code.vcxproj.user} (100%) rename {CPP-Code => Code/C-Code}/head/head.h (100%) create mode 100644 Code/C-Code/head/link_list.h create mode 100644 Code/C-Code/head/sequence_list.h create mode 100644 Code/C-Code/source/main.c create mode 100644 Code/C-Code/source/test.c rename {CPP-Code => Code/CPP-Code}/CMakeLists.txt (100%) rename {CPP-Code => Code/CPP-Code}/CMakeSettings.json (100%) rename Code/{ => CPP-Code/head}/head.h (100%) rename {CPP-Code => Code/CPP-Code}/head/link_list.h (100%) rename {CPP-Code => Code/CPP-Code}/head/sequence_list.h (100%) rename {CPP-Code => Code/CPP-Code}/source/main.cpp (100%) rename {CPP-Code => Code/CPP-Code}/source/test.cpp (100%) rename Code/{ => Code}/Code.sln (100%) rename Code/{ => Code}/Code.vcxproj (100%) rename Code/{ => Code}/Code.vcxproj.filters (100%) create mode 100644 Code/Code/Code.vcxproj.user rename Code/{ => Code}/double_link_list.h (100%) rename Code/{ => Code}/graph.h (100%) create mode 100644 Code/Code/head.h rename Code/{ => Code}/link_list.h (100%) rename Code/{ => Code}/link_queue.h (100%) rename Code/{ => Code}/link_stack.h (100%) rename Code/{ => Code}/link_string.h (100%) rename Code/{ => Code}/link_tree.h (100%) rename Code/{ => Code}/main.c (100%) rename Code/{ => Code}/search.h (100%) rename Code/{ => Code}/sequence_list.h (100%) rename Code/{ => Code}/sequence_queue.h (100%) rename Code/{ => Code}/sequence_stack.h (100%) rename Code/{ => Code}/sequence_string.h (100%) rename Code/{ => Code}/sequence_tree.h (100%) rename Code/{ => Code}/sort.h (100%) rename Code/{ => Code}/static_link_list.h (100%) rename Code/{ => Code}/test.c (100%) rename Code/{ => Code}/thread_tree.h (100%) diff --git a/.gitignore b/.gitignore index 8596ef1..fd077bc 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,7 @@ *.pdf -*/.vs/ -*/.idea/ -*/Debug/ -*/x64/ -*/out/ -*/cmake-build-debug/ \ No newline at end of file +*.vs/ +*.idea/ +*Debug/ +*x64/ +*out/ +*cmake-build-debug/ \ No newline at end of file diff --git a/Code/C-Code/C-Code.sln b/Code/C-Code/C-Code.sln new file mode 100644 index 0000000..7383438 --- /dev/null +++ b/Code/C-Code/C-Code.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.31605.320 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "C-Code", "C-Code.vcxproj", "{0097210B-6B4C-4528-90F7-28DC333772CF}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {0097210B-6B4C-4528-90F7-28DC333772CF}.Debug|x64.ActiveCfg = Debug|x64 + {0097210B-6B4C-4528-90F7-28DC333772CF}.Debug|x64.Build.0 = Debug|x64 + {0097210B-6B4C-4528-90F7-28DC333772CF}.Debug|x86.ActiveCfg = Debug|Win32 + {0097210B-6B4C-4528-90F7-28DC333772CF}.Debug|x86.Build.0 = Debug|Win32 + {0097210B-6B4C-4528-90F7-28DC333772CF}.Release|x64.ActiveCfg = Release|x64 + {0097210B-6B4C-4528-90F7-28DC333772CF}.Release|x64.Build.0 = Release|x64 + {0097210B-6B4C-4528-90F7-28DC333772CF}.Release|x86.ActiveCfg = Release|Win32 + {0097210B-6B4C-4528-90F7-28DC333772CF}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {D42A6D35-5080-4B03-A977-17AEC5B1ED3D} + EndGlobalSection +EndGlobal diff --git a/Code/C-Code/C-Code.vcxproj b/Code/C-Code/C-Code.vcxproj new file mode 100644 index 0000000..45af98f --- /dev/null +++ b/Code/C-Code/C-Code.vcxproj @@ -0,0 +1,153 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + Win32Proj + {0097210b-6b4c-4528-90f7-28dc333772cf} + CCode + 10.0 + + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + false + + + true + + + false + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Code/C-Code/C-Code.vcxproj.filters b/Code/C-Code/C-Code.vcxproj.filters new file mode 100644 index 0000000..7cac836 --- /dev/null +++ b/Code/C-Code/C-Code.vcxproj.filters @@ -0,0 +1,36 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;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/Code/Code.vcxproj.user b/Code/C-Code/C-Code.vcxproj.user similarity index 100% rename from Code/Code.vcxproj.user rename to Code/C-Code/C-Code.vcxproj.user diff --git a/CPP-Code/head/head.h b/Code/C-Code/head/head.h similarity index 100% rename from CPP-Code/head/head.h rename to Code/C-Code/head/head.h diff --git a/Code/C-Code/head/link_list.h b/Code/C-Code/head/link_list.h new file mode 100644 index 0000000..b5efa6f --- /dev/null +++ b/Code/C-Code/head/link_list.h @@ -0,0 +1,114 @@ +#include +#include +#include "head.h" + +// +typedef struct LinkListNode { + element_type data; + struct LinkListNode* next; +} LinkListNode, *LinkList; + +// C޷ֵԱһм +// ʼͷڵ㵥 +int InitLinkListWithHead(LinkList list) { + if (list) { + list->data = NULL; + list->next = NULL; + return 0; + } + else { + printf("InitLinkListWithHead:ָΪ޷ʼ"); + return 1; + } +} + +// C޷ʵֳʼΪ޷ʵôݣֵܸ +// ʼͷڵ㵥 +int InitLinkListWithoutHead(LinkList list) { + list = NULL; + return 0; +} + +// ͷڵ㵥 +LinkList CreateLinkListWithHead() { + LinkList list = (LinkListNode*)malloc(sizeof(LinkListNode)); + if (list) { + list->data = NULL; + list->next = NULL; + } + else { + printf("CreateLinkListWithHead:ռʧܣ"); + } + return list; +} + +// ͷڵ㵥 +LinkList CreateLinkListWithoutHead() { + return NULL; +} + + +// жͷڵ㵥ǷΪ +int EmptyLinkListWithHead(LinkList list) { + if (list->next) { + return 0; + } + else { + return 1; + } +} + +// жͷڵ㵥ǷΪ +int EmptyLLinkListWithoutHead(LinkList list) { + if (list) { + return 0; + } + else { + return 1; + } +} + +// ͷڵ㵥Ԫ +// 0Žڵͷڵ +int InsertLinkListWithHead(LinkList list, int index, element_type elem) { + if (index < 1) { + printf("InsertLinkListWithHead:ֵС\n"); + return 1; + } + // һָpָǰɨ赽Ľ + LinkListNode* p; + // һiʾǰɨ赽Ľ + int i = 0; + // ͷָpΪ0 + p = list; + // ѭָŵĵĽ + // ǵǰһΪŵĽһǿս + while (p->next != NULL && i < index - 1) { + p = p->next; + i++; + } + // ʱiСindex-1ʾ껹ûеӦ + if (i < index - 1) { + printf("InsertLinkListWithHead:ֵ\n"); + return 1; + } + // ʱi==index-1 + LinkListNode* s = (LinkListNode*)malloc(sizeof(LinkListNode)); + if (s) { + s->data = elem; + // pԭĺ̸µĽ + s->next = p->next; + p->next = s; + return 0; + } + else { + printf("InsertLinkListWithHead:ڴʧܣ\n"); + return 1; + } +} + +// ͷڵ㵥Ԫ +// CҲ޷ +int InsertLinkListWithoutHead(LinkList list, int index, element_type elem) { + return 1; +} \ No newline at end of file diff --git a/Code/C-Code/head/sequence_list.h b/Code/C-Code/head/sequence_list.h new file mode 100644 index 0000000..d2ad597 --- /dev/null +++ b/Code/C-Code/head/sequence_list.h @@ -0,0 +1,322 @@ +#include +#include +#include "head.h" + +#pragma warning(disable:6385) +#pragma warning(disable:6386) + +// 静态顺序表 +typedef struct { + element_type data[MAXSIZE]; + // 长度 + int length; +} StaticSequenceList; + +// 动态顺序表 +typedef struct { + // 给一个指针来分配动态数组 + element_type *data; + // 已分配的最大容量 + int max_size; + // 长度 + int length; +} DynamicSequenceList; + +// 初始化静态顺序表 +int InitStaticSequenceList(StaticSequenceList* list) { + if (list) { + // 初初始化静态顺序表长度为0 + list->length = 0; + return 0; + } + else { + printf("InitStaticSequenceList:指针指向为NULL！\n"); + return 1; + } +} + +// 初始化动态顺序表 +int InitDynamicSequenceList(DynamicSequenceList* list) { + if (list) { + // 初初始化动态顺序表长度为0 + list->length = 0; + list->max_size = 0; + // 申请一片连续的存储空间 + element_type* space = (element_type*)malloc(MAXSIZE * sizeof(element_type)); + if (space) { + list->data = space; + list->max_size = MAXSIZE; + return 0; + } + else { + printf("InitDynamicSequenceList:分配空间失败！\n"); + return 1; + } + } + else { + printf("InitDynamicSequenceList:指针指向为NULL！\n"); + return 1; + } +} + +// 打印静态顺序表 +int PrintfStaticSequenceList(StaticSequenceList list) { + for (int i = 0; i < list.length; i++) { + printf("第%d个元素值为%c\n", i + 1, list.data[i]); + } + return 0; +} + +// 打印动态顺序表 +int PrintfDynamicSequenceList(DynamicSequenceList list) { + for (int i = 0; i < list.length; i++) { + printf("第%d个元素值为%c\n", i + 1, list.data[i]); + } + return 0; +} + +// 分配其他地址增长动态顺序表的数据空间长度 +int OtherIncreaseDynamicSequenceList(DynamicSequenceList* list, int len) { + if (len <= 0) { + printf("OtherIncreaseDynamicSequenceList:申请空间应该大于0！\n"); + return 1; + } + // 申请一片连续的存储空间 + int new_length = list->max_size + len; + element_type* space = (element_type*)malloc(new_length * sizeof(element_type)); + if (space) { + // 建立中间变量 + list->data = space; + element_type* temp = list->data; + for (int i = 0; i < list->length; i++) { + list->data[i] = temp[i]; + } + list->max_size = new_length; + free(temp); + return 0; + } + else { + printf("OtherIncreaseDynamicSequenceList:重新分配空间失败！\n"); + return 1; + } +} + +// 重新分配地址增长动态顺序表的数据空间长度 +int ReIncreaseDynamicSequenceList(DynamicSequenceList* list, int len) { + if (len <= 0) { + printf("ReIncreaseDynamicSequenceList:申请空间应该大于0！\n"); + return 1; + } + // 申请一片连续的存储空间 + int new_length = list->max_size + len; + element_type* space = (element_type*)realloc(list->data, new_length * sizeof(element_type)); + if (space) { + list->data = space; + list->max_size += len; + return 0; + } + else { + list->max_size = 0; + list->length = 0; + printf("ReIncreaseDynamicSequenceList:分配其他地址空间失败！\n"); + return 1; + } +} + +// 插入静态顺序表 +int InsertStaticSequenceList(StaticSequenceList* list, int index, element_type elem) { + // 当静态顺序表已经满了就不能插入任何元素 + if (list->length >= MAXSIZE) { + printf("InsertStaticSequenceList:静态顺序表空间不足，插入失败！\n"); + return 1; + } + // 索引位置从0开始，所以可以插入的范围是0到list->length + if (index > list->length || index < 0) { + printf("InsertStaticSequenceList:插入索引%d超过索引范围！\n", index); + return 1; + } + // 从最后一个元素开始交换后移，list->length是空的 + for (int i = list->length; i > index; i--) { + list->data[i] = list->data[i - 1]; + } + list->data[index] = elem; + list->length++; + return 0; +} + +// 插入动态顺序表 +int InsertDynamicSequenceList(DynamicSequenceList* list, int index, element_type elem) { + if (index > list->length || index < 0) { + printf("InsertDynamicSequenceList:插入索引%d超过索引范围！\n", index); + return 1; + } + // 当动态顺序表已经满了，需要新增一个位置 + // 为了避免索引无效而多增加一个空间，所以放在检查索引值的后面 + if (list->length >= MAXSIZE) { + int result = ReIncreaseDynamicSequenceList(list, 1); + if (result == 1) { + printf("InsertDynamicSequenceList:申请空间失败！\n"); + return 1; + } + } + for (int i = list->length; i > index; i--) { + list->data[i] = list->data[i - 1]; + } + list->data[index] = elem; + list->length++; + return 0; +} + +// 循环插入静态顺序表 +int LoopInsertStaticSequenceList(StaticSequenceList* list, element_type* elem, int start, int end) { + for (int i = 0; i < end; i++) { + int result = InsertStaticSequenceList(list, i, elem[i + start]); + if (result == 1) { + printf("LoopInsertStaticSequenceList:循环插入失败！\n"); + return 1; + } + } + return 0; +} + +// 循环插入动态顺序表 +int LoopInsertDynamicSequenceList(DynamicSequenceList* list, element_type* elem, int start, int end) { + for (int i = 0; i < end; i++) { + int result = InsertDynamicSequenceList(list, i, elem[i + start]); + if (result == 1) { + printf("LoopInsertDynamicSequenceList:循环插入失败！\n"); + return 1; + } + } + return 0; +} + +// 删除静态顺序表 +int DeleteStaticSequenceList(StaticSequenceList* list, int index, element_type *elem) { + if (index >= list->length || index < 0) { + printf("DeleteStaticSequenceList:删除索引超过索引范围！\n"); + return 1; + } + *elem = list->data[index]; + for (int i = index; i < list->length; i++) { + list->data[i] = list->data[i + 1]; + } + list->length--; + return 0; +} + +// 删除动态顺序表 +int DeleteDynamicSequenceList(DynamicSequenceList* list, int index, element_type *elem) { + if (index >= list->length || index < 0) { + printf("DeleteDynamicSequenceList:删除索引超过索引范围！\n"); + return 1; + } + *elem = list->data[index]; + for (int i = index; i < list->length; i++) { + list->data[i] = list->data[i + 1]; + } + list->length--; + return 0; +} + +// 删除多个静态顺序表 +int MultiDeleteStaticSequenceList(StaticSequenceList* list, int index, int len, element_type* elem) { + if (index + len >= list->length || index < 0) { + printf("MultiDeleteStaticSequenceList:删除索引超过索引范围！\n"); + return 1; + } + for (int i = index; i < list->length - len; i++) { + if (i < index + len) { + elem[i - index] = list->data[i]; + } + list->data[i] = list->data[i + len]; + } + list->length -= len; + return 0; +} + +// 删除多个动态顺序表 +int MultiDeleteDynamicSequenceList(DynamicSequenceList* list, int index, int len, element_type* elem) { + if (index + len >= list->length || index < 0) { + printf("MultiDeleteDynamicSequenceList:删除索引超过索引范围！\n"); + return 1; + } + for (int i = index; i < list->length - len; i++) { + if (i < index + len) { + elem[i - index] = list->data[i]; + } + list->data[i] = list->data[i + len]; + } + list->length -= len; + return 0; +} + +// 按位查找静态顺序表元素 +element_type GetStaticSequenceListElement(StaticSequenceList list, int index) { + if (index >= list.length || index < 0) { + printf("GetStaticSequenceListElement:查找索引超过索引范围！\n"); + return DEFAULTELEM; + } + return list.data[index]; +} + +// 按位查找动态顺序表元素 +element_type GetDynamicSequenceListElement(DynamicSequenceList list, int index) { + if (index >= list.length || index < 0) { + printf("GetDynamicSequenceListElement:查找索引超过索引范围！\n"); + return DEFAULTELEM; + } + return list.data[index]; +} + +// 按值查找静态顺序表索引 +int LocateStaticSequenceListElement(StaticSequenceList list, element_type elem) { + for (int i = 0; i < list.length; i++) { + if (list.data[i] == elem) { + return i; + } + } + printf("LocateStaticSequenceListElement:未能定位到对应值的元素！\n"); + return -1; +} + +// 按值查找动态顺序表索引 +int LocateDynamicSequenceListElement(DynamicSequenceList list, element_type elem) { + for (int i = 0; i < list.length; i++) { + if (list.data[i] == elem) { + return i; + } + } + printf("LocateDynamicSequenceListElement:未能定位到对应值的元素！\n"); + return -1; +} + +// 判空静态顺序表 +int EmptyStaticSequenceList(StaticSequenceList list) { + if (list.length == 0) { + return 1; + } + else { + return 0; + } +} + +// 判空动态顺序表 +int EmptyDynamicSequenceList(DynamicSequenceList list) { + if (list.length == 0) { + return 1; + } + else { + return 0; + } +} + +// 销毁动态顺序表 +int DestroyDynamicSequenceList(DynamicSequenceList* list) { + if (list != NULL) { + free(list->data); + } + list = NULL; + return 0; +} + diff --git a/Code/C-Code/source/main.c b/Code/C-Code/source/main.c new file mode 100644 index 0000000..c784272 --- /dev/null +++ b/Code/C-Code/source/main.c @@ -0,0 +1,10 @@ +#include +#include + + +int main() +{ + //SequenceListTest(); + LinkListTest(); + return 0; +} \ No newline at end of file diff --git a/Code/C-Code/source/test.c b/Code/C-Code/source/test.c new file mode 100644 index 0000000..d58f551 --- /dev/null +++ b/Code/C-Code/source/test.c @@ -0,0 +1,45 @@ +// ļ + +#include "../Head/sequence_list.h" +#include "../Head/link_list.h" + +int SequenceListTest() { + DynamicSequenceList list; + InitDynamicSequenceList(&list); + element_type a[6] = {'1','2','3','4','5','6'}; + LoopInsertDynamicSequenceList(&list, a, 0, 6); + element_type b[3] = { 9, 'a', 'e' }; + LoopInsertDynamicSequenceList(&list, b, 1, 2); + //printf("%d", list.length); + PrintfDynamicSequenceList(list); + printf("\n"); + int len = 2; + element_type elem[2]; + MultiDeleteDynamicSequenceList(&list, 0, len, elem); + PrintfDynamicSequenceList(list); + for (int i = 0; i < len; i++) { + printf("%c\n", elem[i]); + } + /*DynamicSequenceList dlist; + InitDynamicSequenceList(&dlist); + OtherIncreaseDynamicSequenceList(&dlist, 15); + printf("%d", dlist.max_size);*/ + /*int index = LocateDynamicSequenceListElement(list, '5'); + printf("%d", index); + DestroyDynamicSequenceList(&list);*/ + return 0; +} + +int LinkListTest() { + /*LinkListNode node; + InitLinkListWithHead(&node); + LinkList list = &node;*/ + LinkList list = CreateLinkListWithHead(); + /*int empty = EmptyLinkListWithHead(list);*/ + /*LinkList list = CreateLinkListWithoutHead(); + int empty = EmptyLLinkListWithoutHead(list); + printf("%d", empty);*/ + InsertLinkListWithHead(list, 1, '0'); + return 0; +} + diff --git a/CPP-Code/CMakeLists.txt b/Code/CPP-Code/CMakeLists.txt similarity index 100% rename from CPP-Code/CMakeLists.txt rename to Code/CPP-Code/CMakeLists.txt diff --git a/CPP-Code/CMakeSettings.json b/Code/CPP-Code/CMakeSettings.json similarity index 100% rename from CPP-Code/CMakeSettings.json rename to Code/CPP-Code/CMakeSettings.json diff --git a/Code/head.h b/Code/CPP-Code/head/head.h similarity index 100% rename from Code/head.h rename to Code/CPP-Code/head/head.h diff --git a/CPP-Code/head/link_list.h b/Code/CPP-Code/head/link_list.h similarity index 100% rename from CPP-Code/head/link_list.h rename to Code/CPP-Code/head/link_list.h diff --git a/CPP-Code/head/sequence_list.h b/Code/CPP-Code/head/sequence_list.h similarity index 100% rename from CPP-Code/head/sequence_list.h rename to Code/CPP-Code/head/sequence_list.h diff --git a/CPP-Code/source/main.cpp b/Code/CPP-Code/source/main.cpp similarity index 100% rename from CPP-Code/source/main.cpp rename to Code/CPP-Code/source/main.cpp diff --git a/CPP-Code/source/test.cpp b/Code/CPP-Code/source/test.cpp similarity index 100% rename from CPP-Code/source/test.cpp rename to Code/CPP-Code/source/test.cpp diff --git a/Code/Code.sln b/Code/Code/Code.sln similarity index 100% rename from Code/Code.sln rename to Code/Code/Code.sln diff --git a/Code/Code.vcxproj b/Code/Code/Code.vcxproj similarity index 100% rename from Code/Code.vcxproj rename to Code/Code/Code.vcxproj diff --git a/Code/Code.vcxproj.filters b/Code/Code/Code.vcxproj.filters similarity index 100% rename from Code/Code.vcxproj.filters rename to Code/Code/Code.vcxproj.filters diff --git a/Code/Code/Code.vcxproj.user b/Code/Code/Code.vcxproj.user new file mode 100644 index 0000000..88a5509 --- /dev/null +++ b/Code/Code/Code.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Code/double_link_list.h b/Code/Code/double_link_list.h similarity index 100% rename from Code/double_link_list.h rename to Code/Code/double_link_list.h diff --git a/Code/graph.h b/Code/Code/graph.h similarity index 100% rename from Code/graph.h rename to Code/Code/graph.h diff --git a/Code/Code/head.h b/Code/Code/head.h new file mode 100644 index 0000000..3ea11c5 --- /dev/null +++ b/Code/Code/head.h @@ -0,0 +1,8 @@ +// ʼ󳤶 +#define MAXSIZE 5 +// Ĭֵ +#define DEFAULTELEM '0' +// ֵ +#define INFINITY 32767 +// Ĭ +typedef char element_type; diff --git a/Code/link_list.h b/Code/Code/link_list.h similarity index 100% rename from Code/link_list.h rename to Code/Code/link_list.h diff --git a/Code/link_queue.h b/Code/Code/link_queue.h similarity index 100% rename from Code/link_queue.h rename to Code/Code/link_queue.h diff --git a/Code/link_stack.h b/Code/Code/link_stack.h similarity index 100% rename from Code/link_stack.h rename to Code/Code/link_stack.h diff --git a/Code/link_string.h b/Code/Code/link_string.h similarity index 100% rename from Code/link_string.h rename to Code/Code/link_string.h diff --git a/Code/link_tree.h b/Code/Code/link_tree.h similarity index 100% rename from Code/link_tree.h rename to Code/Code/link_tree.h diff --git a/Code/main.c b/Code/Code/main.c similarity index 100% rename from Code/main.c rename to Code/Code/main.c diff --git a/Code/search.h b/Code/Code/search.h similarity index 100% rename from Code/search.h rename to Code/Code/search.h diff --git a/Code/sequence_list.h b/Code/Code/sequence_list.h similarity index 100% rename from Code/sequence_list.h rename to Code/Code/sequence_list.h diff --git a/Code/sequence_queue.h b/Code/Code/sequence_queue.h similarity index 100% rename from Code/sequence_queue.h rename to Code/Code/sequence_queue.h diff --git a/Code/sequence_stack.h b/Code/Code/sequence_stack.h similarity index 100% rename from Code/sequence_stack.h rename to Code/Code/sequence_stack.h diff --git a/Code/sequence_string.h b/Code/Code/sequence_string.h similarity index 100% rename from Code/sequence_string.h rename to Code/Code/sequence_string.h diff --git a/Code/sequence_tree.h b/Code/Code/sequence_tree.h similarity index 100% rename from Code/sequence_tree.h rename to Code/Code/sequence_tree.h diff --git a/Code/sort.h b/Code/Code/sort.h similarity index 100% rename from Code/sort.h rename to Code/Code/sort.h diff --git a/Code/static_link_list.h b/Code/Code/static_link_list.h similarity index 100% rename from Code/static_link_list.h rename to Code/Code/static_link_list.h diff --git a/Code/test.c b/Code/Code/test.c similarity index 100% rename from Code/test.c rename to Code/Code/test.c diff --git a/Code/thread_tree.h b/Code/Code/thread_tree.h similarity index 100% rename from Code/thread_tree.h rename to Code/Code/thread_tree.h diff --git a/Operate-System/0-summary-ex.md b/Operate-System/0-summary-ex.md index d7e52aa..18eac54 100644 --- a/Operate-System/0-summary-ex.md +++ b/Operate-System/0-summary-ex.md @@ -270,4 +270,24 @@ $D.$仅Ⅱ、Ⅲ、Ⅳ 解：$C$。用户可以在用户态调用操作系统的服务，但执行具体的系统调用服务程序是处于内核态的，Ⅰ正确；设备管理属于操作系统的职能之一，包括对输入/输出设备的分配、初始化、维护等，用户程序需要通过系统调用使用操作系统的设备管理服务，Ⅱ正确；操作系统不同，底层逻辑、实现方式均不相同，为应用程序提供的系统调用接口也不同，Ⅲ错误；系统调用是用户在程序中调用操作系统提供的子功能，Ⅳ正确。 +**例题** 相对于传统操作系统结构，采用微内核结构设计和实现操作系统具有诸多好处，下列()是微内核结构的特点。 + +Ⅰ.使系统更高效 + +Ⅱ.添加系统服务时，不必修改内核 + +Ⅲ.微内核结构没有单一内核稳定 + +Ⅳ.使系统更可靠 + +$A.$Ⅰ、Ⅲ、Ⅳ + +$B.$Ⅰ、Ⅱ、Ⅳ + +$C.$Ⅱ、Ⅳ + +$D.$Ⅰ、Ⅳ + +解：$C$。微内核结构将操作系统的很多服务移动到内核以外（如文件系统），且服务之间使用进程间通信机制进行信息交换，这种通过进程间通信机制进行的信息交换影响了系统的效率，所以Ⅰ错。由于内核的服务变少，且一般来说内核的服务越少内核越稳定，所以Ⅲ错。而Ⅱ、Ⅳ正是微内核结构的优点。 + [gantt]:data:image/png;base64,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 \ No newline at end of file