Copy disabled (too large)
Download .txt
Showing preview only (17,728K chars total). Download the full file to get everything.
Repository: Didnelpsun/CS408
Branch: main
Commit: d438ec44778a
Files: 110
Total size: 16.2 MB
Directory structure:
gitextract_pv185ee9/
├── .gitignore
├── Code/
│ ├── C-Code/
│ │ ├── C-Code.sln
│ │ ├── C-Code.vcxproj
│ │ ├── C-Code.vcxproj.filters
│ │ ├── C-Code.vcxproj.user
│ │ ├── head/
│ │ │ ├── head.h
│ │ │ ├── link_list.h
│ │ │ └── sequence_list.h
│ │ └── source/
│ │ ├── main.c
│ │ └── test.c
│ ├── CPP-Code/
│ │ ├── CMakeSettings.json
│ │ ├── head/
│ │ │ ├── double_link_list.h
│ │ │ ├── dynamic_sequence_list.h
│ │ │ ├── head.h
│ │ │ ├── link_list.h
│ │ │ ├── link_list_with_head.h
│ │ │ ├── link_list_without_head.h
│ │ │ ├── link_queue.h
│ │ │ ├── link_stack.h
│ │ │ ├── link_string.h
│ │ │ ├── list.h
│ │ │ ├── sequence_list.h
│ │ │ ├── sequence_queue.h
│ │ │ ├── sequence_stack.h
│ │ │ ├── sequence_string.h
│ │ │ ├── share_stack.h
│ │ │ ├── static_link_list.h
│ │ │ └── static_sequence_list.h
│ │ └── source/
│ │ ├── main.cpp
│ │ └── test.cpp
│ └── Code/
│ ├── CMakeSettings.json
│ ├── head/
│ │ ├── double_link_list.h
│ │ ├── graph.h
│ │ ├── head.h
│ │ ├── link_list.h
│ │ ├── link_queue.h
│ │ ├── link_stack.h
│ │ ├── link_string.h
│ │ ├── link_tree.h
│ │ ├── search.h
│ │ ├── sequence_list.h
│ │ ├── sequence_queue.h
│ │ ├── sequence_stack.h
│ │ ├── sequence_string.h
│ │ ├── share_stack.h
│ │ ├── sort.h
│ │ ├── static_link_list.h
│ │ ├── thread_tree.h
│ │ └── tree.h
│ └── source/
│ ├── main.cpp
│ └── test.cpp
├── Computer-Network/
│ ├── 0-summary-ex.md
│ ├── 0-summary.md
│ ├── 1-physical-layer-ex.md
│ ├── 1-physical-layer.md
│ ├── 2-data-link-layer-ex.md
│ ├── 2-data-link-layer.md
│ ├── 3-network-layer-ex.md
│ ├── 3-network-layer.md
│ ├── 4-transport-layer-ex.md
│ ├── 4-transport-layer.md
│ ├── 5-application-layer-ex.md
│ └── 5-application-layer.md
├── Computer-Organization/
│ ├── 0-summary-ex.md
│ ├── 0-summary.md
│ ├── 1-data-representation-and-operation-ex.md
│ ├── 1-data-representation-and-operation.md
│ ├── 2-storage-system-ex.md
│ ├── 2-storage-system.md
│ ├── 3-instruction-system-ex.md
│ ├── 3-instruction-system.md
│ ├── 4-central-processing-unit-ex.md
│ ├── 4-central-processing-unit.md
│ ├── 5-bus-ex.md
│ ├── 5-bus.md
│ ├── 6-input-output-system-ex.md
│ ├── 6-input-output-system.md
│ └── 7-assembler.md
├── Data-Structrue/
│ ├── 0-summary-ex.md
│ ├── 0-summary.md
│ ├── 1-linear-list-ex.md
│ ├── 1-linear-list.md
│ ├── 2-stack-ex.md
│ ├── 2-stack.md
│ ├── 3-queue-ex.md
│ ├── 3-queue.md
│ ├── 4-array-ex.md
│ ├── 4-array.md
│ ├── 5-string-ex.md
│ ├── 5-string.md
│ ├── 6-tree-ex.md
│ ├── 6-tree.md
│ ├── 7-graph-ex.md
│ ├── 7-graph.md
│ ├── 8-search-ex.md
│ ├── 8-search.md
│ ├── 9-sort-ex.md
│ └── 9-sort.md
├── Operate-System/
│ ├── 0-summary-ex.md
│ ├── 0-summary.md
│ ├── 1-process-management-ex.md
│ ├── 1-process-management.md
│ ├── 2-memory-management-ex.md
│ ├── 2-memory-management.md
│ ├── 3-file-management-ex.md
│ ├── 3-file-management.md
│ ├── 4-device-management-ex.md
│ └── 4-device-management.md
├── README.md
└── merge（工具程序，不要乱点，用前进去改路径！！）.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
*.pdf
*.doc
*.docx
*.png
*.jpg
*.jpeg
*.html
*.htm
*.vs/
*.vscode/
*.txt
*.idea/
*Debug/
*x64/
*out/
*build.mingw/
*build.default/
*build.wsl/
*build.cygwin/
*build/
================================================
FILE: Code/C-Code/C-Code.sln
================================================
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
================================================
FILE: Code/C-Code/C-Code.vcxproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>16.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{0097210b-6b4c-4528-90f7-28dc333772cf}</ProjectGuid>
<RootNamespace>CCode</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v142</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="source\main.c" />
<ClCompile Include="source\test.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="head\head.h" />
<ClInclude Include="head\link_list.h" />
<ClInclude Include="head\sequence_list.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
================================================
FILE: Code/C-Code/C-Code.vcxproj.filters
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="源文件">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="头文件">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
</Filter>
<Filter Include="资源文件">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="source\main.c">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="source\test.c">
<Filter>源文件</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="head\head.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="head\link_list.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="head\sequence_list.h">
<Filter>头文件</Filter>
</ClInclude>
</ItemGroup>
</Project>
================================================
FILE: Code/C-Code/C-Code.vcxproj.user
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>
================================================
FILE: Code/C-Code/head/head.h
================================================
// ʼ
#define MAXSIZE 5
// Ĭֵ
#define DEFAULTELEM '0'
// ֵ
#define INFINITY 32767
// Ĭ
typedef char element_type;
================================================
FILE: Code/C-Code/head/link_list.h
================================================
#include <stdio.h>
#include <stdlib.h>
#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;
}
================================================
FILE: Code/C-Code/head/sequence_list.h
================================================
#include <stdio.h>
#include <stdlib.h>
#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;
}
================================================
FILE: Code/C-Code/source/main.c
================================================
#include <stdio.h>
#include <stdlib.h>
int main()
{
//SequenceListTest();
LinkListTest();
return 0;
}
================================================
FILE: Code/C-Code/source/test.c
================================================
// ļ
#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;
}
================================================
FILE: Code/CPP-Code/CMakeSettings.json
================================================
{
"configurations": [
{
"name": "x64-Debug",
"generator": "Ninja",
"configurationType": "Debug",
"inheritEnvironments": [ "msvc_x64_x64" ],
"buildRoot": "${projectDir}\\out\\build\\${name}",
"installRoot": "${projectDir}\\out\\install\\${name}"
}
]
}
================================================
FILE: Code/CPP-Code/head/double_link_list.h
================================================
#include "head.h"
// 单链表结点
class DoubleLinkListNode {
private:
// 数据
element_type _data{};
// 指针
DoubleLinkListNode *_prior{}, *_next{};
public:
// 设置数据
bool SetData(element_type elem);
// 获取数据
element_type GetData() const;
// 设置prior
bool SetPrior(DoubleLinkListNode *prior);
// 获取prior
DoubleLinkListNode *GetPrior();
// 设置next
bool SetNext(DoubleLinkListNode *next);
// 获取next
DoubleLinkListNode *GetNext();
// 构造函数
DoubleLinkListNode();
explicit DoubleLinkListNode(element_type elem);
DoubleLinkListNode(element_type elem, DoubleLinkListNode *next);
DoubleLinkListNode(element_type elem, DoubleLinkListNode *prior, DoubleLinkListNode *next);
// 销毁
bool Destory();
};
bool DoubleLinkListNode::SetData(element_type elem) {
this->_data = elem;
return true;
}
element_type DoubleLinkListNode::GetData() const {
return this->_data;
}
bool DoubleLinkListNode::SetPrior(DoubleLinkListNode *prior) {
this->_prior = prior;
return true;
}
DoubleLinkListNode *DoubleLinkListNode::GetPrior() {
return this->_prior;
}
bool DoubleLinkListNode::SetNext(DoubleLinkListNode *next) {
this->_next=next;
return true;
}
DoubleLinkListNode *DoubleLinkListNode::GetNext() {
return this->_next;
}
DoubleLinkListNode::DoubleLinkListNode() {
this->SetPrior(nullptr);
this->SetNext(nullptr);
this->SetData(DEFAULTELEM);
}
DoubleLinkListNode::DoubleLinkListNode(element_type elem) {
this->SetPrior(nullptr);
this->SetNext(nullptr);
this->SetData(elem);
}
DoubleLinkListNode::DoubleLinkListNode(element_type elem, DoubleLinkListNode *next) {
this->SetPrior(nullptr);
this->SetNext(next);
this->SetData(elem);
}
DoubleLinkListNode::DoubleLinkListNode(element_type elem, DoubleLinkListNode *prior, DoubleLinkListNode *next) {
this->SetPrior(prior);
this->SetNext(next);
this->SetData(elem);
}
bool DoubleLinkListNode::Destory() {
free(this->GetPrior());
free(this->GetNext());
this->SetPrior(nullptr);
this->SetNext(nullptr);
this->SetData(DEFAULTELEM);
return true;
}
================================================
FILE: Code/CPP-Code/head/dynamic_sequence_list.h
================================================
#include "sequence_list.h"
// 动态顺序表
class DynamicSequenceList : public SequenceList {
public:
// 构造函数
DynamicSequenceList();
explicit DynamicSequenceList(int max_size);
// 插入函数
bool Insert(int index, element_type elem) override;
private:
// 分配其他地址增长动态顺序表的数据空间长度
bool OtherIncrease(int len);
// 重新分配地址增长动态顺序表的数据空间长度
bool ReIncrease(int len);
};
DynamicSequenceList::DynamicSequenceList() : SequenceList() {
}
DynamicSequenceList::DynamicSequenceList(int max_size) : SequenceList(max_size) {
}
bool DynamicSequenceList::OtherIncrease(int length) {
if (length <= 0) {
// cout << "OtherIncrease:申请空间应该大于0！" << endl;
cout << "OtherIncrease:The length " << length << " should larger than 0!" << endl;
return false;
}
// 申请一片连续的存储空间
int new_length = this->GetMaxSize() + length;
auto *space = new element_type[new_length];
// 建立中间变量
this->SetData(space);
element_type *temp = this->GetData();
for (int i = 0; i < this->GetLength(); i++) {
this->SetData(i, temp[i]);
}
this->SetMaxSize(new_length);
// delete(temp);
return true;
}
bool DynamicSequenceList::ReIncrease(int length) {
if (length <= 0) {
// cout << "ReIncrease:申请空间应该大于0！" << endl;
cout << "ReIncrease:The length " << length << " should larger than 0!" << endl;
return false;
}
// 申请一片连续的存储空间
int new_length = this->GetMaxSize() + length;
auto *space = (element_type *) realloc(this->GetData(), new_length * sizeof(element_type));
if (space) {
this->SetData(space);
this->SetMaxSize(this->GetMaxSize() + length);
return true;
} else {
this->SetMaxSize(0);
this->SetLength(0);
cout << "ReIncrease:分配其他地址空间失败！" << endl;
return false;
}
}
bool DynamicSequenceList::Insert(int index, element_type elem) {
if (index > this->GetLength() || index < 0) {
// cout << "Insert:插入索引" << index << "超过索引范围！" << endl;
cout << "Insert:Insert index value " << index << " is out of range!" << endl;
return false;
}
// 当动态顺序表已经满了，需要新增一个位置
// 为了避免索引无效而多增加一个空间，所以放在检查索引值的后面
if (this->GetLength() >= this->GetMaxSize()) {
this->ReIncrease(1);
}
for (int i = this->GetLength(); i > index; i--) {
this->SetData(i, this->GetData(i - 1));
}
this->SetData(index, elem);
this->SetLength();
return true;
}
================================================
FILE: Code/CPP-Code/head/head.h
================================================
// 初始化最大长度
#define MAXSIZE 5
// 定义默认值
#define DEFAULTELEM '\0'
// 定义最大值
//#define INFINITY 32767
// 定义默认数据类型
typedef char element_type;
================================================
FILE: Code/CPP-Code/head/link_list.h
================================================
#ifndef _LINK_LIST_
#define _LINK_LIST_
#include <iostream>
#include "head.h"
using namespace std;
// 单链表结点
class LinkListNode {
private:
// 数据
element_type _data{};
// 指针
LinkListNode *_next{};
public:
// 设置数据
bool SetData(element_type elem);
// 获取数据
element_type GetData() const;
// 设置next
bool SetNext(LinkListNode *next);
// 获取next
LinkListNode *GetNext();
// 构造函数
LinkListNode();
explicit LinkListNode(element_type elem);
LinkListNode(element_type elem, LinkListNode *next);
// 销毁
bool Destory();
};
bool LinkListNode::SetData(element_type elem) {
this->_data = elem;
return true;
}
element_type LinkListNode::GetData() const {
return this->_data;
}
bool LinkListNode::SetNext(LinkListNode *next) {
this->_next = next;
return true;
}
LinkListNode *LinkListNode::GetNext() {
return this->_next;
}
LinkListNode::LinkListNode() {
this->SetData(DEFAULTELEM);
this->SetNext(nullptr);
}
LinkListNode::LinkListNode(element_type elem) {
this->SetData(elem);
this->SetNext(nullptr);
}
LinkListNode::LinkListNode(element_type elem, LinkListNode *next) {
this->SetData(elem);
this->SetNext(next);
}
bool LinkListNode::Destory() {
if (this->GetNext() != nullptr) {
free(this->GetNext());
}
this->SetData(DEFAULTELEM);
this->SetNext(nullptr);
return true;
}
class LinkList {
private:
// 指针
LinkListNode *_next{};
// 链表长度
int _length{};
// 类型，真有头节点，假无头节点
bool _type{};
protected:
// 设置链表类型
bool SetType(bool type);
public:
// 设置next
bool SetNext(LinkListNode *next);
// 获取next
LinkListNode *GetNext();
// 长度自加1
bool SetLength();
// 设置长度
bool SetLength(int length);
// 获取长度
int GetLength() const;
// 获取链表类型
bool GetType() const;
// 构造函数
LinkList();
// 打印
virtual bool Print() = 0;
// 判空
bool Empty() const;
// 插入
virtual bool Insert(int index, element_type elem) = 0;
// 前插入
bool PriorInsert(element_type *elem, int start, int length);
// 后插入
bool NextInsert(element_type *elem, int start, int length);
// 删除
element_type Delete(int index);
virtual element_type *Delete(int index, int length) = 0;
//按位查找
virtual element_type GetElem(int index);
// 按值查找
virtual int Locate(element_type elem);
// 销毁
virtual bool Destroy();
};
bool LinkList::SetNext(LinkListNode *next) {
this->_next = next;
return true;
}
LinkListNode *LinkList::GetNext() {
return this->_next;
}
bool LinkList::SetLength() {
this->_length++;
return true;
}
bool LinkList::SetLength(int length) {
this->_length = length;
return true;
}
int LinkList::GetLength() const {
return this->_length;
}
bool LinkList::SetType(bool type) {
this->_type = type;
return true;
}
bool LinkList::GetType() const {
return this->_type;
}
LinkList::LinkList() {
this->SetNext(nullptr);
this->SetLength(0);
}
element_type LinkList::GetElem(int index) {
if (index >= this->GetLength() || index < 0) {
// cout << "GetElem:查找索引" << index << "超过索引范围！" << endl;
cout << "GetElem:The index " << index << " is out of range!" << endl;
return DEFAULTELEM;
}
LinkListNode *node = this->GetNext();
for (int i = 1; i < index; i++) {
node = node->GetNext();
}
return node->GetData();
}
int LinkList::Locate(element_type elem) {
LinkListNode *node = this->GetNext();
for (int i = 1; i < this->GetLength(); i++) {
if (node->GetData() == elem) {
return i;
}
}
// cout << "Locate:未能定位到值为" << elem << "的元素！" << endl;
cout << "Locate:Can't locate the element with value " << elem << " !" << endl;
return -1;
}
bool LinkList::Empty() const {
return this->GetLength() == 0;
}
bool LinkList::PriorInsert(element_type *elem, int start, int length) {
if (this->GetType()) {
for (int i = 0; i < length; i++) {
bool result = this->Insert(1, elem[i + start]);
if (!result) {
// cout << "PriorInsert:循环插入失败！索引值为" << i + start << endl;
cout << "PriorInsert:Loop Insert of element with index value of " << i + start << " failed!" << endl;
return false;
}
}
return true;
} else {
for (int i = 0; i < length; i++) {
bool result = this->Insert(0, elem[i + start]);
if (!result) {
// cout << "PriorInsert:循环插入失败！索引值为" << i + start << endl;
cout << "PriorInsert:Loop Insert of element with index value of " << i + start << "failed!" << endl;
return false;
}
}
return true;
}
}
bool LinkList::NextInsert(element_type *elem, int start, int length) {
if (this->GetType()) {
for (int i = 0; i < length; i++) {
bool result = this->Insert(i + 1, elem[i + start]);
if (!result) {
// cout << "NextInsert:循环插入失败！索引值为" << i + start << endl;
cout << "NextInsert:Loop insert of element with index value of " << i + start << "failed!" << endl;
return false;
}
}
return true;
} else {
for (int i = 0; i < length; i++) {
bool result = this->Insert(i, elem[i + start]);
if (!result) {
// cout << "NextInsert:循环插入失败！索引值为" << i + start << endl;
cout << "NextInsert:Loop insert of element with index value of " << i + start << "failed!" << endl;
return false;
}
}
return true;
}
}
element_type LinkList::Delete(int index) {
return *(this->Delete(index, 1));
}
bool LinkList::Destroy() {
this->SetLength(0);
free(this->GetNext());
this->SetNext(nullptr);
this->SetType(true);
return true;
}
#endif
================================================
FILE: Code/CPP-Code/head/link_list_with_head.h
================================================
#include "link_list.h"
class LinkListWithHead : public LinkList
{
public:
// 构造函数
LinkListWithHead();
// 获取数据
element_type GetData(int index);
// 打印
bool Print() override;
// 插入
bool Insert(int index, element_type elem) override;
// 删除
element_type *Delete(int index, int length) override;
// 获取最大值
int Max();
// 获取最小值
int Min();
};
LinkListWithHead::LinkListWithHead()
{
this->SetType(true);
};
element_type LinkListWithHead::GetData(int index)
{
if (index <= 0 || index >= this->GetLength() || this->GetLength() == 0)
{
cout << "GetData:Can't get the element by index of " << index << " !" << endl;
return DEFAULTELEM;
}
LinkListNode *node = this->GetNext();
for (int i = 1; i < index; i++)
{
node = node->GetNext();
}
return node->GetData();
}
bool LinkListWithHead::Print()
{
int i = 1;
// cout << "第0个元素值为空" << endl;
cout << "index: 0 -> value: NULL" << endl;
if (this->GetLength() == 0)
{
return true;
}
// 当前遍历指针
LinkListNode *node = this->GetNext();
while (node != nullptr)
{
// cout << "第" << i << "个元素值为" << node->GetData() << endl;
cout << "index: " << i << " -> value: " << node->GetData() << endl;
i++;
node = node->GetNext();
}
return true;
}
bool LinkListWithHead::Insert(int index, element_type elem)
{
if (index < 1)
{
// cout << "Insert:插入索引值" << index << "过小！" << endl;
cout << "Insert:Insert index value " << index << " is too small!" << endl;
return false;
}
// 定义一个结点指针p指向当前扫描到的结点
LinkListNode *node;
// 定义一个变量i表示当前扫描到的结点的索引号
int i = 1;
// 将链表头结点的next指向node，为第1个结点
node = this->GetNext();
// 设置一个新结点进行插入
auto *new_node = new LinkListNode(elem);
// 如果该链表为空链表
if (node == nullptr)
{
this->SetNext(new_node);
this->SetLength();
return true;
}
// 当插入的是第一个节点
if (index == 1)
{
new_node->SetNext(node);
this->SetNext(new_node);
this->SetLength();
return true;
}
// 循环遍历到达指定索引号的单链表的结点
// 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
while (node->GetNext() != nullptr && i < index - 1)
{
node = node->GetNext();
i++;
}
// 如果此时i小于index-1，表示遍历完还没有到达对应的索引
if (i < index - 1)
{
// cout << "Insert:插入索引值" << index << "过大！" << endl;
cout << "Insert:Insert index value" << index << " is too large!";
return false;
}
// 此时i==index-1
// 将node原来的后继给新的结点
new_node->SetNext(node->GetNext());
node->SetNext(new_node);
this->SetLength();
return true;
}
element_type *LinkListWithHead::Delete(int index, int length)
{
auto *data = new element_type[length];
if (index < 1)
{
// cout << "Delete:删除索引值" << index << "过小！" << endl;
cout << "Delete:Delete index value " << index << " is too small!" << endl;
return data;
}
if (length < 1)
{
// cout << "Delete:删除长度" << length << "过小！" << endl;
cout << "Delete:Delete length value " << length << " is too small!" << endl;
return data;
}
// 定义一个结点指针start指向当前扫描到的结点，即要删除第一的元素的前一个
LinkListNode *start;
// 定义一个结点指针start指向当前扫描到的结点，要删除最后的元素
LinkListNode *end;
// 定义一个变量i表示当前扫描到的结点的索引号
int i = 1;
// 将链表头结点的next指向start，为第1个结点
start = this->GetNext();
// 如果链表没有任何数据
if (start == nullptr)
{
// cout << "Delete:链表为空！" << endl;
cout << "Delete:Link list is empty!" << endl;
return data;
}
// 循环遍历到达指定索引号的单链表的结点
// 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
while (start->GetNext() != nullptr && i < index - 1)
{
start = start->GetNext();
i++;
}
// 如果此时i小于index-1，表示遍历完还没有到达对应的索引
if (i < index - 1)
{
// cout << "Delete:删除索引值" << index << "过大！" << endl;
cout << "Delete:Delete index value " << index << " is too large!" << endl;
return data;
}
// 此时i==index-1，start到达，求end
end = start;
for (int i = 0; i < length; i++)
{
data[i] = end->GetData();
end = end->GetNext();
if (end == nullptr)
{
// cout << "Delete:删除索引最大值" << index + length - 1 << "大于链表最大索引" << length - 1 << "！" << endl;
cout << "Delete:Delete index value" << index + length - 1 << "is larger than link list's biggest index " << length - 1 << "!" << endl;
return data;
}
}
if (index == 1)
{
this->SetNext(end);
}
else
{
start->SetNext(end->GetNext());
}
this->SetLength(this->GetLength() - length);
return data;
}
int LinkListWithHead::Max()
{
if (this->GetLength() == 0)
{
cout << "Max:The list is empty!" << endl;
return -1;
}
element_type temp = this->GetData(1);
int index = 1;
for (int i = 1; i < this->GetLength(); i++)
{
if (this->GetData(i) > temp)
{
temp = this->GetData(i);
index = i;
}
}
return index;
}
int LinkListWithHead::Min()
{
if (this->GetLength() == 0)
{
cout << "Min:The list is empty!" << endl;
return -1;
}
element_type temp = this->GetData(1);
int index = 1;
for (int i = 1; i < this->GetLength(); i++)
{
if (this->GetData(i) < temp)
{
temp = this->GetData(i);
index = i;
}
}
return index;
}
================================================
FILE: Code/CPP-Code/head/link_list_without_head.h
================================================
#include "link_list.h"
class LinkListWithoutHead : public LinkList
{
private:
// 数据
element_type _data{};
public:
// 设置数据
bool SetData(element_type elem);
// 获取数据
element_type GetData() const;
element_type GetData(int index);
// 构造函数
LinkListWithoutHead();
// 打印
bool Print() override;
// 插入
bool Insert(int index, element_type elem) override;
// 删除
element_type *Delete(int index, int length) override;
// 按位查找
element_type GetElem(int index) override;
// 按值查找
int Locate(element_type elem) override;
// 销毁
bool Destroy() override;
// 获取最大值
int Max();
// 获取最小值
int Min();
};
bool LinkListWithoutHead::SetData(element_type elem)
{
this->_data = elem;
return true;
}
element_type LinkListWithoutHead::GetData() const
{
return this->_data;
}
element_type LinkListWithoutHead::GetData(int index)
{
if (index < 0 || index >= this->GetLength() || this->GetLength() == 0)
{
cout << "GetData:Can't get the element by index of " << index << " !" << endl;
return DEFAULTELEM;
}
if (index == 0)
return this->GetData();
LinkListNode *node = this->GetNext();
for (int i = 1; i < index; i++)
{
node = node->GetNext();
}
return node->GetData();
}
LinkListWithoutHead::LinkListWithoutHead()
{
this->SetType(false);
this->SetData(DEFAULTELEM);
}
bool LinkListWithoutHead::Print()
{
int i = 0;
if (this->GetLength() == 0)
{
return true;
}
// cout << "第" << i << "个元素值为" << this->GetData() << endl;
cout << "index: " << i << " -> value: " << this->GetData() << endl;
// 当前遍历指针
LinkListNode *node = this->GetNext();
while (node != nullptr)
{
i++;
// cout << "第" << i << "个元素值为" << node->GetData() << endl;
cout << "index: " << i << " -> value: " << node->GetData() << endl;
node = node->GetNext();
}
return true;
}
bool LinkListWithoutHead::Insert(int index, element_type elem)
{
if (index < 0)
{
// cout << "Insert:插入索引值" << index << "过小！" << endl;
cout << "Insert:Insert index value " << index << " is too small!" << endl;
return false;
}
if (index == 0)
{
if (this->GetLength() == 0)
{
this->SetData(elem);
this->SetLength();
}
else
{
auto *node = new LinkListNode(this->GetData());
node->SetNext(this->GetNext());
this->SetData(elem);
this->SetNext(node);
this->SetLength();
}
return true;
}
// 定义一个结点指针node指向当前扫描到的结点
LinkListNode *node;
// 定义一个变量i表示当前扫描到的结点的索引号
int i = 1;
// 将链表头结点的next指向p，为第1个结点
node = this->GetNext();
// 设置一个新结点进行插入
auto *new_node = new LinkListNode(elem);
// 如果该链表为空链表
if (node == nullptr)
{
this->SetLength();
this->SetNext(new_node);
return true;
}
// 循环遍历到达指定索引号的单链表的结点
// 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
while (node->GetNext() != nullptr && i < index - 1)
{
node = node->GetNext();
i++;
}
// 如果此时i小于index-1，表示遍历完还没有到达对应的索引
if (i < index - 1)
{
// cout << "Insert:插入索引值" << index << "过大！" << endl;
cout << "Insert:Insert index value" << index << " is too large!";
return false;
}
// 此时i==index-1
// 将p原来的后继给新的结点
new_node->SetNext(node->GetNext());
node->SetNext(new_node);
this->SetLength();
return true;
}
element_type *LinkListWithoutHead::Delete(int index, int length)
{
auto *data = new element_type[length];
if (index < 0)
{
// cout << "Delete:删除索引值" << index << "过小！" << endl;
cout << "Delete:Delete index value " << index << " is too small!";
return data;
}
if (length < 1)
{
// cout << "Delete:删除长度" << length << "过小！" << endl;
cout << "Delete:Delete length value " << length << " is too small!";
return data;
}
// 定义一个结点指针start指向当前扫描到的结点，即要删除第一的元素的前一个
LinkListNode *start;
// 定义一个结点指针start指向当前扫描到的结点，要删除最后的元素
LinkListNode *end;
// 定义一个变量i表示当前扫描到的结点的索引号
int i = 1;
// 将链表头结点的next指向start，为第1个结点
start = this->GetNext();
// 如果链表没有任何数据
if (this->GetData() == DEFAULTELEM)
{
// cout << "Delete:链表为空！" << endl;
cout << "Delete:Link list is empty!" << endl;
return data;
}
data[0] = this->GetData();
// 循环遍历到达指定索引号的单链表的结点
// 条件是当前结点的下一个不为空且索引号到达，所到达的结点一定不是空结点
while (start->GetNext() != nullptr && i < index - 1)
{
start = start->GetNext();
i++;
}
// 如果此时i小于index-1，表示遍历完还没有到达对应的索引
if (i < index - 1)
{
// cout << "Delete:删除索引值" << index << "过大！" << endl;
cout << "Delete:Delete index value " << index << " is too large!";
return data;
}
// 从1开始遍历
end = this->GetNext();
for (int i = 1; i < index + length - 1; i++)
{
if (i >= index)
{
data[i - index] = end->GetData();
}
end = end->GetNext();
if (end == nullptr)
{
// cout << "Delete:删除索引最大值" << index + length - 1 << "大于链表最大索引" << length - 1 << "！" << endl;
cout << "Delete:Delete index value" << index + length - 1 << "is larger than link list's biggest index " << length - 1 << "!" << endl;
return data;
}
}
data[length - 1] = end->GetData();
if (index == 0)
{
this->SetData(end->GetNext()->GetData());
this->SetNext(end->GetNext()->GetNext());
}
if (index == 1)
{
this->SetNext(end->GetNext());
}
else
{
start->SetNext(end->GetNext());
}
this->SetLength(this->GetLength() - length);
return data;
}
element_type LinkListWithoutHead::GetElem(int index)
{
return index == 0 ? this->GetData() : LinkList::GetElem(index);
}
int LinkListWithoutHead::Locate(element_type elem)
{
return this->GetData() == elem ? 0 : LinkList::Locate(elem);
}
bool LinkListWithoutHead::Destroy()
{
this->SetData(DEFAULTELEM);
return LinkList::Destroy();
}
int LinkListWithoutHead::Max()
{
if (this->GetLength() == 0)
{
cout << "Max:The list is empty!" << endl;
return -1;
}
element_type temp = this->GetData(0);
int index = 0;
for (int i = 1; i < this->GetLength(); i++)
{
if (this->GetData(i) > temp)
{
temp = this->GetData(i);
index = i;
}
}
return index;
}
int LinkListWithoutHead::Min()
{
if (this->GetLength() == 0)
{
cout << "Min:The list is empty!" << endl;
return -1;
}
element_type temp = this->GetData(0);
int index = 0;
for (int i = 1; i < this->GetLength(); i++)
{
if (this->GetData(i) < temp)
{
temp = this->GetData(i);
index = i;
}
}
return index;
}
================================================
FILE: Code/CPP-Code/head/link_queue.h
================================================
#include <iostream>
#include "head.h"
// 链队结点
class LinkQueueNode {
private:
// 数据
element_type _data;
// 指针
LinkQueueNode *_next;
public:
// 设置数据
bool SetData(element_type elem);
// 获取数据
element_type GetData() const;
// 设置指针
bool SetNext(LinkQueueNode *next);
// 获取指针
LinkQueueNode *GetNext();
// 构造函数
LinkQueueNode() {
this->SetData(DEFAULTELEM);
this->SetNext(nullptr);
}
LinkQueueNode(element_type elem) {
this->SetData(elem);
this->SetNext(nullptr);
}
LinkQueueNode(element_type elem, LinkQueueNode *next) {
this->SetData(elem);
this->SetNext(next);
}
};
bool LinkQueueNode::SetData(element_type elem) {
this->_data = elem;
return true;
}
element_type LinkQueueNode::GetData() const {
return this->_data;
}
bool LinkQueueNode::SetNext(LinkQueueNode *next) {
this->_next = next;
return true;
}
LinkQueueNode *LinkQueueNode::GetNext() {
return this->_next;
}
// 链队
class LinkQueue {
private:
// 队头指针和队尾指针
LinkQueueNode *_front{}, *_rear{};
// 长度
int _length{};
public:
// 设置队首指针
bool SetFront(LinkQueueNode *front);
// 获取对首指针
LinkQueueNode *GetFront();
// 设置队尾指针
bool SetRear(LinkQueueNode *rear);
// 获取队尾指针
LinkQueueNode *GetRear();
// 队长自加
bool SetLength();
// 设置队长
bool SetLength(int length);
// 获取队长
int GetLength() const;
// 构造函数
LinkQueue();
// 判空
bool Empty() const;
// 入队
bool Enter(element_type elem);
// 出队
element_type Depart();
};
bool LinkQueue::SetFront(LinkQueueNode *front) {
this->_front = front;
return true;
}
LinkQueueNode *LinkQueue::GetFront() {
return this->_front;
}
bool LinkQueue::SetRear(LinkQueueNode *rear) {
this->_rear = rear;
return true;
}
LinkQueueNode *LinkQueue::GetRear() {
return this->_rear;
}
bool LinkQueue::SetLength() {
this->_length++;
return true;
}
bool LinkQueue::SetLength(int length) {
this->_length = length;
return true;
}
int LinkQueue::GetLength() const {
return this->_length;
}
LinkQueue::LinkQueue() {
auto *node = new LinkQueueNode();
this->SetFront(node);
this->SetRear(node);
this->SetLength(0);
}
bool LinkQueue::Empty() const {
return this->GetLength() == 0;
}
bool LinkQueue::Enter(element_type elem) {
// 创建新结点
auto *node = new LinkQueueNode(elem);
// 把最后一个元素的next连接到node
this->GetRear()->SetNext(node);
// 移动尾指针
this->SetRear(node);
return true;
}
element_type LinkQueue::Depart() {
if(this->Empty()){
cout << "Depart:The queue is empty!" << endl;
return DEFAULTELEM;
}
// 获取对首元素下一个元素的数据
element_type elem = this->GetFront()->GetNext()->GetData();
// 后移移位
this->GetFront()->SetNext(this->GetFront()->GetNext()->GetNext());
return true;
}
================================================
FILE: Code/CPP-Code/head/link_stack.h
================================================
#include "head.h"
using namespace std;
// 链栈
class LinkStackNode {
private:
// 数据
element_type _data{};
// 指针
LinkStackNode *_next{};
// 设置数据
bool SetData(element_type data);
// 取数据
element_type GetData() const;
// 设置指针
bool SetNext(LinkStackNode *next);
// 获取指针
LinkStackNode *GetNext();
public:
// 构造函数
LinkStackNode();
explicit LinkStackNode(element_type data);
LinkStackNode(element_type data, LinkStackNode *next);
// 销毁
bool Destroy();
};
bool LinkStackNode::SetData(element_type data) {
this->_data = data;
return true;
}
element_type LinkStackNode::GetData() const {
return this->_data;
}
bool LinkStackNode::SetNext(LinkStackNode *next) {
this->_next = next;
return true;
}
LinkStackNode *LinkStackNode::GetNext() {
return this->_next;
}
LinkStackNode::LinkStackNode() {
this->SetData(DEFAULTELEM);
this->SetNext(nullptr);
}
LinkStackNode::LinkStackNode(element_type data) {
this->SetData(data);
this->SetNext(nullptr);
}
LinkStackNode::LinkStackNode(element_type data, LinkStackNode *next) {
this->SetData(data);
this->SetNext(next);
}
bool LinkStackNode::Destroy() {
this->SetData(DEFAULTELEM);
delete (this->GetNext());
this->SetNext(nullptr);
return true;
}
================================================
FILE: Code/CPP-Code/head/link_string.h
================================================
#include "head.h"
// 块链串结点
class LinkStringNode {
private:
// 数据
char *_data{};
// 指针
LinkStringNode *_next{};
public:
// 初始化数据
bool SetData();
bool SetData(int data_size);
// 设置数据
bool SetData(char *character);
bool SetData(int index, char character);
// 获取数据
char *GetData();
char GetData(int index);
// 设置指针
bool SetNext();
bool SetNext(LinkStringNode *next);
// 获取指针
LinkStringNode *GetNext();
// 初始化
LinkStringNode();
explicit LinkStringNode(int max_size);
LinkStringNode(int max_size, LinkStringNode *next);
LinkStringNode(int max_size, char *character, LinkStringNode *next);
LinkStringNode(int max_size, char *character);
};
bool LinkStringNode::SetData() {
this->_data = new char[1];
return true;
}
bool LinkStringNode::SetData(int data_size) {
this->_data = new char[data_size];
return true;
}
bool LinkStringNode::SetData(char *character) {
this->_data = character;
return true;
}
bool LinkStringNode::SetData(int index, char character) {
this->_data[index] = character;
return true;
}
char *LinkStringNode::GetData() {
return this->_data;
}
char LinkStringNode::GetData(int index) {
return this->_data[index];
}
bool LinkStringNode::SetNext() {
this->_next = nullptr;
return true;
}
bool LinkStringNode::SetNext(LinkStringNode *next) {
this->_next = next;
return true;
}
LinkStringNode *LinkStringNode::GetNext() {
return this->_next;
}
LinkStringNode::LinkStringNode() {
this->SetData();
this->SetNext();
}
LinkStringNode::LinkStringNode(int max_size) {
this->SetData(max_size);
this->SetNext();
}
LinkStringNode::LinkStringNode(int max_size, LinkStringNode *next) {
this->SetData(max_size);
this->SetNext(next);
}
LinkStringNode::LinkStringNode(int max_size, char *character, LinkStringNode *next) {
this->SetData(max_size);
for (int i = 0; i < max_size; i++) {
if (character[i] != '\0') {
this->SetData(i, character[i]);
}
}
this->SetNext(next);
}
LinkStringNode::LinkStringNode(int max_size, char *character) {
this->SetData(max_size);
for (int i = 0; i < max_size; i++) {
if (character[i] != '\0') {
this->SetData(i, character[i]);
}
}
this->SetNext();
}
class LinkString {
private:
// 头尾指针
LinkStringNode *_front{}, *_rear{};
// 块链长度
int _data_size{};
// 长度
int _length{};
public:
// 设置头指针
bool SetFront();
bool SetFront(LinkStringNode *front);
// 获取头指针
LinkStringNode *GetFront();
// 设置尾指针
bool SetRear();
bool SetRear(LinkStringNode *rear);
// 获取尾指针
LinkStringNode *GetRear();
// 设置总体块链单元长度
bool SetDataSize();
bool SetDataSize(int data_size);
// 获取数据长度
int GetDataSize() const;
// 数据长度自加
bool SetLength();
// 设置数据长度
bool SetLength(int length);
// 获取数据长度
int GetLength() const;
// 初始化
LinkString();
explicit LinkString(int data_size);
};
bool LinkString::SetFront() {
this->_front = nullptr;
return true;
}
bool LinkString::SetFront(LinkStringNode *front) {
this->_front = front;
return true;
}
LinkStringNode *LinkString::GetFront() {
return this->_front;
}
bool LinkString::SetRear() {
this->_rear = nullptr;
return true;
}
bool LinkString::SetRear(LinkStringNode *rear) {
this->_rear = rear;
return true;
}
LinkStringNode *LinkString::GetRear() {
return this->_rear;
}
bool LinkString::SetDataSize() {
this->_data_size = 1;
return true;
}
bool LinkString::SetDataSize(int data_size) {
this->_data_size = data_size;
return true;
}
int LinkString::GetDataSize() const {
return this->_data_size;
}
bool LinkString::SetLength() {
this->_length++;
return true;
}
bool LinkString::SetLength(int length) {
this->_length = length;
return true;
}
int LinkString::GetLength() const {
return this->_length;
}
LinkString::LinkString() {
this->SetFront();
this->SetRear();
this->SetLength(0);
this->SetDataSize(1);
}
LinkString::LinkString(int data_size) {
this->SetFront();
this->SetRear();
this->SetLength(0);
this->SetDataSize(data_size);
}
================================================
FILE: Code/CPP-Code/head/list.h
================================================
#include "static_sequence_list.h"
#include "dynamic_sequence_list.h"
#include "link_list_with_head.h"
#include "link_list_without_head.h"
#include "static_link_list.h"
#include "double_link_list.h"
================================================
FILE: Code/CPP-Code/head/sequence_list.h
================================================
#ifndef _SEQUENCE_LIST_
#define _SEQUENCE_LIST_
// 避免重复编译
#include <iostream>
#include "head.h"
//#pragma warning(disable:6385)
//#pragma warning(disable:6386)
using namespace std;
// 顺序表
class SequenceList {
private:
// 数据
element_type *_data{};
// 长度
int _length{};
// 最大容量
int _max_size{};
protected:
// 构造函数
SequenceList();
explicit SequenceList(int max_size);
public:
// 设置数据
bool SetData();
bool SetData(int max_size);
bool SetData(element_type *elem);
bool SetData(int index, element_type elem);
// 获取数据
element_type *GetData() const;
element_type GetData(int index) const;
// 长度自加1
bool SetLength();
// 设置长度
bool SetLength(int length);
// 获取长度
int GetLength() const;
// 设置最大容量
bool SetMaxSize();
bool SetMaxSize(int max_size);
// 获取最大容量
int GetMaxSize() const;
// 插入函数
virtual bool Insert(int index, element_type elem) = 0;
// 打印函数
bool Print() const;
// 循环插入函数
bool LoopInsert(element_type *elem, int index, int length);
// 删除函数
element_type Delete(int index);
// 多个删除函数
element_type *LoopDelete(int index, int length);
// 按位获取元素
element_type GetElem(int index) const;
// 按值获取元素
int Locate(element_type elem) const;
// 判空
bool Empty() const;
// 销毁
bool Destroy() const;
// 获取最大值
int Max() const;
// 获取最小值
int Min() const;
};
bool SequenceList::SetData() {
this->_data = new element_type[MAXSIZE];
return true;
}
bool SequenceList::SetData(int max_size) {
this->_data = new element_type[max_size];
return true;
}
bool SequenceList::SetData(element_type *elem) {
this->_data = elem;
return true;
}
bool SequenceList::SetData(int index, element_type elem) {
this->_data[index] = elem;
return true;
}
element_type *SequenceList::GetData() const {
return this->_data;
}
element_type SequenceList::GetData(int index) const {
return this->_data[index];
}
bool SequenceList::SetLength() {
this->_length++;
return true;
}
bool SequenceList::SetLength(int length) {
this->_length = length;
return true;
}
int SequenceList::GetLength() const {
return this->_length;
}
bool SequenceList::SetMaxSize() {
this->_max_size = MAXSIZE;
return true;
}
bool SequenceList::SetMaxSize(int max_size) {
this->_max_size = max_size;
return true;
}
int SequenceList::GetMaxSize() const {
return this->_max_size;
}
SequenceList::SequenceList() {
this->SetData();
this->SetMaxSize();
this->SetLength(0);
}
SequenceList::SequenceList(int max_size) {
this->SetData(max_size);
this->SetMaxSize(max_size);
this->SetLength(0);
}
bool SequenceList::Print() const {
for (int i = 0; i < this->GetLength(); i++) {
// cout << "第" << i << "个元素值为" << this->GetData(i) << endl;
cout << "index: " << i << " -> value: " << this->GetData(i) << endl;
}
return true;
}
bool SequenceList::LoopInsert(element_type *elem, int index, int length) {
for (int i = 0; i < length; i++) {
bool result = this->Insert(i, elem[i + index]);
if (!result) {
// cout << "LoopInsert:循环插入失败！" << endl;
cout << "LoopInsert:Loop insert failed!" << endl;
return false;
}
}
return true;
}
element_type SequenceList::Delete(int index) {
if (index >= this->GetLength() || index < 0) {
// cout << "Delete:删除索引" << index << "超过索引范围！" << endl;
cout << "Delete:Delete index value " << index << " is out of range!" << endl;
return false;
}
for (int i = index; i < this->GetLength(); i++) {
this->SetData(i, this->GetData(i + 1));
}
this->SetLength(this->GetLength() - 1);
return this->GetData(index);
}
element_type *SequenceList::LoopDelete(int index, int length) {
if (index + length > this->GetLength() || index < 0) {
// cout << "LoopDelete:删除索引" << index + length << "超过索引范围！" << endl;
cout << "LoopDelete:Loop Delete index value " << index + length << " is out of range!" << endl;
return nullptr;
}
auto *elem = new element_type[length];
for (int i = index; i <= this->GetLength() - length; i++) {
if (i < index + length) {
elem[i - index] = this->GetData(i);
}
this->SetData(i, this->GetData(i + length));
}
this->SetLength(this->GetLength() - length);
return elem;
}
element_type SequenceList::GetElem(int index) const {
if (index >= this->GetLength() || index < 0) {
// cout << "GetElem:查找索引" << index << "超过索引范围！" << endl;
cout << "GetElem:The index " << index << " is out of range!" << endl;
return DEFAULTELEM;
}
return this->GetData(index);
}
int SequenceList::Locate(element_type elem) const {
for (int i = 0; i < this->GetLength(); i++) {
if (this->GetData(i) == elem) {
return i;
}
}
// cout << "Locate:未能定位到对应值的元素！" << endl;
cout << "Locate:Can't locate the element with value " << elem << " !" << endl;
return -1;
}
bool SequenceList::Empty() const {
return this->GetLength() == 0;
}
bool SequenceList::Destroy() const {
if (this->GetData()) {
free(this->GetData());
}
return true;
}
int SequenceList::Max() const {
if(this->GetLength()==0){
cout << "Max:The list is empty!" << endl;
return -1;
}
element_type temp = this->GetData(0);
int index = 0;
for(int i=1;i<this->GetLength();i++){
if(this->GetData(i)>temp){
temp = this->GetData(i);
index = i;
}
}
return index;
}
int SequenceList::Min() const {
if(this->GetLength()==0){
cout << "Min:The list is empty!" << endl;
return -1;
}
element_type temp = this->GetData(0);
int index = 0;
for(int i=1;i<this->GetLength();i++){
if(this->GetData(i)<temp){
temp = this->GetData(i);
index = i;
}
}
return index;
}
#endif
================================================
FILE: Code/CPP-Code/head/sequence_queue.h
================================================
#include "head.h"
// 顺序队列
class SequenceQueue {
private:
// 数据
element_type *_data{};
// 队头队尾指针
int _front{}, _rear{};
// 队列最大容量
int _max_size{};
public:
// 设置数据
bool SetData();
bool SetData(int max_size);
bool SetData(element_type *elem);
bool SetData(int index, element_type elem);
// 获取数据
element_type *GetData();
element_type GetData(int index);
// 队头自加
bool SetFront();
// 设置队头
bool SetFront(int front);
// 获取队头
int GetFront() const;
// 队尾自加
bool SetRear();
// 设置队尾
bool SetRear(int rear);
// 获取队尾
int GetRear() const;
// 设置最大容量
bool SetMaxSize();
bool SetMaxSize(int max_size);
// 获取最大容量
int GetMaxSize() const;
// 构造函数
SequenceQueue();
explicit SequenceQueue(int max_size);
// 判空
bool Empty() const;
// 判满
bool Full() const;
// 循环队列判满
bool FullCircular() const;
// 进队
bool Enter(element_type elem);
// 循环队列进队
bool EnterCircular(element_type elem);
// 出队
element_type Depart();
// 循环队列出队
element_type DepartCircular();
// 获取队长
int Length() const;
// 读队头
element_type Head();
};
bool SequenceQueue::SetData() {
this->_data = new element_type[MAXSIZE];
return true;
}
bool SequenceQueue::SetData(int max_size) {
this->_data = new element_type[max_size];
return true;
}
bool SequenceQueue::SetData(element_type *elem) {
this->_data = elem;
return true;
}
bool SequenceQueue::SetData(int index, element_type elem) {
this->_data[index] = elem;
return true;
}
element_type *SequenceQueue::GetData() {
return this->_data;
}
element_type SequenceQueue::GetData(int index) {
return this->_data[index];
}
bool SequenceQueue::SetFront() {
this->_front++;
return true;
}
bool SequenceQueue::SetFront(int front) {
this->_front = front;
return true;
}
int SequenceQueue::GetFront() const {
return this->_front;
}
bool SequenceQueue::SetRear() {
this->_rear++;
return true;
}
bool SequenceQueue::SetRear(int rear) {
this->_rear = rear;
return true;
}
int SequenceQueue::GetRear() const {
return this->_rear;
}
bool SequenceQueue::SetMaxSize() {
this->_max_size = MAXSIZE;
return true;
}
bool SequenceQueue::SetMaxSize(int max_size) {
this->_max_size = max_size;
return true;
}
int SequenceQueue::GetMaxSize() const {
return this->_max_size;
}
SequenceQueue::SequenceQueue() {
this->SetData();
this->SetMaxSize();
this->SetFront(0);
this->SetRear(0);
}
SequenceQueue::SequenceQueue(int max_size) {
this->SetData(max_size);
this->SetMaxSize(max_size);
this->SetFront(0);
this->SetRear(0);
}
bool SequenceQueue::Empty() const {
return this->GetFront() == this->GetRear();
}
bool SequenceQueue::Full() const {
return this->GetFront() == this->GetMaxSize();
}
bool SequenceQueue::FullCircular() const {
return (this->GetRear() + 1) % this->GetMaxSize() == this->GetFront();
}
bool SequenceQueue::Enter(element_type elem) {
if (this->Full()) {
cout << "Enter:The queue is full!" << endl;
return false;
}
this->SetData(this->GetRear(), elem);
this->SetRear();
return true;
}
bool SequenceQueue::EnterCircular(element_type elem) {
if (this->FullCircular()) {
cout << "EnterCircular:The queue is full!" << endl;
return false;
}
this->SetData(this->GetRear(), elem);
this->SetRear((this->GetRear() + 1) % this->GetMaxSize());
return true;
}
element_type SequenceQueue::Depart() {
if (this->Empty()) {
cout << "Depart:The queue is empty!" << endl;
return DEFAULTELEM;
}
element_type temp = this->GetData(this->GetFront());
this->SetFront();
return temp;
}
element_type SequenceQueue::DepartCircular() {
if (this->Empty()) {
cout << "DepartCircular:The queue is empty!" << endl;
return DEFAULTELEM;
}
element_type temp = this->GetData(this->GetFront());
this->SetFront((this->GetFront() + 1) % this->GetMaxSize());
return temp;
}
int SequenceQueue::Length() const {
return (this->GetRear() - this->GetFront() + this->GetMaxSize()) % this->GetMaxSize();
}
element_type SequenceQueue::Head() {
if (this->Empty()) {
cout << "Head:The queue is empty!" << endl;
return DEFAULTELEM;
}
return this->GetData(this->GetFront());
}
================================================
FILE: Code/CPP-Code/head/sequence_stack.h
================================================
#include "head.h"
using namespace std;
// 顺序栈
class SequenceStack {
private:
// 栈内元素
element_type *_data{};
// 栈顶指针
int _top{};
// 最大容量
int _max_size{};
// 设置数据
bool SetData(element_type *data);
// 栈顶指针自加
bool SetTop();
// 设置栈顶指针
bool SetTop(int top);
// 获取栈顶指针
int GetTop() const;
// 设置最大容量
bool SetMaxSize(int max_size);
public:
// 获取最大容量
int GetMaxSize() const;
// 构造函数
SequenceStack();
explicit SequenceStack(int max_size);
// 判空
bool Empty() const;
// 判满
bool Full() const;
// 栈长
int Length() const;
// 进栈
bool Push(element_type elem);
// 出栈
element_type Pop();
// 读栈顶
element_type Top();
};
bool SequenceStack::SetData(element_type *data) {
this->_data = data;
return true;
}
bool SequenceStack::SetTop() {
this->_top++;
return true;
}
bool SequenceStack::SetTop(int top) {
this->_top = top;
return true;
}
int SequenceStack::GetTop() const {
return this->_top;
}
bool SequenceStack::SetMaxSize(int max_size) {
this->_max_size = max_size;
return true;
}
int SequenceStack::GetMaxSize() const {
return this->_max_size;
}
SequenceStack::SequenceStack() {
this->SetData(new element_type[MAXSIZE]);
this->SetTop(-1);
this->SetMaxSize(MAXSIZE);
}
SequenceStack::SequenceStack(int max_size) {
this->SetData(new element_type[max_size]);
this->SetTop(-1);
this->SetMaxSize(max_size);
}
bool SequenceStack::Empty() const {
return this->GetTop() == -1;
}
bool SequenceStack::Full() const {
return this->GetTop() == this->GetMaxSize() - 1;
}
int SequenceStack::Length() const {
return this->GetTop() + 1;
}
bool SequenceStack::Push(element_type elem) {
if (this->Full()) {
cout << "Push:栈满无法进栈！" << endl;
cout << "Push:The stack is full!" << endl;
return false;
}
this->_data[this->SetTop()] = elem;
return true;
}
element_type SequenceStack::Pop() {
if (this->Empty()) {
cout << "Pop:栈空无法出栈！" << endl;
cout << "Pop:The stack is empty!" << endl;
return DEFAULTELEM;
}
return this->_data[this->SetTop(this->GetTop() - 1)];
}
element_type SequenceStack::Top() {
if (this->Empty()) {
cout << "Top:栈空无法读栈顶元素！" << endl;
cout << "Top:The stack is empty!" << endl;
return DEFAULTELEM;
}
return this->_data[this->GetTop() - 1];
}
================================================
FILE: Code/CPP-Code/head/sequence_string.h
================================================
#include "head.h"
// 顺序串
class SequenceString {
private:
// 数据
char *_data{};
// 长度
int _length{};
// 最大容量
int _max_size{};
public:
// 设置数据
bool SetData();
bool SetData(int max_size);
bool SetData(char *character);
bool SetData(int index, char character);
// 获取数据
char *GetData();
char GetData(int index);
// 长度自加
bool SetLength();
// 设置长度
bool SetLength(int length);
// 获取长度
int GetLength() const;
// 设置最大容量
bool SetMaxSize();
bool SetMaxSize(int max_size);
// 获取最大容量
int GetMaxSize() const;
// 构造函数
SequenceString();
explicit SequenceString(int max_size);
// 暴力模式匹配
int LocateSimple(SequenceString string);
// 销毁
bool Destroy();
};
bool SequenceString::SetData() {
this->_data = new char[MAXSIZE];
return true;
}
bool SequenceString::SetData(int max_size) {
this->_data = new char[max_size];
return true;
}
bool SequenceString::SetData(char *character) {
this->_data = character;
return true;
}
bool SequenceString::SetData(int index, char character) {
this->_data[index] = character;
return true;
}
char *SequenceString::GetData() {
return this->_data;
}
char SequenceString::GetData(int index) {
return this->_data[index];
}
bool SequenceString::SetLength() {
this->_length++;
return true;
}
bool SequenceString::SetLength(int length) {
this->_length = length;
return true;
}
int SequenceString::GetLength() const {
return this->_length;
}
bool SequenceString::SetMaxSize() {
this->_max_size = MAXSIZE;
return true;
}
bool SequenceString::SetMaxSize(int max_size) {
this->_max_size = max_size;
return true;
}
int SequenceString::GetMaxSize() const {
return this->_max_size;
}
SequenceString::SequenceString() {
this->SetData();
this->SetMaxSize();
this->SetLength(0);
}
SequenceString::SequenceString(int max_size) {
this->SetData(max_size);
this->SetMaxSize();
this->SetLength(0);
}
int SequenceString::LocateSimple(SequenceString string) {
int i = 0, j = 0;
while (i < this->GetLength() && j < string.GetLength()) {
// 匹配就继续后移
if (this->GetData(i) == string.GetData(j)) {
i++;
j++;
}
// 不匹配就退回
else {
i = i - j + 1;
j = 0;
}
}
if (j >= string.GetLength()) {
return i - string.GetLength();
}
return -1;
}
bool SequenceString::Destroy() {
delete (this->GetData());
this->SetLength(0);
this->SetMaxSize(0);
this->SetData(nullptr);
return true;
}
================================================
FILE: Code/CPP-Code/head/share_stack.h
================================================
#include "head.h"
// 共享栈
class ShareStack{
private:
// 栈内元素
element_type *_data{};
// 栈顶指针，left从-1开始，right从MAXSIZE开始
int _top_left{}, _top_right{};
// 最大容量
int _max_size{};
public:
// 设置数据
bool SetData();
bool SetData(element_type *data);
bool SetData(int max_size);
bool SetData(int index, element_type elem);
// 获取数据
element_type * GetData();
element_type GetData(int index);
// 左栈顶指针自加
bool SetTopLeft();
// 左设置栈顶指针
bool SetTopLeft(int top);
// 左获取栈顶指针
int GetTopLeft() const;
// 右栈顶指针自减
bool SetTopRight();
// 右设置栈顶指针
bool SetTopRight(int top);
// 右获取栈顶指针
int GetTopRight() const;
// 设置最大容量
bool SetMaxSize();
bool SetMaxSize(int max_size);
// 获取最大容量
int GetMaxSize() const;
// 构造函数
ShareStack();
explicit ShareStack(int max_size);
// 判左栈空
bool EmptyLeft() const;
// 判右栈空
bool EmptyRight() const;
// 判栈满
bool Full() const;
// 左栈长
int LengthLeft() const;
// 右栈长
int LengthRight() const;
// 进左栈
bool PushLeft(element_type elem);
// 进右栈
bool PushRight(element_type elem);
// 出左栈
element_type PopLeft();
// 出右栈
element_type PopRight();
// 读左栈顶
element_type TopLeft();
// 读右栈顶
element_type TopRight();
};
bool ShareStack::SetData() {
this->_data = new element_type[MAXSIZE];
return true;
}
bool ShareStack::SetData(element_type *data) {
this->_data = data;
return true;
}
bool ShareStack::SetData(int max_size) {
this->_data = new element_type [max_size];
return true;
}
bool ShareStack::SetData(int index, element_type elem) {
this->_data[index] = elem;
return true;
}
element_type *ShareStack::GetData() {
return this->_data;
}
element_type ShareStack::GetData(int index) {
return this->_data[index];
}
bool ShareStack::SetTopLeft() {
this->_top_left++;
return true;
}
bool ShareStack::SetTopRight() {
this->_top_right--;
return true;
}
bool ShareStack::SetTopLeft(int top) {
this->_top_left = top;
return true;
}
bool ShareStack::SetTopRight(int top) {
this->_top_right = top;
return true;
}
int ShareStack::GetTopLeft() const {
return this->_top_left;
}
int ShareStack::GetTopRight() const {
return this->_top_right;
}
bool ShareStack::SetMaxSize() {
this->_max_size = MAXSIZE;
return true;
}
bool ShareStack::SetMaxSize(int max_size) {
this->_max_size = max_size;
return true;
}
int ShareStack::GetMaxSize() const {
return this->_max_size;
}
ShareStack::ShareStack() {
this->SetData();
this->SetMaxSize();
this->SetTopLeft(-1);
this->SetTopRight(MAXSIZE);
}
ShareStack::ShareStack(int max_size) {
this->SetData(max_size);
this->SetMaxSize(max_size);
this->SetTopLeft(-1);
this->SetTopRight(max_size);
}
bool ShareStack::EmptyLeft() const {
return this->GetTopLeft() == -1;
}
bool ShareStack::EmptyRight() const {
return this->GetTopRight() == this->GetMaxSize();
}
bool ShareStack::Full() const {
return this->GetTopRight() - this->GetTopLeft() == 1;
}
int ShareStack::LengthLeft() const {
return this->GetTopLeft() + 1;
}
int ShareStack::LengthRight() const {
return this->GetMaxSize() - this->GetTopRight();
}
bool ShareStack::PushLeft(element_type elem) {
if (this->Full()) {
// cout << "PushLeft:栈满无法进栈！" << endl;
cout << "PushLeft:The stack is full!";
return false;
}
this->SetTopLeft();
this->SetData(this->GetTopLeft(), elem);
return true;
}
bool ShareStack::PushRight(element_type elem) {
if(this->Full()){
// cout << "PushRight:栈满无法进栈！" << endl;
cout << "PushRight:The stack is full!" << endl;
return false;
}this->SetTopRight();
this->SetData(this->GetTopRight(), elem);
return true;
}
element_type ShareStack::PopLeft() {
if (this->EmptyLeft()) {
// cout << "PopLeft:栈空无法出栈！" << endl;
cout << "PopLeft:The stack is empty!" << endl;
return DEFAULTELEM;
}
element_type temp = this->GetData(this->GetTopLeft());
this->SetTopLeft(this->GetTopLeft() - 1);
return temp;
}
element_type ShareStack::PopRight() {
if (this->EmptyRight()) {
// cout << "PopRight:栈空无法出栈！" << endl;
cout << "PopRight:The stack is empty!" << endl;
return DEFAULTELEM;
}
element_type temp = this->GetData(this->GetTopRight());
this->SetTopRight(this->GetTopRight() + 1);
return temp;
}
element_type ShareStack::TopLeft() {
if (this->EmptyLeft()) {
// cout << "TopLeft:栈空无法读栈顶元素！" << endl;
cout << "TopLeft:The stack is empty!" << endl;
return DEFAULTELEM;
}
return this->GetData(this->GetTopLeft());
}
element_type ShareStack::TopRight() {
if (this->EmptyRight()) {
// cout << "TopRight:栈空无法读栈顶元素！" << endl;
cout << "TopRight:The stack is empty!" << endl;
return DEFAULTELEM;
}
return this->GetData(this->GetTopRight());
}
================================================
FILE: Code/CPP-Code/head/static_link_list.h
================================================
#include "head.h"
class StaticLinkListNode {
private:
// 数据元素
element_type _data{};
// 下一个元素的数组下标
int _next{};
public:
// 设置元素
bool SetData(element_type elem);
// 获取元素
element_type GetData() const;
// 设置下标
bool SetNext(int index);
// 获取下标
int GetNext() const;
// 构造函数
StaticLinkListNode();
explicit StaticLinkListNode(element_type elem);
StaticLinkListNode(element_type elem, int next);
// 销毁
bool Destroy();
};
bool StaticLinkListNode::SetData(element_type elem) {
this->_data = elem;
return true;
}
element_type StaticLinkListNode::GetData() const {
return this->_data;
}
bool StaticLinkListNode::SetNext(int index) {
this->_next = index;
return true;
}
int StaticLinkListNode::GetNext() const {
return this->_next;
}
StaticLinkListNode::StaticLinkListNode() {
this->SetData(DEFAULTELEM);
this->SetNext(-1);
}
StaticLinkListNode::StaticLinkListNode(element_type elem) {
this->SetData(elem);
this->SetNext(-1);
}
StaticLinkListNode::StaticLinkListNode(element_type elem, int next) {
this->SetData(elem);
this->SetNext(next);
}
bool StaticLinkListNode::Destroy() {
this->SetData(DEFAULTELEM);
this->SetNext(0);
return true;
}
class StaticLinkList {
private:
// 首元素地址
int _first{};
// 数据长度
int _length{};
// 数据当前最大长度
int _max_size{};
public:
// 数据
StaticLinkListNode *data;
// 设置首元素地址
bool SetFirst(int first);
// 获取首元素地址
int GetFirst() const;
// 数据长度自加
bool SetLength();
// 设置数据长度
bool SetLength(int length);
// 获取数据长度
int GetLength() const;
// 设置数据当前最大长度
bool SetMaxSize(int max_size);
// 获取数据当前最大长度
int GetMaxSize() const;
// 构造函数
StaticLinkList();
StaticLinkList(int first, element_type elem);
};
bool StaticLinkList::SetFirst(int first) {
this->_first = first;
return true;
}
int StaticLinkList::GetFirst() const {
return this->_first;
}
bool StaticLinkList::SetLength() {
this->_length++;
return true;
}
bool StaticLinkList::SetLength(int length) {
this->_length = length;
return true;
}
int StaticLinkList::GetLength() const {
return this->_length;
}
bool StaticLinkList::SetMaxSize(int max_size) {
this->_max_size = max_size;
return true;
}
int StaticLinkList::GetMaxSize() const {
return this->_max_size;
}
StaticLinkList::StaticLinkList() {
this->SetFirst(DEFAULTELEM);
this->SetLength(0);
this->SetMaxSize(MAXSIZE);
this->data = new StaticLinkListNode[MAXSIZE];
}
StaticLinkList::StaticLinkList(int first, element_type elem) {
this->SetFirst(first);
this->SetLength(1);
this->SetMaxSize(MAXSIZE);
this->data = new StaticLinkListNode[MAXSIZE];
this->data[first].SetData(elem);
this->data[first].SetNext(-1);
}
================================================
FILE: Code/CPP-Code/head/static_sequence_list.h
================================================
#include "sequence_list.h"
// 静态顺序表
class StaticSequenceList : public SequenceList {
public:
// 构造函数
StaticSequenceList();
explicit StaticSequenceList(int max_size);
// 插入函数
bool Insert(int index, element_type elem) override;
};
StaticSequenceList::StaticSequenceList() :SequenceList() {
}
StaticSequenceList::StaticSequenceList(int max_size) : SequenceList(max_size) {
}
bool StaticSequenceList::Insert(int index, element_type elem) {
// 当静态顺序表已经满了就不能插入任何元素
if (this->GetLength() >= this->GetMaxSize()) {
// cout << "Insert:静态顺序表空间不足，插入失败！" << endl;
cout << "Insert:The space size of " << this->GetMaxSize() << " is not enough!" << endl;
return false;
}
// 索引位置从0开始，所以可以插入的范围是0到list->length
if (index > this->GetLength() || index < 0) {
// cout << "Insert:插入索引" << index << "超过索引范围！" << endl;
cout << "Insert:Insert index value " << index << " is out of range!" << endl;
return false;
}
// 从最后一个元素开始交换后移，list->length是空的
for (int i = this->GetLength(); i > index; i--) {
this->SetData(i, this->GetData(i - 1));
}
this->SetData(index, elem);
this->SetLength();
return true;
}
================================================
FILE: Code/CPP-Code/source/main.cpp
================================================
#include "test.cpp"
int main()
{
// SequenceListTest();
LinkListTest();
return 0;
}
================================================
FILE: Code/CPP-Code/source/test.cpp
================================================
// 测试文件
#include "../head/list.h"
#include "../head/sequence_stack.h"
#include "../head/share_stack.h"
#include "../head/link_stack.h"
#include "../head/sequence_queue.h"
#include "../head/link_queue.h"
#include "../head/sequence_string.h"
#include "../head/link_string.h"
bool SequenceListTest() {
DynamicSequenceList list;
element_type a[6] = {'1','2','3','4','5','6'};
list.LoopInsert(a, 0, 6);
list.Print();
// element_type * data = list.GetData();
// element_type* b = list.LoopDelete(1, 3);
// list.Print();
// for (int i = 0; i < 3; i++) {
// cout << b[i] << endl;
// }
cout << list.GetData(list.Max()) << endl;
list.Destroy();
return true;
}
bool LinkListTest() {
element_type a[6] = {'0', '1','2','3','4','5' };
// LinkListWithHead list;
// list.NextInsert(a, 0, 5);
// list.Print();
// list.Delete(2, 4);
// list.Print();
/*cout << list.GetLength() << endl;
LinkListWithoutHead list2;
list2.PriorInsert(a, 2, 3);
list2.Print();
cout << list2.GetLength() << endl;*/
auto* list = new LinkListWithHead();
list->NextInsert(a, 0 ,5);
list->Print();
// int len = 2;
// element_type* b = list->Delete(2, len);
// for (int i = 0; i < len; i++) {
// cout << b[i] << endl;
// }
// list->Print();
// cout << list->Locate('1') << endl;
cout << list->GetData(list->Min()) << endl;
return true;
}
bool StaticLinkListTest(){
return true;
}
================================================
FILE: Code/Code/CMakeSettings.json
================================================
{
"configurations": [
{
"name": "x64-Debug",
"generator": "Ninja",
"configurationType": "Debug",
"inheritEnvironments": [ "msvc_x64_x64" ],
"buildRoot": "${projectDir}\\out\\build\\${name}",
"installRoot": "${projectDir}\\out\\install\\${name}",
"cmakeCommandArgs": "",
"buildCommandArgs": "",
"ctestCommandArgs": ""
}
]
}
================================================
FILE: Code/Code/head/double_link_list.h
================================================
#include "head.h"
// ˫
typedef struct DoubleLinkListNode{
//
element_type data;
// ͷβָ
struct DoubleLinkListNode *prior, *next;
} DoubleLinkListNode, *DoubleLinkList;
// ʼ
DoubleLinkList InitDoubleLinkList(){
auto list = (DoubleLinkList) malloc(sizeof(DoubleLinkList));
list->data = DEFAULTELEM;
list->prior = nullptr;
list->next = nullptr;
return list;
}
//
bool DestroyDoubleLinkList(DoubleLinkList &list){
list->data = DEFAULTELEM;
delete(list->prior);
delete(list->next);
list->prior = nullptr;
list->next = nullptr;
return true;
}
================================================
FILE: Code/Code/head/graph.h
================================================
#include "head.h"
// ڽӾͼ
typedef struct {
//
element_type* vex;
// ߱
weight_type *edge;
//
int vex_length;
//
int edge_length;
} AdjacentArrayGraph;
// ڽӱͼ
// ߱
typedef struct EdgeNode{
// ûָλ
int vex;
// ָָ
struct EdgeNode *next;
// Ȩֵ
weight_type weigh;
} EdgeNode;
//
typedef struct VexNode{
// Ϣ
element_type data;
// ָһöĻָ
EdgeNode* frist;
} VexNode, *AdjacentList;
// ڽӱ
typedef struct {
// ڽӱ
AdjacentList data;
//
int vex_length;
//
int edge_length;
} AdjacentListGraph;
================================================
FILE: Code/Code/head/head.h
================================================
//#pragma once
// ʼ
#define MAXSIZE 5
// Ĭֵ
#define DEFAULTELEM '\0'
// Ĭϴֵ
#define DEFAULTCHAR '\0'
// 崮ݳ
#define DATASIZE 4
// Ĭ
typedef char element_type;
// Ȩֵ
typedef int weight_type;
typedef int elem_type;
================================================
FILE: Code/Code/head/link_list.h
================================================
#include "head.h"
//
typedef struct LinkListNode {
element_type data;
struct LinkListNode *next;
} LinkListNode, *LinkList;
// ʼ
bool InitLinkList(LinkList &list) {
list->data = DEFAULTELEM;
list->next = nullptr;
return true;
}
LinkList InitLinkList() {
auto list = (LinkList) malloc(sizeof(LinkList));
list->data = DEFAULTELEM;
list->next = nullptr;
return list;
}
// п
bool EmptyLinkList(LinkList list) {
return list->next == nullptr && list->data == DEFAULTELEM;
}
// ж
bool TypeLinkList(LinkList list) {
if (EmptyLinkList(list)) {
return NULL;
} else {
// һΪվʹͷڵ
if (list->data == DEFAULTELEM) {
return true;
} else {
return false;
}
}
}
// ӡ
bool PrintLinkList(LinkList list) {
int i = 0;
if (EmptyLinkList(list)) {
return true;
}
// ǰָ
LinkListNode *node = list;
while (!TypeLinkList(list) && node != nullptr && node->data != DEFAULTELEM ||
TypeLinkList(list) && node != nullptr) {
printf("%dԪֵΪ%c\n", i, node->data);
node = node->next;
i++;
}
return true;
}
// ͷڵ
bool InsertLinkListWithHead(LinkList &list, int index, element_type elem) {
//if (!TypeLinkList(list)) {
// printf("InsertLinkListWithHead:Ӧͷڵͣ\n");
// return false;
//}
if (index < 1) {
printf("InsertLinkListWithHead:ֵ%dС\n", index);
return false;
}
// һָpָǰɨ赽Ľ
LinkListNode *p;
// һiʾǰɨ赽Ľ
int i = 0;
// ͷָpΪ0
p = list;
// ѭָŵĵĽ
// ǵǰһΪŵĽһǿս
while (p->next != nullptr && i < index - 1) {
p = p->next;
i++;
}
// ʱiСindex-1ʾ껹ûеӦ
if (i < index - 1) {
printf("InsertLinkListWithHead:ֵ\n");
return false;
}
// ʱi==index-1
auto *s = (LinkListNode *) malloc(sizeof(LinkListNode));
s->data = elem;
// pԭĺ̸µĽ
s->next = p->next;
p->next = s;
return true;
}
// ͷڵ
bool InsertLinkListWithoutHead(LinkList &list, int index, element_type elem) {
//if (TypeLinkList(list)) {
// printf("InsertLinkListWithoutHead:Ӧͷڵͣ\n");
// return false;
//}
if (index < 0) {
printf("InsertLinkListWithoutHead:ֵ%dС\n", index);
return false;
}
auto *s = (LinkListNode *) malloc(sizeof(LinkListNode));
if (index == 0) {
s->data = elem;
// sĺΪlistָ
s->next = list;
// listָΪsָ
list = s;
return true;
}
// һָpָǰɨ赽Ľ
LinkListNode *p;
// һiʾǰɨ赽Ľ
int i = 0;
// ͷָpΪ0
p = list;
// ѭָŵĵĽ
// ǵǰһΪŵĽһǿս
while (p->next != nullptr && i < index - 1) {
p = p->next;
i++;
}
// ʱiСindex-1ʾ껹ûеӦ
if (i < index - 1) {
printf("InsertLinkListWithoutHead:ֵ\n");
return false;
}
// ʱi==index-1
s->data = elem;
// pԭĺ̸µĽ
s->next = p->next;
p->next = s;
return true;
}
//
bool NextInsertLinkList(LinkList &list, element_type *elem, int start, int length) {
if (!TypeLinkList(list)) {
for (int i = 0; i < length; i++) {
bool result = InsertLinkListWithoutHead(list, i, elem[i + start]);
if (!result) {
printf("NextInsertLinkList:ѭʧܣֵΪ%d\n", i + start);
return false;
}
}
} else {
for (int i = 0; i < length; i++) {
bool result = InsertLinkListWithHead(list, i + 1, elem[i + start]);
if (!result) {
printf("NextInsertLinkList:ѭʧܣֵΪ%d\n", i + start);
return false;
}
}
}
return true;
}
// ǰ
bool PriorInsertLinkList(LinkList &list, element_type *elem, int start, int length) {
if (!TypeLinkList(list)) {
for (int i = 0; i < length; i++) {
bool result = InsertLinkListWithoutHead(list, 0, elem[i + start]);
if (!result) {
printf("PriorInsertLinkList:ѭʧܣֵΪ%d\n", i + start);
return false;
}
}
return true;
} else {
for (int i = 0; i < length; i++) {
bool result = InsertLinkListWithHead(list, 1, elem[i + start]);
if (!result) {
printf("PriorInsertLinkList:ѭʧܣֵΪ%d\n", i + start);
return false;
}
}
return true;
}
}
// ɾ
element_type *DeleteLinkListWithHead(LinkList &list, int index, int length) {
auto *elem = (element_type *) malloc(length * sizeof(element_type));
if (index < 1) {
printf("DeleteLinkListWithHead:ɾֵ%dС\n", index);
return elem;
}
if (length < 1) {
printf("DeleteLinkListWithHead:ɾ%dС\n", length);
}
// һָstartָǰɨ赽Ľ㣬ҪɾһԪصǰһ
LinkListNode *start;
// һָstartָǰɨ赽Ľ㣬ҪɾԪ
LinkListNode *end;
// һiʾǰɨ赽Ľ
int i = 1;
// ͷnextָstartΪ1
start = list->next;
// ûκ
if (start == nullptr) {
printf("DeleteLinkListWithHead:Ϊգ\n");
return elem;
}
// ѭָŵĵĽ
// ǵǰһΪŵĽһǿս
while (start->next != nullptr && i < index - 1) {
start = start->next;
i++;
}
// ʱiСindex-1ʾ껹ûеӦ
if (i < index - 1) {
printf("DeleteLinkListWithHead:ɾֵ%d\n", index);
return elem;
}
// ʱi==index-1startend
end = start;
for (int i = 0; i < length; i++) {
elem[i] = end->data;
end = end->next;
if (end == nullptr) {
printf("DeleteLinkListWithHead:ɾֵ%d%d\n", index + length - 1, length - 1);
return elem;
}
}
if (index == 1) {
list->next = end;
} else {
start->next = end->next;
}
return elem;
}
element_type *DeleteLinkListWithoutHead(LinkList &list, int index, int length) {
auto *elem = (element_type *) malloc(length * sizeof(element_type));
if (index < 0) {
printf("DeleteLinkListWithoutHead:ɾֵС\n");
return elem;
}
if (length < 1) {
printf("DeleteLinkListWithoutHead:ɾ%dС\n", length);
}
// һָstartָǰɨ赽Ľ㣬ҪɾһԪصǰһ
LinkListNode *start;
// һָstartָǰɨ赽Ľ㣬ҪɾԪ
LinkListNode *end;
// iʾǰָǵڼ
int i = 0;
// ͷnextָstartΪ0
start = list;
// ûκ
if (EmptyLinkList(list)) {
printf("DeleteLinkListWithoutHead:Ϊգ\n");
return elem;
}
// ѭָŵĵĽ
// ǵǰһΪŵĽһǿս
while (start->next != nullptr && i < index - 1) {
start = start->next;
i++;
}
// ʱiСindex-1ʾ껹ûеӦ
if (i < index - 1) {
printf("DeleteLinkListWithoutHead:ɾֵ%d\n", index);
return elem;
}
// λ
end = start;
for (int i = 0; i < length; i++) {
end = end->next;
elem[i] = end->data;
if (end->next == nullptr) {
printf("DeleteLinkListWithoutHead:ɾֵ%d%d\n", index + length - 1, length - 1);
return elem;
}
}
// ɾһ0Ž
if (index == 0) {
start->data = end->next->data;
start->next = end->next->next;
}
start->next = end->next;
return elem;
}
//
int GetLengthLinkList(LinkList list) {
int length = 0;
LinkListNode *node = list;
while (node->next != nullptr) {
length++;
node = node->next;
}
return length;
}
// λ
element_type GetLinkListElem(LinkList list, int index) {
if (index >= GetLengthLinkList(list) || index < 0) {
printf("GetLinkListElem:%dΧ\n", index);
return DEFAULTELEM;
}
LinkListNode *node = list;
for (int i = 0; i < index; i++) {
node = node->next;
}
return node->data;
}
// ֵ
int LocateLinkList(LinkList list, element_type elem) {
LinkListNode *node = list;
for (int i = 0; i < GetLengthLinkList(list); i++) {
if (node->data == elem) {
return i;
}
}
printf("LocateLinkList:δܶλӦֵ%cԪأ\n", elem);
return -1;
}
//
bool DestroyLinkList(LinkList &list) {
list->data = DEFAULTELEM;
delete (list);
return true;
}
================================================
FILE: Code/Code/head/link_queue.h
================================================
#include "head.h"
// ӽ
typedef struct LinkQueueNode {
//
element_type data;
// ָ
struct LinkQueueNode *next;
} LinkQueueNode;
//
typedef struct {
// ͷָͶβָ
LinkQueueNode *front, *rear;
} LinkQueue;
// ʼ
bool InitLinkQueue(LinkQueue &queue){
// ͷڵ
queue.front = queue.rear = (LinkQueueNode*) malloc(sizeof(LinkQueueNode));
// ʼΪ
queue.front->next = nullptr;
queue.front->data = DEFAULTELEM;
return true;
}
LinkQueue InitLinkQueue(){
auto* queue = (LinkQueue*) malloc(sizeof(LinkQueue));
queue->front = queue->rear = (LinkQueueNode*) malloc(sizeof(LinkQueueNode));
// ʼΪ
queue->front->next = nullptr;
queue->front->data = DEFAULTELEM;
return (LinkQueue &) queue;
}
// п
bool EmptyLinkQueue(LinkQueue queue){
return queue.front==queue.rear;
}
//
bool EnterLinkQueue(LinkQueue &queue, element_type elem){
// ½
auto *node = (LinkQueueNode *) malloc(sizeof(LinkQueueNode));
node->data = elem;
node->next = nullptr;
// һԪصnextӵnode
queue.rear->next = node;
// ƶβָ
queue.rear = node;
return true;
}
//
element_type DepartLinkQueue(LinkQueue &queue){
if(EmptyLinkQueue(queue)){
printf("DepartLinkQueue:The queue is empty!");
return false;
}
// ȡԪһԪص
element_type elem = queue.front->next->data;
// λ
queue.front->next=queue.front->next->next;
// п
return true;
}
================================================
FILE: Code/Code/head/link_stack.h
================================================
#include "head.h"
// ջ
typedef struct LinkStackNode{
//
element_type data;
// ָ
LinkStackNode *next;
} *LinkStack;
// ʼ
LinkStack InitLinkStack(){
auto stack = (LinkStack) malloc(sizeof(LinkStack));
stack->data = DEFAULTELEM;
stack->next = nullptr;
return stack;
}
bool InitLinkStack(LinkStack &stack){
stack->data = DEFAULTELEM;
stack->next = nullptr;
return true;
}
// п
bool EmptyLinkStack(LinkStack stack){
return stack->data == DEFAULTELEM;
};
================================================
FILE: Code/Code/head/link_string.h
================================================
#include "head.h"
//
typedef struct LinkStringNode {
//
char *data;
// ָ
LinkStringNode *next;
} LinkStringNode, *LinkString;
bool InitLinkString(LinkString &string) {
string->data = (char *) malloc(sizeof(char) * DATASIZE);
string->next = nullptr;
return true;
}
LinkString InitLinkString() {
auto* string = (LinkString) malloc(sizeof(LinkString));
string->data = (char *) malloc(sizeof(char) * DATASIZE);
string->next = nullptr;
return (LinkString &)string;
}
================================================
FILE: Code/Code/head/link_tree.h
================================================
#include "head.h"
#include <stack>
#include <queue>
// ȽԪط
int CompareElem(element_type elem1, element_type elem2){
return 0;
}
//
typedef struct BinaryTreeNode {
element_type data;
BinaryTreeNode *left_child, *right_child;
} BinaryTreeNode, *BinaryTree;
// ǰ
bool PreOrderBinaryTree(BinaryTree &tree, bool( *function)(BinaryTree &)) {
if (tree != nullptr) {
if (!function(tree))
return false;
PreOrderBinaryTree(tree->left_child, function);
PreOrderBinaryTree(tree->right_child, function);
}
return true;
}
//
bool InOrderBinaryTree(BinaryTree &tree, bool(*function)(BinaryTree &)) {
if (tree != nullptr) {
PreOrderBinaryTree(tree->left_child, function);
if (!function(tree))
return false;
PreOrderBinaryTree(tree->right_child, function);
}
return true;
}
//
bool PostOrderBinaryTree(BinaryTree &tree, bool(*function)(BinaryTree &)) {
if (tree != nullptr) {
PreOrderBinaryTree(tree->left_child, function);
PreOrderBinaryTree(tree->right_child, function);
if (!function(tree))
return false;
}
return true;
}
// ǵݹ
bool PreOrderNonRecursiveBinaryTree(BinaryTree &tree, bool(*function)(BinaryTree &)) {
// ʼջջԪΪtreeָ
std::stack<BinaryTree> stack;
// ֵһ
BinaryTree new_tree = tree;
// ջջnew_treeʱѭ
while (new_tree || !stack.empty()) {
// һֱ
if (new_tree) {
// ʵǰ
if (!function(new_tree)) {
printf("PreOrderNonRecursive:ʽʧܣ");
return false;
}
// ǰջ
stack.push(new_tree);
// Ӳһֱ
new_tree = new_tree->left_child;
}
// ջת
else {
// ջԪأɾԪ
new_tree = stack.top();
// ɾջԪصֵ
stack.pop();
//
new_tree = new_tree->right_child;
// while
}
}
return true;
}
// ǵݹ
bool InOrderNonRecursiveBinaryTree(BinaryTree &tree, bool(*function)(BinaryTree &)) {
// ʼջջԪΪtreeָ
std::stack<BinaryTree> stack;
// ֵһ
BinaryTree new_tree = tree;
// ջջnew_treeʱѭ
while (new_tree || !stack.empty()) {
// һֱ
if (new_tree) {
// ǰջ
stack.push(new_tree);
// Ӳһֱ
new_tree = new_tree->left_child;
}
// ջת
else {
// ջԪأɾԪ
new_tree = stack.top();
// ɾջԪصֵ
stack.pop();
// ʳջ
if (!function(new_tree)) {
printf("InOrderNonRecursive:ʽʧܣ");
return false;
}
//
new_tree = new_tree->right_child;
// while
}
}
return true;
}
//
bool LevelOrderBinaryTree(BinaryTree &tree, bool(*function)(BinaryTree &)) {
// ʼ
std::queue<BinaryTree> queue;
// ʼ
BinaryTree new_tree = tree;
//
queue.push(new_tree);
// зǿѭ
while (!queue.empty()) {
// ͷ
new_tree = queue.front();
queue.pop();
// ʳӽ
if (!function(new_tree)) {
printf("LevelOrder:ʽʧܣ");
return false;
}
//
if (new_tree->left_child != nullptr) {
queue.push(new_tree);
}
if (new_tree->right_child != nullptr) {
queue.push(new_tree);
}
}
return true;
}
//
BinaryTreeNode *SearchBinarySortTree(BinaryTree tree, element_type elem) {
BinaryTree node = tree;
// ջڸֵͽѭ
while (node != nullptr && elem != node->data) {
// С
if (CompareElem(elem, node->data) < 0)
node = node->left_child;
else
node = node->right_child;
}
return node;
}
//
bool InsertBinarySortTree(BinaryTree &tree, element_type elem) {
if (elem == NULL){
printf("InsertBinarySortTree:ݲӦΪգ\n");
return false;
}
// ԭΪգ²ļ¼Ϊ
if (tree == nullptr) {
tree = (BinaryTree) malloc(sizeof(BinaryTreeNode));
tree->data = elem;
tree->left_child = tree->right_child = nullptr;
return true;
}
// ͬؼֵĽʧ
else if (CompareElem(elem, tree->data) == 0)
return false;
// С뵽
else if (CompareElem(elem, tree->data) < 0)
return InsertBinarySortTree(tree->left_child, elem);
// 뵽
else
return InsertBinarySortTree(tree->right_child, elem);
}
//
bool CreateBinarySortTree(BinaryTree &tree, element_type* elem, int start, int length){
// ʼ
tree = nullptr;
int i = 0;
while(i<length){
if(!InsertBinarySortTree(tree,elem[start+i]))
return false;
i++;
}
return true;
}
// ɾ
bool DeleteBinarySortTree();
================================================
FILE: Code/Code/head/search.h
================================================
#include "head.h"
// Ա
typedef struct {
elem_type *data;
int length;
} LinearTable;
// ˳
int SequenceSearch(LinearTable table, elem_type key) {
for (int i = 0; i < table.length; i++) {
if (table.data[i] == key)
return i;
}
return -1;
}
// ۰
int BinarySearch(LinearTable table, elem_type key) {
int low = 0, high = table.length - 1, mid;
while (low <= high) {
mid = (low + high) / 2;
if (table.data[mid] == key)
return mid;
else if (table.data[mid] > key)
high = mid - 1;
else
low = mid + 1;
}
return -1;
}
================================================
FILE: Code/Code/head/sequence_list.h
================================================
#include "head.h"
// ̬˳
typedef struct {
element_type *data;
int length;
} StaticSequenceList;
// ̬˳
typedef struct {
element_type *data;
int max_size, length;
} DynamicSequenceList;
// ʼ
bool InitSequenceList(StaticSequenceList &list) {
list.data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
list.length = 0;
return true;
}
bool InitSequenceList(StaticSequenceList &list, int max_size) {
list.data = (element_type *) malloc(sizeof(element_type) * max_size);
list.length = 0;
return true;
}
StaticSequenceList InitStaticSequenceList() {
auto *list = (StaticSequenceList *) malloc(sizeof(StaticSequenceList));
list->data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
list->length = 0;
return (StaticSequenceList &) list;
}
StaticSequenceList InitStaticSequenceList(int max_size) {
auto *list = (StaticSequenceList *) malloc(sizeof(StaticSequenceList));
list->data = (element_type *) malloc(sizeof(element_type) * max_size);
list->length = 0;
return (StaticSequenceList &) list;
}
bool InitSequenceList(DynamicSequenceList &list) {
list.length = 0;
list.data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
list.max_size = MAXSIZE;
return true;
}
bool InitSequenceList(DynamicSequenceList &list, int max_size) {
list.length = 0;
list.data = (element_type *) malloc(sizeof(element_type) * max_size);
list.max_size = max_size;
return true;
}
DynamicSequenceList InitDynamicSequenceList() {
auto *list = (DynamicSequenceList *) malloc(sizeof(DynamicSequenceList));
list->data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
list->length = 0;
list->max_size = MAXSIZE;
return (DynamicSequenceList &) list;
}
DynamicSequenceList InitDynamicSequenceList(int max_size) {
auto *list = (DynamicSequenceList *) malloc(sizeof(DynamicSequenceList));
list->data = (element_type *) malloc(sizeof(element_type) * max_size);
list->length = 0;
list->max_size = MAXSIZE;
return (DynamicSequenceList &) list;
}
// ӡ
template<class List>
bool PrintSequenceList(List list) {
for (int i = 0; i < list.length; i++) {
printf("%dԪֵΪ%c\n", i + 1, list.data[i]);
}
return true;
}
// 鳤
bool IncreaseSequenceList(DynamicSequenceList &list, int length) {
if (length <= 0) {
printf("IncreaseSequenceList:ռӦô0\n");
return false;
}
// һƬĴ洢ռ
int new_length = list.max_size + length;
void *pointer = realloc(list.data, new_length * sizeof(element_type));
if (pointer == nullptr) {
printf("IncreaseSequenceList:ʧܣ\n");
return false;
}
return true;
}
// п
template<class List>
bool EmptySequenceList(List list) {
return list.length == 0;
}
//
bool InsertSequenceList(StaticSequenceList &list, int index, element_type elem) {
// ̬˳Ѿ˾ͲܲκԪ
if (list.length >= MAXSIZE) {
printf("InsertSequenceList:̬˳ռ䲻㣬ʧܣ\n");
return false;
}
// λô0ʼԿԲķΧ0list->length
if (index > list.length || index < 0) {
printf("InsertSequenceList:%dΧ\n", index);
return false;
}
// һԪؿʼƣlist->lengthǿյ
for (int i = list.length; i > index; i--) {
list.data[i] = list.data[i - 1];
}
list.data[index] = elem;
list.length++;
return true;
}
bool InsertSequenceList(DynamicSequenceList &list, int index, element_type elem) {
if (index > list.length || index < 0) {
printf("InsertDynamicSequenceList:%dΧ\n", index);
return false;
}
// ̬˳ѾˣҪһλ
// Ϊ˱Чһռ䣬Էڼֵĺ
if (list.length >= MAXSIZE) {
bool result = IncreaseSequenceList(list, 1);
if (!result) {
printf("InsertDynamicSequenceList:ռʧܣ\n");
return false;
}
}
for (int i = list.length; i > index; i--) {
list.data[i] = list.data[i - 1];
}
list.data[index] = elem;
list.length++;
return true;
}
// ѭ
template<class List>
bool LoopInsertSequenceList(List &list, element_type *elem, int start, int end) {
for (int i = 0; i < end; i++) {
bool result = InsertSequenceList(list, i, elem[i + start]);
if (!result) {
printf("LoopInsertSequenceList:ѭʧܣ\n");
return false;
}
}
return true;
}
// ɾ
template<class List>
element_type DeleteSequenceList(List &list, int index) {
if (index >= list.length || index < 0) {
printf("DeleteStaticSequenceList:ɾΧ\n");
return false;
}
element_type elem = list.data[index];
for (int i = index; i < list.length; i++) {
list.data[i] = list.data[i + 1];
}
list.length--;
return elem;
}
// ɾԪ
template<class List>
element_type* MultiDeleteSequenceList(List &list, int index, int length) {
if (index + length >= list.length || index < 0) {
printf("MultiDeleteSequenceList:ɾΧ\n");
return nullptr;
}
auto elem = new element_type[length];
for (int i = index; i < list.length - length; i++) {
if (i < index + length) {
elem[i - index] = list.data[i];
}
list.data[i] = list.data[i + length];
}
list.length -= length;
return elem;
}
// λ˳Ԫ
template<class List>
element_type GetSequenceListElem(List list, int index) {
if (index >= list.length || index < 0) {
printf("GetSequenceListElement:%dΧ\n", index);
return DEFAULTELEM;
}
return list.data[index];
}
// ֵ˳
template<class List>
int LocateSequenceList(List list, element_type elem) {
for (int i = 0; i < list.length; i++) {
if (list.data[i] == elem) {
return i;
}
}
printf("LocateSequenceListElement:δܶλӦֵ%cԪأ\n", elem);
return -1;
}
// ٶ̬˳
int DestroyDynamicSequenceList(DynamicSequenceList &list) {
delete (list.data);
return 0;
}
================================================
FILE: Code/Code/head/sequence_queue.h
================================================
#include "head.h"
// ˳
typedef struct {
//
element_type *data;
// ͷβ
int front, rear;
//
int max_size;
} SequenceQueue;
// ʼ
bool InitSequenceQueue(SequenceQueue &queue) {
queue.data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
queue.front = 0;
queue.rear = 0;
queue.max_size = MAXSIZE;
return true;
}
bool InitSequenceQueue(SequenceQueue &queue, int max_size) {
queue.data = (element_type *) malloc(sizeof(element_type) * max_size);
queue.front = 0;
queue.rear = 0;
queue.max_size = max_size;
return true;
}
SequenceQueue InitSequenceQueue() {
auto *queue = (SequenceQueue *) malloc(sizeof(SequenceQueue));
queue->data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
queue->front = 0;
queue->rear = 0;
queue->max_size = MAXSIZE;
return (SequenceQueue &) queue;
}
SequenceQueue InitSequenceQueue(int max_size) {
auto *queue = (SequenceQueue *) malloc(sizeof(SequenceQueue));
queue->data = (element_type *) malloc(sizeof(element_type) * max_size);
queue->front = 0;
queue->rear = 0;
queue->max_size = max_size;
return (SequenceQueue &) queue;
}
// п
bool EmptySequenceQueue(SequenceQueue queue) {
return queue.front == queue.rear;
}
// ڼ
bool FullSequenceQueue(SequenceQueue queue) {
return queue.rear == queue.max_size;
}
// ѭ
bool FullCircularSequenceQueue(SequenceQueue queue) {
return (queue.rear + 1) % queue.max_size == queue.front;
}
//
bool EnterSequenceQueue(SequenceQueue &queue, element_type elem) {
// ж϶
if (FullSequenceQueue(queue)) {
printf("EnterSequenceQueue:ӣ\n");
return false;
}
queue.data[queue.rear++] = elem;
return true;
}
// ѭ
bool EnterCircularSequenceQueue(SequenceQueue &queue, element_type elem) {
// ѭ
if (FullCircularSequenceQueue(queue)) {
printf("EnterCircularSequenceQueue:ӣ\n");
return false;
}
queue.data[queue.rear] = elem;
queue.rear = (queue.rear + 1) % queue.max_size;
return true;
}
//
element_type DepartSequenceQueue(SequenceQueue &queue) {
// ж϶ӿ
if (EmptySequenceQueue(queue)) {
printf("DepartSequenceQueue:ӿӣ\n");
return DEFAULTELEM;
}
return queue.data[queue.front++];
}
// ѭ
element_type DepartCircularDepartSequence(SequenceQueue &queue) {
// ж϶ӿ
if (EmptySequenceQueue(queue)) {
printf("DepartCircularDepartSequence:ӿӣ\n");
return DEFAULTELEM;
}
element_type elem = queue.data[queue.front];
queue.front = (queue.front + 1) % queue.max_size;
return elem;
}
// ȡӳ
int LengthSequenceQueue(SequenceQueue queue) {
return (queue.rear - queue.front + queue.max_size) % queue.max_size;
}
// ͷ
element_type HeadSequenceQueue(SequenceQueue &queue) {
// ж϶ӿ
if (EmptySequenceQueue(queue)) {
printf("HeadSequenceQueue:ӿͷ\n");
return DEFAULTELEM;
}
return queue.data[queue.front];
}
================================================
FILE: Code/Code/head/sequence_stack.h
================================================
#include "head.h"
// ˳ջ
typedef struct SequenceStack {
// ջԪ
element_type *data;
// ջָ
int top;
//
int max_size;
} SequenceStack;
// ʼ
bool InitSequenceStack(SequenceStack &stack) {
stack.data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
stack.top = -1;
stack.max_size = MAXSIZE;
return true;
}
bool InitSequenceStack(SequenceStack &stack, int max_size) {
stack.data = (element_type *) malloc(sizeof(element_type) * max_size);
stack.top = -1;
stack.max_size = max_size;
return true;
}
SequenceStack InitSequenceStack(){
auto* stack = (SequenceStack*) malloc(sizeof(SequenceStack));
stack->data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
stack->top = -1;
stack->max_size = MAXSIZE;
return (SequenceStack &) stack;
}
SequenceStack InitSequenceStack(int max_size){
auto* stack = (SequenceStack*) malloc(sizeof(SequenceStack));
stack->data = (element_type *) malloc(sizeof(element_type) * max_size);
stack->top = -1;
stack->max_size = max_size;
return (SequenceStack &) stack;
}
// п
bool EmptySequenceStack(SequenceStack stack) {
return stack.top == -1;
}
//
bool FullSequenceStack(SequenceStack stack) {
return stack.top == stack.max_size - 1;
}
// ջ
int LengthSequenceStack(SequenceStack stack) {
return stack.top + 1;
}
// ջ
bool PushSequenceStack(SequenceStack &stack, element_type elem){
if(FullSequenceStack(stack)){
printf("PushSequenceStack:ջջ\n");
return false;
}
// Լٽջ
stack.data[++stack.top] = elem;
return true;
}
// ջ
element_type PopSequenceStack(SequenceStack &stack){
if(EmptySequenceStack(stack)){
printf("PopSequenceStack:ջջ\n");
return DEFAULTELEM;
}
// ȳջԼ
return stack.data[stack.top--];
}
// ջ
element_type TopSequenceStack(SequenceStack stack){
if(EmptySequenceStack(stack)){
printf("TopSequenceStack:ջջԪأ\n");
return DEFAULTELEM;
}
return stack.data[stack.top];
}
================================================
FILE: Code/Code/head/sequence_string.h
================================================
#include "head.h"
// ˳
typedef struct {
//
char *data;
//
int length;
//
int max_size;
} SequenceString;
bool InitSequenceString(SequenceString &string) {
string.data = (char *) malloc(sizeof(char) * MAXSIZE);
string.max_size = MAXSIZE;
string.length = 0;
return true;
}
bool InitSequenceString(SequenceString &string, int max_size) {
string.data = (char *) malloc(sizeof(char) * max_size);
string.max_size = max_size;
string.length = 0;
return true;
}
SequenceString InitSequenceString() {
auto *string = (SequenceString *) malloc(sizeof(SequenceString));
string->data = (char *) malloc(sizeof(char) * MAXSIZE);
string->max_size = MAXSIZE;
string->length = 0;
return (SequenceString &) string;
}
SequenceString InitSequenceString(int max_size) {
auto *string = (SequenceString *) malloc(sizeof(SequenceString));
string->data = (char *) malloc(sizeof(char) * max_size);
string->max_size = max_size;
string->length = 0;
return (SequenceString &) string;
}
// ַƥ
int LocateSimple(SequenceString string, SequenceString pattern) {
int i = 0, j = 0;
while (i < string.length && j < pattern.length) {
// ƥͼ
if (string.data[i] == pattern.data[j]) {
i++;
j++;
}
// ƥͳ
else {
i = i - j + 1;
j = 0;
}
}
if (j >= pattern.length) {
return i - pattern.length;
}
return -1;
}
// ȡKMPnext
int *GetNext(SequenceString string) {
auto *next = (int *) malloc(sizeof(int) * string.length);
next[0] = 0;
// iΪǰƥַλãҲnext
int i = 0, j = 0;
while (i < string.length) {
if (j == 0 || string.data[i] == string.data[j]) {
next[++i] = ++j;
} else {
j = next[j];
}
}
return next;
}
// ȡKMPnextval
int *GetNextVal(SequenceString string) {
auto *nextval = (int *) malloc(sizeof(int) * string.length);
nextval[0] = 0;
// iΪǰƥַλãҲnext
int i = 0, j = 0;
while (i < string.length) {
if (j == 0 || string.data[i] == string.data[j]) {
++i;
++j;
if (string.data[i] != string.data[j])
nextval[i] = j;
else
nextval[i] = nextval[j];
} else {
j = nextval[j];
}
}
return nextval;
}
int LocateKMP(SequenceString string, SequenceString pattern, const int *next) {
int i = 0, j = 0;
while (i < string.length && j < pattern.length) {
if (j == 0 || string.data[i] == pattern.data[j]) {
// ƥȽ
++i;
++j;
} else {
// ģʽ
j = next[j];
}
}
if (j >= pattern.length) {
// ƥɹ
return i - pattern.length;
} else {
return -1;
}
}
int LocateKMP(SequenceString string, SequenceString pattern) {
int *next = GetNext(pattern);
int i = 0, j = 0;
while (i < string.length && j < pattern.length) {
if (j == 0 || string.data[i] == pattern.data[j]) {
// ƥȽ
++i;
++j;
} else {
// ģʽ
j = next[j];
}
}
if (j >= pattern.length) {
// ƥɹ
return i - pattern.length;
} else {
return -1;
}
}
bool DestroySequenceString(SequenceString &string) {
free(string.data);
string.max_size = 0;
string.length = 0;
return true;
}
================================================
FILE: Code/Code/head/share_stack.h
================================================
#include "head.h"
typedef struct {
//
element_type *data;
// ջָ
int top_left, top_right;
//
int max_size;
} ShareStack;
// ʼ
bool InitShareStack(ShareStack &stack) {
stack.data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
stack.top_left = -1;
stack.top_right = MAXSIZE;
stack.max_size = MAXSIZE;
return true;
}
bool InitShareStack(ShareStack &stack, int max_size) {
stack.data = (element_type *) malloc(sizeof(element_type) * max_size);
stack.top_left = -1;
stack.top_right = max_size;
stack.max_size = max_size;
return true;
}
ShareStack InitShareStack() {
auto *stack = (ShareStack *) malloc(sizeof(ShareStack));
stack->data = (element_type *) malloc(sizeof(element_type) * MAXSIZE);
stack->top_left = -1;
stack->top_right = MAXSIZE;
stack->max_size = MAXSIZE;
return (ShareStack &) stack;
}
ShareStack InitShareStack(int max_size) {
auto *stack = (ShareStack *) malloc(sizeof(ShareStack));
stack->data = (element_type *) malloc(sizeof(element_type) * max_size);
stack->top_left = -1;
stack->top_right = max_size;
stack->max_size = max_size;
return (ShareStack &) stack;
}
//
bool EmptyLeftShareStack(ShareStack stack){
return stack.top_left == -1;
}
// ҿ
bool EmptyRightShareStack(ShareStack stack){
return stack.top_right == stack.max_size;
}
//
bool FullShareStack(ShareStack stack){
return stack.top_right - stack.top_left == 1;
}
// ջ
int LengthLeftShareStack(ShareStack stack){
return stack.top_left + 1;
}
// ջ
int LengthRightShareStack(ShareStack stack){
return stack.max_size - stack.top_right;
}
// ջ
bool PushLeftShareStack(ShareStack &stack, element_type elem){
if(FullShareStack(stack)){
printf("PushLeftShareStack:ջջ\n");
return false;
}
stack.data[++stack.top_left] = elem;
return true;
}
// ҽջ
bool PushRightShareStack(ShareStack &stack, element_type elem){
if(FullShareStack(stack)){
printf("PushRightShareStack:ջջ\n");
return false;
}
stack.data[--stack.top_right] = elem;
return true;
}
// ջ
element_type PopLeftShareStack(ShareStack &stack){
if(EmptyLeftShareStack(stack)){
printf("PopLeftShareStack:ջջ\n");
return DEFAULTELEM;
}
element_type elem = stack.data[stack.top_left];
stack.top_left--;
return elem;
}
// ҳջ
element_type PopRightShareStack(ShareStack &stack){
if(EmptyLeftShareStack(stack)){
printf("PopRightShareStack:ջջ\n");
return DEFAULTELEM;
}
element_type elem = stack.data[stack.top_right];
stack.top_left++;
return elem;
}
// ȡײ
element_type TopLeftShareStack(ShareStack stack){
if(EmptyLeftShareStack(stack)){
printf("PopLeftShareStack:ջջ\n");
return DEFAULTELEM;
}
return stack.data[stack.top_left];
}
// ȡײ
element_type TopRightShareStack(ShareStack stack){
if(EmptyLeftShareStack(stack)){
printf("TopRightShareStack:ջջ\n");
return DEFAULTELEM;
}
return stack.data[stack.top_right];
}
================================================
FILE: Code/Code/head/sort.h
================================================
#include "head.h"
// ֱӲ
bool StraightInsertSort(LinearTable table) {
// ѭӵڶʼ
for (int i = 1; i < table.length; i++) {
// ǰԪСǰһСеֵҪԵǰԪ
if (table.data[i] < table.data[i - 1]) {
// ǰǷбȵǰԪشģ嵽ǰԪغ
int temp = table.data[i];
// ϺԪ
int j;
for (j = i - 1; j >= 0 && table.data[j] > temp; j--) {
table.data[j + 1] = table.data[j];
}
// tempմ
table.data[j + 1] = temp;
}
}
return true;
}
// ۰
bool BinaryInsertSort(LinearTable table) {
// ָ
int i, j, low, high, mid;
elem_type temp;
// νԪز뵽ǰ
for (i = 1; i < table.length; i++) {
temp = table.data[i];
// ۰ҵķΧ0ǰԪǰһԪ
low = 0;
high = i - 1;
while (low <= high) {
// ȡм
mid = (low + high) / 2;
// ӱ
if (table.data[mid] > table.data[0])
high = mid - 1;
// ӱ
else
low = mid + 1;
}
for (j = i - 1; j > high; j--) {
// һλճλ
table.data[j + 1] = table.data[j];
}
table.data[j + 1] = temp;
}
return true;
}
// ϣ
bool ShellSort(LinearTable table) {
int j;
// ò
for (int group = table.length / 2; group > 0; group /= 2) {
for (int i = group; i < table.length; i++) {
elem_type temp = table.data[i];
for (j = i; j >= group && temp < table.data[j - group]; j -= group) {
table.data[j] = table.data[j - group];
}
table.data[j] = temp;
}
}
return true;
}
// ð
bool BubbleSort(LinearTable table) {
elem_type temp;
// ѭΪһҪlength-1
for (int i = 0; i < table.length - 1; i++) {
// ѭΪi˱ȽϴΪlength-i
// ɵں
for (int j = 0; j < table.length - 1 - i; j++) {
if (table.data[j] > table.data[j + 1]) {
temp = table.data[j];
table.data[j] = table.data[j + 1];
table.data[j + 1] = temp;
}
}
}
return true;
}
// һ˻
int PartQuickSort(LinearTable table, int low, int high) {
// еһԪΪŦԱл
elem_type pivot = table.data[low];
// ѭ
while (low < high) {
// Ԫشһֱ
while (low < high && table.data[high] >= pivot)
--high;
// СԪƶ
table.data[low] = table.data[high];
while (low < high && table.data[low] <= pivot)
++low;
// ԪƶҶ
table.data[high] = table.data[low];
}
// Ԫطŵλ
table.data[low] = pivot;
return low;
}
//
bool QuickSort(LinearTable table, int low, int high) {
// ݹ
if (low < high) {
//
int pivot = PartQuickSort(table, low, high);
// ݹ
PartQuickSort(table, low, pivot - 1);
PartQuickSort(table, pivot + 1, high);
}
return true;
}
// ѡ
bool SimpleSelectSort(LinearTable table) {
int min;
for (int i = 0; i < table.length - 1; i++) {
// ¼СԪ
min = i;
// ѡСԪ
for (int j = i + 1; j < table.length; j++) {
// СԪλ
if (table.data[j] < table.data[min])
min = j;
// Ԫ
if (min != i) {
elem_type temp = table.data[min];
table.data[min] = table.data[i];
table.data[i] = temp;
}
}
}
return true;
}
//
bool BuildHeap(LinearTable table, bool HeadAdjust(LinearTable table, int index)) {
// i=[n/2]~1ʼ
for (int i = table.length / 2; i > 0; i--) {
bool result = HeadAdjust(table, i);
if (!result)
return false;
}
return true;
}
//
bool HeadMaxAdjust(LinearTable table, int index) {
// ԪΪֵindexе֮ԪѾ
// 0ݴ
table.data[0] = table.data[index];
// ֵϴӽɸѡ
for (int i = 2 * index; i <= table.length; i *= 2) {
// Ѱҽϴӽ±
if (i < table.length && table.data[i] < table.data[i + 1])
i++;
// ɸѡΪҪҵԪرȸ
if (table.data[0] >= table.data[i])
break;
else {
// indexԪص˫
table.data[index] = table.data[i];
// indexֵԱɸѡ
index = i;
}
}
// ɸѡλ
table.data[index] = table.data[0];
return true;
}
//
bool HeapSort(LinearTable table, bool mode){
bool result;
// modeΪtrueѣfalseС
if(mode)
result = BuildHeap(table, HeadMaxAdjust);
if(!result)
return false;
for(int i=table.length;i>1;i--){
// ջԪغջԪؽ
elem_type temp = table.data[0];
table.data[0] = table.data[i];
table.data[i] = temp;
if(mode)
HeadMaxAdjust(table,i);
}
return true;
}
================================================
FILE: Code/Code/head/static_link_list.h
================================================
#include "head.h"
// ̬
typedef struct {
// Ԫ
element_type data;
// ±
int next;
} StaticLinkList[MAXSIZE];
================================================
FILE: Code/Code/head/thread_tree.h
================================================
#include "head.h"
//
typedef struct ThreadBinaryTreeNode {
//
element_type data;
// Һӽ
ThreadBinaryTreeNode *left_child, *right_child;
// ָ
int left_tag, right_tag;
} ThreadBinaryTreeNode, *ThreadBinaryTree;
//
bool InOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree &pre) {
if (tree != nullptr) {
// ݹ
InOrderThreadBinaryTree(tree->left_child, pre);
// Ϊգǰ
if (tree->left_child == nullptr) {
// ָǰ
tree->left_child = pre;
tree->left_tag = 1;
}
// ǰΪǰΪ
if (pre != nullptr && pre->right_child == nullptr) {
// ǰĺָǰ
pre->right_child = tree;
pre->right_tag = 1;
}
// ǰΪǰ
pre = tree;
// ݹ
InOrderThreadBinaryTree(tree->right_child, pre);
}
return true;
}
//
bool CreateInOrderThreadBinaryTree(ThreadBinaryTree tree) {
ThreadBinaryTreeNode *pre = nullptr;
if (tree != nullptr) {
//
InOrderThreadBinaryTree(tree, pre);
// һ
pre->right_child = nullptr;
pre->right_tag = 1;
}
return true;
}
// еһ
ThreadBinaryTreeNode *FirstInOrderBinaryTreeNode(ThreadBinaryTreeNode *node) {
// ӽ
while (node->left_tag == 0) {
// µĽ㣬һҶӽ
node = node->left_child;
}
return node;
}
// к
ThreadBinaryTreeNode *NextInOrderBinaryTreeNode(ThreadBinaryTreeNode *node){
// Һӽ㣬ҵ
if(node->right_tag==0){
return FirstInOrderBinaryTreeNode(node->right_child);
}
else
// кֱӷ
return node->right_child;
}
//
bool InOrderThreadBinaryTree(ThreadBinaryTree *tree,bool( *function)(ThreadBinaryTreeNode)){
for(ThreadBinaryTreeNode *node= FirstInOrderBinaryTreeNode(*tree);node != nullptr;node= NextInOrderBinaryTreeNode(node)){
if(!function(*node))
return false;
}
return true;
}
//
bool PreOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree &pre) {
if (tree != nullptr) {
// Ϊգǰ
if (tree->left_child == nullptr) {
// ָǰ
tree->left_child = pre;
tree->left_tag = 1;
}
// ǰΪǰΪ
if (pre != nullptr && pre->right_child == nullptr) {
// ǰĺָǰ
pre->right_child = tree;
pre->right_tag = 1;
}
// ǰΪǰ
pre = tree;
// ҪжǷ
if(tree->left_tag==0){
// ݹ
InOrderThreadBinaryTree(tree->left_child, pre);
}
// ݹ
InOrderThreadBinaryTree(tree->right_child, pre);
}
return true;
}
//
bool CreatePreOrderThreadBinaryTree(ThreadBinaryTree tree) {
ThreadBinaryTreeNode *pre = nullptr;
if (tree != nullptr) {
//
PreOrderThreadBinaryTree(tree, pre);
// һ
pre->right_child = nullptr;
pre->right_tag = 1;
}
return true;
}
//
bool PostOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree &pre) {
if (tree != nullptr) {
// ݹ
InOrderThreadBinaryTree(tree->left_child, pre);
// ݹ
InOrderThreadBinaryTree(tree->right_child, pre);
// Ϊգǰ
if (tree->left_child == nullptr) {
// ָǰ
tree->left_child = pre;
tree->left_tag = 1;
}
// ǰΪǰΪ
if (pre != nullptr && pre->right_child == nullptr) {
// ǰĺָǰ
pre->right_child = tree;
pre->right_tag = 1;
}
// ǰΪǰ
pre = tree;
}
return true;
}
//
bool CreatePostOrderThreadBinaryTree(ThreadBinaryTree tree) {
ThreadBinaryTreeNode *pre = nullptr;
if (tree != nullptr) {
//
PreOrderThreadBinaryTree(tree, pre);
// һ
pre->right_child = nullptr;
pre->right_tag = 1;
}
return true;
}
================================================
FILE: Code/Code/head/tree.h
================================================
#include "head.h"
// ˫ױʾ
//
typedef struct {
element_type data;
// ˫λ
int parent;
} ParentTreeNode;
//
typedef struct {
//
ParentTreeNode* data;
//
int length;
//
int max_length;
} ParentTree;
// ֵܱʾ
//
typedef struct ChildSiblingTreeNode {
//
element_type data;
// һ
struct ChildSiblingTreeNode *frist_child;
// һֵ
struct ChildSiblingTreeNode *next_sibling;
} ChildSiblingTreeNode, *ChildSiblingTree;
================================================
FILE: Code/Code/source/main.cpp
================================================
#include "test.cpp"
int main()
{
//SequenceListTest();
// LinkListTest();
SortTest();
return 0;
}
================================================
FILE: Code/Code/source/test.cpp
================================================
//
#include <iostream>
#include "../head/sequence_list.h"
#include "../head/link_list.h"
#include "../head/double_link_list.h"
#include "../head/static_link_list.h"
#include "../head/sequence_stack.h"
#include "../head/link_stack.h"
#include "../head/share_stack.h"
#include "../head/sequence_queue.h"
#include "../head/link_queue.h"
#include "../head/sequence_string.h"
#include "../head/link_string.h"
#include "../head/link_tree.h"
#include "../head/thread_tree.h"
#include "../head/tree.h"
#include "../head/graph.h"
#include "../head/search.h"
#include "../head/sort.h"
using namespace std;
bool SequenceListTest() {
DynamicSequenceList list;
InitSequenceList(list);
element_type a[6] = {'1','2','3','4','5','6'};
LoopInsertSequenceList(list, a, 0, 6);
//printf("%d", list.length);
PrintSequenceList(list);
printf("\n");
int len = 2;
element_type* elem = MultiDeleteSequenceList(list, 0, len);
PrintSequenceList(list);
for (int i = 0; i < len; i++) {
printf("%c\n", elem[i]);
}
cout << EmptySequenceList(list) << endl;
return true;
}
bool LinkListTest() {
element_type a[6] = { '0', '1','2','3','4','5' };
LinkList list = InitLinkList();
cout << EmptyLinkList(list) << endl;
//InsertLinkListWithoutHead(list, 0, '2');
InsertLinkListWithoutHead(list, 0, '4');
//InsertLinkListWithHead(list, 1, '5');
PriorInsertLinkList(list, a, 1, 5);
PrintLinkList(list);
int length = 2;
//element_type* data = DeleteLinkListWithHead(list, 2, length);
element_type* data = DeleteLinkListWithoutHead(list, 2, length);
PrintLinkList(list);
for (int i = 0; i < length; i++) {
printf("??%d?%c\n", i, data[i]);
}
printf("?????%d", GetLengthLinkList(list));
printf("%c???%d", '3', LocateLinkList(list, '3'));
return true;
}
bool SortTest(){
LinearTable table;
int a[3] = {2,4,1};
table.data = a;
table.length = 3;
StraightInsertSort(table);
printf("%d", table.data[0]);
printf("%d", table.data[1]);
printf("%d", table.data[2]);
return true;
}
================================================
FILE: Computer-Network/0-summary-ex.md
================================================
# 概述习题
## 计算机网络
**例题** 计算机网络可被理解为()。
$A$.执行计算机数据处理的软件模块
$B$.由自治的计算机互联起来的集合体
$C$.多个处理器通过共享内存实现的紧耦合系统
$D$.用于共同完成一项任务的分布式系统
解：$B$。计算机网络是由自治计算机互联起来的集合体，其中包含着三个关键点:自治计算机、互联、集合体。自治计算机由软件和硬件两部分组成，所以A错误，能完整地实现计算机的各种功能；互联是指计算机之间能实现相互通信;集合体是指所有使用通信线路及互联设备连接起来的自治计算机的集合。选项C和D分别指多机系统和分布式系统。
**例题** 在计算机网络中可以没有的是()。
$A$.客户机
$B$.务器
$C$.操作系统
$D$.数据库管理系统
解：$D$。从物理组成上看，计算机网络由硬件、软件和协议组成，客户机是客户访问网络的出入口，服务器是提供服务、存储信息的设备，当然是必不可少的。只是，在P2P模式下，服务器不一定是固定的某台机器，但网络中一定存在充当服务器角色的计算机。操作系统是最基本的软件。数据库管理系统用于管理数据库，由于在一个网络上可以没有数据库系统，所以数据库管理系统可能没有。
## 数据交换方式
计算时需要注意：
1. 单位换算。
2. 是否考虑传播时延。
3. 选择最少跳数。
4. 起始时间。
5. 是否要计算头部大小。
6. 报文交换时延更长，分组交换时延可能不是整数。
带宽与发送时延相关；传播时延仅与距离相关，电磁波传播速度往往是定值。
### 交换方式计算
传播时延基本上三种交换方式都是一样的。
#### 电路交换
电路交换不使用存储转发，所以时间开销只包含传播时延、发送时延和一个电路建立时间。
发送时延直接数据总长度÷链路发送速率就可以了。
#### 报文交换
以报文为单位，使用存储转发技术。
发送时延为报文总长度÷链路发送速率×链路条数。
#### 分组交换
分组交换的发送时延都按两个步骤来计算。第一是发送整个分组的时延，第二是单个分组经过所有交换机分组转发的时间。
为什么要这样考虑？因为在第一步时所有的分组都被发送出去了，就不用考虑前面的分组怎么样了，只用考虑最后一个分组还要多长时间到达目的，之前的分组肯定在此之前都达到了目标，所以这就是为什么第二步只用考虑一个分组进行分组转发算时间的原因。
### 传输时间
**例题** 已知要传输一份信息大小为$10000bit$，需要经过两个交换设备。所有链路的传输速率为$1000bps$。假如分组交换中每一个分组为$10bit$，其他条件忽略（如接收时延，排队时延、报文头部长度等），求报文交换与分组交换两种方式所需要的传输时间。
解：
报文交换：
$10000\div1000=10(s)$，从而报文在每一个链路上需要$10s$的传输时延。因为要经过两个交换设备所以有三条链路，从而一共需要$10\times3=30(s)$。
分组交换：
每个分组传输需要$10\div1000=0.01(s)$，而一共有$10000\div10=1000$个分组，所以一共需要$0.01×1000=10(s)$发送所有分组。
此时$10s$的时候所有的分组已经发送出去了，不考虑传播时延的情况下，按照报文交换的视角整个数据都到达了第一个交换设备，而按分组交换视角，是最后一个分组到达了第一个交换设备，倒数第二个分组到达第二个交换设备，倒数第三个分组以及以前的分组都已经到达了，所以我们还需要计算还需要多少秒完全传输完。倒数第一个分组是最后一个，所以只用考虑它。最后一个分组还需要传输两个链路，所以还需要$0.01\times2=0.02(s)$，所以总共的分组交换需要$10+0.02=10.02(s)$。
**例题** 在采用“存储-转发”方式的分组交换网络中，所有链路的数据传输速率为$100Mb/s$，分组大小为$1000B$，其中分组头大小为$20B$。若主机$H1$经过两个分组交换机向主机$H2$发送一个大小为$980000B$的文件，则在不考虑分组拆装时间和传播延迟的情况下，从$H1$发送开始到$H2$接收完为止，需要的时间至少是()。
$A.80ms$
$B.80.08ms$
$C.80.16ms$
$D.80.24ms$
解：$C$。因为分组大小为$1000B$，其中分组头大小为$20B$，所以只能携带$1000-20=980B$个数据，而一共要发送一个$980000B$的文件，所以分为$1000$组分组，从而总的数据量为$1000\times1000=10^6B=1MB=8Mbit$。根据链路传输速率为$100Mb/s$，所以为$0.08s=80ms$。这时所有的分组都被$H_1$发出。
然后考虑最后一个分组的发送情况。因为有两个分组交换机，所以在$H_1$发出后还需要经过两次分组转发才能到达$H_2$，不考虑传播时延则不计算电磁波传播时间。每次最后一个分组进行分组转发的时间为$1000\times8/100=0.08ms$，一共两个交换机，所以还要$0.16ms$。
所以总共为$80.16ms$。
**例题** 试在下列条件下比较电路交换和分组交换。要传送的报文共$x$比特。从源点到终点共经过$k$段链路，每段链路的传播时延为$d$秒，数据传输速率为$b$比特/秒。在电路交换时电路的建立时间为$s$秒。在分组交换时分组长度为$p$比特，且各结点的排队等待时间可忽略不计。问在怎样的条件下，分组交换的时延比电路交换的时延要小？（提示:画草图观察k段链路共有几个结点）
解：忽略排队等待时延，所以电路交换时延=建立连接时延+发送时延+传播时延，分组交换时延=发送时延+传播时延。
电路交换与分组交换都是经过同样长度的链路，传播时延一样，有$k$条链路，所以传播时延都是$kd$。
由于电路交换不使用存储转发，所以有$k$条链路对其没有存储转发的影响，是一直传送到目标，所以发送时延=$x/b$。
所以电路交换的总时延就是再加上$s$，为$s+x/b+kd$。
对于分组交换，总共设置了$x/p$个分组。
由于分组交换使用了存储转发技术，所以每一个站点就需要一次发送时延$p/b$。数据在经过$(k-1)p/b$个发送时延后从$k$个$p/b$开始都有一个分组发送成功。一共有$x/p$个分组，所以一共需要$(k-1)p/b+x/p\cdot p/b=(k-1)p/b+x/b$。
所以对于分组交换的总时延就是$(k-1)p/b+x/b+kd$。
若分组交换时延要小于电路交换时延，所以$(k-1)b/p<s$。
### 数据长度
**例题** 在上题的分组交换网中，设报文长度和分组长度分别为$x$和$p+h$比特，其中$p$为分组的数据部分的长度，而$h$为每个分组所带控制信息的固定长度，与$p$的大小无关。通信的两端共经过$k$段链路。链路的数据传输速率为$b$比特/秒，传播时延、结点的排队时延和处理时延均可忽略不计。若欲使总的时延为最小，问分组的数据部分长度$p$应取多大？
解：首先一共有$x/p$个分组。
前$(k-1)$个时间段所有数据都在发送，第$k$个开始发送到达，所以前面需要$(k-1)((p+h)/b)$，而后面计算所有分组发送成功的时间，即$x/p((p+h)/b)$。
最后相加得到$t=(k-1)((p+h)/b)+x/p((p+h)/b)$，$p$为自变量，对其求导得$\textrm{d}t/\textrm{d}p=(k-1)b-(xh/b)(1/p^2)$，令其等于0。
解得$p=\sqrt{(xh)/(k-1)}$。
### 数据分组
**例题** 假定有一个通信协议，每个分组都引入$100$字节的开销用于头和成帧。现在使用这个协议发送$10^6$字节的数据，然而在传送的过程中有一个字节被破坏，因而包含该字节的那个分组被丢弃。试对于$1000$字节和$20000$字节的分组的有效数据大小分别计算“开销＋丢失”字节的总数目。分组数据大小的最佳值是多少?
解：尤其注意这个每个分组都引入$100$字节的额外开销，这个不用于计算分组个数。
令分组数据的大小为$D$，所以一共需要$10^6/D$个分组，所以算上每组$100$字节的开销，一共需要$10^8/D$的额外开销。因为只丢失一个分组，所以开销+丢失一共$10^8/D+D$字节。
当$D=1000$时，消耗$10^8/1000+1000=101000$字节。
当$D=20000$时，消耗$10^8/20000+20000=25000$字节。
设消耗总数目为$y=10^8/D+D$，求其导数为$\textrm{d}y/\textrm{d}D=1-10^8/D^2$，令其为$0$，解得$D=10^4$时消耗最小，所以分组数据最好为$10000$字节。
## 性能指标
### RTT
$RTT$是从发送方发送数据开始，到发送方收到接收方的确认（假如收到数据立刻返回确认）总共经历的时延。
$RTT$=往返传播时延+末端处理时延。
所以$RTT$是与传播时延相关的，若没有末端处理时间，那么传播时延=$RTT/2$
**例题** 在下列情况下，计算传送$1000KB$文件所需要的总时间，即从开始传送时起直到文件的最后一位到达目的地为止的时间。假定往返时间$RTT$为$100ms$，一个分组是$1KB$（即$1024B$）的数据，在开始传送整个文件数据之前进行的起始握手过程需要$2RTT$的时间。
1）带宽是$1.5Mb/s$，数据分组可连续发送。
2）带宽是$1.5Mb/s$，但在发送完每个数据分组后，必须等待一个$RTT$（等待来自接收方的确认）才能发送下一个数据分组。
3）假设带宽是无限大的值，即我们取发送时间为$0$，并在等待每个$RTT$后可以发送多达$20$个分组。
1）解：计算总时延=发送时延+传播时延+握手时延。其中握手时延是固定的$2RTT=0.1\times2=0.2(s)$。
发送时延=$1000\times1024\times8/1.5\times10^6=5.46(s)$。
所以总时间为$0.2+5.46+0.05=5.71(s)$。
2）解：每一个数据都需要一个$RTT$，而$1000$个数据就需要$999$个，因为最后一个不用确认就传输完了。所以只需要第一题基础上加上$999RTT$：$5.71+99.9=105.61(s)$。
3）解：因为发送时延不计算，所以只用考虑传播时延。每个分组为$1KB$，所以可以分为$1000$个分组。而每次可以发送$20$个分组，所以需要发送$50$次数据和$50-1=49$次$RTT$，最后一次只需要走到终点而不需要等待返回，所以只用$0.5RTT$，从而一共为$2RTT+49RTT+0.5RTT=5.15RTT=5.15(s)$。
**例题** 假定在地球和月球之间建立一条$100Mb/s$的链路。月球到地球的距离约为$385000km$，数据在链路上以光速$3×10^8m/s$传输。
1）计算该链路的最小$RTT$。
2）使用$RTT$作为延迟，计算该链路的“延迟×带宽”值。
3）在2）中计算的“延迟×带宽”值的含义是什么？
4）在月球上用照相机拍取地球的相片，并把它们以数字形式保存到磁盘上。假定要
在地球上下载$25MB$的最新图像，那么从发出数据请求到传送结束最少要花多少时间?
1）解：最小RTT等于$2×385000000m/(3×10^8m/s)=2.57s$。
2）解：“延迟×带宽”值等于$2.57s×100Mb/s=257Mb=32MB$。
3）解：它表示发送方在收到一个响应之前能够发送的数据量。
4）解：在图像可以开始到达地面之前，至少需要一个$RTT$。假定仅有带宽延迟，那么发送需要的时间等于$25MB/(100Mb/s)=(25×1024×1024×8)bit/(100Mb/s)\approx2.1s$。因此，直到最后一个图像位到达地球，总共花的时间等于$2.1+2.57=4.67s$。注意这里$MB$的单位转换问题，$1M=2^{20}$而不是$10^6$。
## 体系结构
**例题** 下列能够最好地描述$OSI$参考模型的数据链路层功能的是()。
$A$.提供用户和网络的接口
$B$.处理信号通过介质的传输
$C$.控制报文通过网络的路由选择
$D$.保证数据正确的顺序和完整性
解：$D$。数据链路层的功能包括：链路连接的建立、拆除、分离；帧界定和帧同步；差错检测等。$A$是应用层的功能，$B$是物理层的功能，$C$是网络层的功能，$D$才是数据链路层的功能。
**例题** 当数据由端系统$A$传送至端系统$B$时，不参与数据封装工作的是()。
$A$.物理层
$B$.数据链路层
$C$.网络层
$D$.表示层
解：$A$。物理层以$0$、$1$比特流的形式透明地传输数据链路层递交的帧。网络层、表示层和应用层都为上层提交的数据加上首部，数据链路层为上层提交的数据加上首部和尾部，然后提交给下一层。物理层不存在下一层，自然也就不用封装。
**例题** 在$ISO/OSI$参考模型中，可同时提供无连接服务和面向连接服务的是()。
$A$.物理层
$B$.数据链路层
$C$.网络层
$D$.传输层
解：$C$。本题容易误选$D$。$ISO/OSI$参考模型在网络层支持无连接和面向连接的通信，但在传输层仅支持面向连接的通信：$TCP/IP$模型在网络层仅有无连接的通信，而在传输层支持无连接和面向连接的通信。两类协议栈的区别是统考的考点，而这个区别是常考点。
**例题** 下列说法中，正确描述了OSI参考模型中数据的封装过程的是()。
$A$.数据链路层在分组上仅增加了源物理地址和目的物理地址
$B$.网络层将高层协议产生的数据封装成分组，并增加第三层的地址和控制信息
$C$.传输层将数据流封装成数据帧,并增加可靠性和流控制信息
$D$.表示层将高层协议产生的数据分割成数据段，并增加相应的源和目的端口信息
解：$B$。$A$，数据链路层在分组上除增加源和目的物理地址外，也增加控制信息如$MAC$信息；$C$，传输层的$PDU$不称为帧而称为报文；$D$，表示层不负责把高层协议产生的数据分割成数据段，且负责增加相应源和目的端口信息的应是传输层。选项$B$正确描述了$OSI$参考模型中数据的封装过程，数据经过应用层、表示层、会话层后，只是增加了第三层$PCI$。
**例题** 在$OSI$参考模型中，提供流量控制功能的层是第(①)层；提供建立、维护和拆除端到端的连接的层是(②)；为数据分组提供在网络中路由的功能的是(③)；传输层提供(④)的数据传送；为网络层实体提供数据发送和接收功能及过程的是(⑤)。
① $A$.$1$、$2$、$3$ $B$.$2$、$3$、$4$ $C$.$3$、$4$、$5$ $D$.$4$、$5$、$6$
② $A$.物理层 $B$.数据链路层 $C$.会话层 $D$.传输层
③ $A$.物理层 $B$.数据链路层 $C$.网络层 $D$.传输层
④ $A$.主机进程之间 $B$.网络之间 $C$.数据链路之间 $D$.物理线路之间
⑤ $A$.物理层 $B$.数据链路层 $C$.会话层 $D$.传输层
解：①B、②D、③C、④A、⑤B。
$A$，在计算机网络中，流量控制指的是通过限制发送方发出的数据流量，从而使得其发送速率不超过接收方接收速率的一种技术。流量控制功能可以存在于数据链路层及其之上的各层中。目前提供流量控制功能的主要是数据链路层、网络层和传输层。不过，各层的流量控制对象不一样，各层的流量控制功能是在各层实体之间进行的。
$BC$，在$OSI$参考模型中，物理层实现比特流在传输介质上的透明传输；数据链路层将有差错的物理线路变成无差错的数据链路，实现相邻结点之间即点到点的数据传输。网络层的主要功能是路由选择、拥塞控制和网际互联等，实现主机到主机的通信；传输层实现主机的进程之间即端到端的数据传输。
$D$，下一层为上一层提供服务，而网络层下一层是数据链路层，所以为网络层实体提供数据发送和接收功能及过程的是数据链路层。
**例题** 在$OSI$参考模型中，(①)利用通信子网提供的服务实现两个用户进程之间端到端的通信。在这个层次模型中，如果用户$A$需要通过网络向用户B传送数据，那么酋先将数据送入应用层，在该层给它附加控制信息后送入表示层；在表示层对数据进行必要的变换并加上头部后送入会话层；在会话层加头部后送入传输层；在传输层将数据分割为(②)后送至网络层；在网络层将数据封装成(③)后送至数据链路层；在数据链路层将数据加上头部和尾部封装成(④)后发送到物理层；在物理层数据以(⑤)形式发送到物理线路。用户$B$所在的系统接收到数据后，层层剥去控制信息，最终将原数据传送给用户$B$。
① $A$.网络层 $B$.传输层 $C$.会话层 $D$.表示层
② $A$.数据报 $B$.数据流 $C$.报文 $D$.分组
③ $A$.数据流 $B$.报文 $C$.路由信息 $D$.分组
④ $A$.数据段 $B$.报文 $C$.数据帧 $D$.分组
⑤ $A$.比特流 $B$.数据帧 $c$.报文 $D$.分组
解：①$B$、②$C$、③$D$、④$C$、⑤$A$。在$OSI$参考模型中，在对等层之间传送的数据的单位都称为协议数据单元（$PDU$）；具体而言，在传输层称为报文段（$TCP$）或用户数据报（$UDP$），在网络层称为分组或数据报，在数据链路层称为帧，在物理层称为比特。
================================================
FILE: Computer-Network/0-summary.md
================================================
# 概述
计算机网络是互连（互联互通）、自治（无主从关系）的计算机集合。
## 计算机功能
+ 数据通信。
+ 资源共享（硬件、软件、数据）。
+ 分布式处理。
+ 提高可靠性。
+ 负载均衡。
## 标准化
### 标准的分类
+ 法定标准：由权威机构制定的正式合法的标准，如$OSI$。
+ 事实标准：某些公司产品在竞争中占据主流，其产品的协议与技术就成为了标准，如$TCP/IP$。
### 工作阶段
$RCF$（$Request For Comments$）因特网标准形式。
+ 因特网草案（$Internet\,Draft$）。
+ 建议标准（$Proposed\,Standard$）。
+ ~~草案标准（$Draft\,Standard$）。~~
+ 因特网标准（$Internet\,Standard$）。
### 相关组织
+ 国际标准化组织$ISO$：$OSI$、$HDLC$。
+ 国际电信联盟$ITU$：制定通信规则。
+ 国际电气电子工程师协会$IEEE$：$IEEE802$。
+ 因特网工程任务组$IETF$：因特网标准制定。
## 计算机组成
+ 组成部分：硬件、软件、协议。
+ 工作方式：边缘部分（用户直接使用，包括$C/S$与$P2P$方式）、核心部分（为边缘部分服务）。
+ 功能组成：通信子网（数据通信）、资源子网（资源共享数据处理）。
## 计算机分类
+ 分布范围：广域网$WAM$（交换技术）、城域网$MAN$、局域网$WAN$（广播技术）、个人区域网$PAN$。
+ 使用者：公用网、专用网。
+ 交换技术：电路交换、报文交换、分组交换。
+ 拓扑结构：总线、星型、环型、网状。
+ 传输技术：广播式、点对点式。
### 电路交换
1. 建立连接（电路建立）。
2. 通信。
3. 释放连接（拆除电路）。
链路支持多路复用（可参考数据链路层的$TDM$等）。
优点：
1. 通信时延小，速度快。
2. 有序传输。
3. 无冲突争用。
4. 实时性强。
缺点：
1. 建立连接时间长。
2. 线路独占，使用效率低。
3. 灵活性较差。
4. 不能流量控制。
5. 无差错控制能力。
### 报文交换
报文：源应用发送的信息整体。
1. 源先根据报文加上$IP$地址，物理地址等，通过物理层发送。
2. 交换机收到报文之后，先进行存储，等待链路空闲之后进行转发，但是转发的路径不是固定的，是比较随机的。
3. 最后通过许多交换机最终到达目的地。
优点：
1. 无需建立连接。
2. 存储转发，动态分配线路。
3. 线路可靠性高。
4. 线路利用率较高。
5. 多目标服务。
缺点：
1. 有存储转发时延。
2. 报文大小不定，需要网络结点有较大的缓存空间。
所以报文交换不能应用于实时通讯，如电话，视频。
### 分组交换
将大的数据块分割为小的数据块。分组交换和报文交换基本相同，就是将报文切割之后再进行发送。
优点：
1. 无需建立连接。
2. 存储转发，动态分配线路。
3. 线路可靠性高。
4. 线路利用率较高。
5. 分组大小一定，存储管理更容易。
6. 分组更小，所以传输时延比报文交换的更小。
缺点：
1. 有存储转发时延。
2. 需要传输额外的信息量（编号、目的地址等）。
3. 乱序到达目的主机时，需要对分组进行排序。
![数据交换][dataswap]
1. 报文交换和分组交换都采用存储转发。
2. 传输数据量大且传输时间远大于呼叫时间，就选择电路交换，其传输时延最小。
3. 报文交换分组交换在信道利用率上优于电路交换。
## 分组交换传输方式
数据报和分组的关系：分组是一段比较长的数据，将它进行切割成一段段之后就得到数据报。其都是网络层的传输单位。
分组交换分为数据报方式和虚电路方式两种。
对于出错率高的线路应该使用数据报方式。
### 数据报方式
+ 提供无连接服务，可随时发送和接受。
+ 尽最大可能交付，所以不保证可靠性。
+ 不事先为分组的传输确定传输路径，每个分组独立确定传输路径，不同分组传输路径可能不同，也不一定按序到达。
+ 每个分组携带源和目的地址。
+ 存储转换需要排队等待。当出现拥塞时会丢弃部分分组。
+ 可及时更新转发表，适应性强。
+ 时延小，提高吞吐量。
+ 不单独占用信道，资源利用率高。
+ 路由器根据分组的目的地址转发组：基于路由协议/算法构建转发表（目的网络地址与链路接口的散列对）；检索转发表；每个分组独立选路。
### 虚电路方式
+ 虚电路将数据报方式与电路交换方式结合。
+ 虚电路是一条源主机到目的主机类似电路的逻辑连接，路径上所有结点都要维持该虚电路的建立，都维持一张虚电路表，每一项都记录一个打开的虚电路的信息。
+ 虚电路方式提供连接服务，首先为分组的传输确定传输路径，然后沿该路径/连接传输系列分组，分组的传输路径相同，结束后拆除连接。
+ 一条物理链路可能有多个逻辑电路。
+ 虚拟电路包含临时和永久两种：
+ 永久性虚电路$PVC$：是一种提前定义好的、基本上不需要任何建立时间的端点之间的连接。
+ 交换型虚电路$SVC$：是端点之间的一种临时性连接，这些连接只持续所需的时间，并且在会话结束时就取消这种连接，B错误。
传输过程：
1. 建立虚电路连接：每个分组携带虚电路标识（$VCID$），而非目的地址，源主机发送呼叫请求分组并收到呼叫应答分组后才算建立连接。
2. 数据传输：全双工通信。
3. 释放虚电路连接：源主机发送释放请求分组以拆除虚电路。
优点：
+ 虚电路通信链路建立拆除需要时间，不适合交互式和小量短分组，适合长时间频繁数据交换。
+ 链路建立确定传输路径。
+ 可靠通信，保证有序到达。
+ 提供流量控制。
+ 虚电路某点或某部分破坏，则会影响其他相关电路。
+ 分组首部不包含目的地址，包含虚电路标识符，开销小。
|数据报服务|虚电路服务
:----:|:-------:|:-------:
建立连接|不用|必须
目的地址|每个分组都要有完成的目的地址|仅在建立连接时使用，之后每个分组使用较短的虚电路号
路由选择|每个分组单独进行路由选择与转发|属于同一条虚电路的分组按照同一个路由转发
分组顺序|不保证有序到达|保证有序到达
可靠性|不保证，可靠性依靠用户主机保证|保证
网络故障适应性|强|弱
差错控制和流量控制|用户主机完成|可由网络完成也可以由用户主机完成
## 性能指标
### 速率
数据传输率或比特率。是主机在数字信道上传输数据位数的额定理想速度。
$1Tb/s=10^3Gb/s=10^6Mb/s=10^9kb/s=10^{12}b/s$。
（
存储容量方面，$1Byte=8bit$，因为一个字节占八个比特位，所以一般都是以字节为单位。
$1TB=2^{10}GB=2^{20}MB=2^{30}KB=2^{40}B$。
）
### 带宽
网络中某点到另外一点所能通过的**最高数据率**，单位是b/s等。即网络设备发送的极限最高速率约束。
### 吞吐量
单位时间内通过某网络或信道接口的数据量，单位是$b/s$等。这是网络实际的平均速率。吞吐量受网络带宽的限制。
### 时延
是数据从网络的一端传送到另一端锁需要的时间，单位为$s$。时延=发送（传输）时延+传播时延+排队时延+处理时延。
+ 发送时延：从发送分组的第一个比特开始到最后一个比特发送完毕的时间。发送时延=数据长度\信道带宽（发送速率）。
+ 传播时延：数据在信道上传播的时间。传播时延=信道长度\电磁波传播速率。
+ 排队时延：等待输入与输出链路可用的时间。
+ 处理时延：检错数据与查找转发出口的时间。
### 时延带宽积
时延带宽积=传播时延×带宽，单位为$bit$。表示是以比特为单位的链路长度，即链路当前的数据比特容量。
### 往返时延RTT
从发送方发送数据开始，到发送方收到接收方的确认（假如收到数据立刻返回确认）总共经历的时延。
$RTT$越大，在收到确认前可以发送的数据越多。
$RTT$=往返传播时延+末端处理时延。
### 利用率
+ 信道利用率：有数据通过时间\（有+无）数据通过时间。
+ 网络利用率：信道利用率加权平均值。
利用率越高则时延越长，且加速度不断提高。
## 体系结构
### 分层原因
+ 发起通信的计算机必须将数据通信的通路进行激活。
+ 要告诉网络如何识别目的主机。
+ 发起通信的计算机要查明目的主机是否开机，并且与网络连接正常。
+ 发起通信的计算机要弄清楚，对方计算机中文件管理程序是否已经做好准备工作。
+ 确保差错和意外可以解决。
### 分层结构概念
+ 实体：第$n$层中的活动元素称为$n$层实体。同一层的实体就是对等实体。
+ 协议：为进行网络中的对等实体数据交换而建立的规则、标准或约定。是水平方向的。
+ 语法：传输数据的格式。
+ 语义：所要完成的功能。
+ 同步：各种操作的顺序。
+ 接口（访问服务点$SAP$）：上层使用下层服务的入口。
+ 接口连接的是相邻层次。
+ 服务：下层为相邻上层提供的功能调用。是垂直方向的。
+ 上层使用下层提供的服务。
+ 第$n$层向$n+1$层提供服务时，不仅包括第n层本身的功能，还包括下面所有层次所提供的所有功能。
+ 本层所提供服务细节对上一层完全屏蔽。
+ 服务类型：
+ 面向连接和无连接。
+ 可靠和不可靠。
+ 有应答和无应答。
+ $SDU$服务数据单元：为完成用户所要求的功能而应传输的数据。即要传输的目的数据。
+ $PCI$协议控制信息：控制协议操作的信息。即协议控制头。
+ $PDU$协议数据单元：对等层次之间传送的数据单位。
+ $n+1$层的$PDU$作为第$n$层的$SDU$，在加上本层的$PCI$就变成了本层的$PDU$，然后交给$n-1$层。所以$(u+1)-PDU+n-SDU=u-SDU+n-PCI=n-PDU=(n-1)-SDU$。
+ 物理层的$PDU$为比特，数据链路层的$SDU$为帧，网络层的$SDU$为分组，传输层的$PDU$为报文段。
### OSI参考模型
为一个法定标准，但是没有实现。为$ISO$于$1984$年提出的开放系统互连模型。
|名称|英文名|作用|
| :--------: | :----------------: | :------------: |
|应用层|Application\,Layer|用户与网络的界面；直接为用户的应用进程（例如电子邮件、文件传输和终端仿真）提供服务；HTTP、SMTP、FTP、DNS|
|表示层|Presentation\,Layer|规范交换信息的表示方式；数据格式转换；加密和解密；数据压缩和恢复；JPEG、ASCII |
|会话层|Session\,Layer|负责在数据传输中建立和维护计算机网络中两台计算机之间的通信连接（会话）；使用校验点同步（SYN）或恢复通信；ADSP、ASP |
|传输层|Transport\,Layer| 负责端到端通讯；传输单位为报文段（TCP）或用户数据报（UDP）；可靠传输，不可靠传输 ；差错控制；流量控制；复用分用；TCP、UDP |
|网络层|Network\,Layer| 传输分组，传输单位是数据报或分组；路由选择；流量控制；差错控制；规划IP地址(ipv4和ipv6变化只会影响网络层)；拥塞控制；网际互联；IP、ICP、IGMP、ARP、RARP、OSPF |
|数据链路层|Data\,Link\,Layer|负责点到点通讯；将数据报组装成帧，传输单位为帧；成帧（帧的开始和结束）；透明传输；差错校验(一般丢弃，纠错由传输层解决)；流量控制；访问（接入）控制（控制信道的控制）；SDLC、HDLC、PPP、STP|
|物理层|Physical\,Layer| 简单将数据转变为物理电信号，在物理媒体上实现比特流的透明传输，传输单位为比特；定义接口特性；定义传输模式（单工、半双工、双工）；定义传输速率；比特同步；比特编码；Rj45、802.3 |
端系统一般都是七层，而中间系统如路由器等最多只有三层。上面四层是端到端的通信，而下面三层是点到点的通信。
### TCP/IP参考模型
先有协议栈才有参考模型。
#### OSI与TCP/IP的联系
+ 应用层-应用层+表示层+会话层：$HTTP$、$FTP$、$DNS$。
+ 传输层-传输层：$TCP$、$UDP$。
+ 网际层-网络层：$IP$。
+ 网络接口层-数据链路层+物理层：$Ethernet$、$ATM$、$Frame\,Relay$。
#### 面向连接与无连接
面向连接：
+ 发出请求，建立连接。
+ 传输数据。
+ 释放连接。
无连接直接传输数据。
两个模型之间的连接区别：
| |$OSI$参考模型|$TCP/IP$模型 |
| :----: | :-------------: | :-------------: |
| 传输层 | 面向连接 | 无连接+面向连接 |
| 网络层 | 无连接+面向连接 | 无连接|
### 五层参考模型
应用层、传输层、网络层、数据链路层、物理层。
[dataswap]:data:image/png;base64,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
gitextract_pv185ee9/ ├── .gitignore ├── Code/ │ ├── C-Code/ │ │ ├── C-Code.sln │ │ ├── C-Code.vcxproj │ │ ├── C-Code.vcxproj.filters │ │ ├── C-Code.vcxproj.user │ │ ├── head/ │ │ │ ├── head.h │ │ │ ├── link_list.h │ │ │ └── sequence_list.h │ │ └── source/ │ │ ├── main.c │ │ └── test.c │ ├── CPP-Code/ │ │ ├── CMakeSettings.json │ │ ├── head/ │ │ │ ├── double_link_list.h │ │ │ ├── dynamic_sequence_list.h │ │ │ ├── head.h │ │ │ ├── link_list.h │ │ │ ├── link_list_with_head.h │ │ │ ├── link_list_without_head.h │ │ │ ├── link_queue.h │ │ │ ├── link_stack.h │ │ │ ├── link_string.h │ │ │ ├── list.h │ │ │ ├── sequence_list.h │ │ │ ├── sequence_queue.h │ │ │ ├── sequence_stack.h │ │ │ ├── sequence_string.h │ │ │ ├── share_stack.h │ │ │ ├── static_link_list.h │ │ │ └── static_sequence_list.h │ │ └── source/ │ │ ├── main.cpp │ │ └── test.cpp │ └── Code/ │ ├── CMakeSettings.json │ ├── head/ │ │ ├── double_link_list.h │ │ ├── graph.h │ │ ├── head.h │ │ ├── link_list.h │ │ ├── link_queue.h │ │ ├── link_stack.h │ │ ├── link_string.h │ │ ├── link_tree.h │ │ ├── search.h │ │ ├── sequence_list.h │ │ ├── sequence_queue.h │ │ ├── sequence_stack.h │ │ ├── sequence_string.h │ │ ├── share_stack.h │ │ ├── sort.h │ │ ├── static_link_list.h │ │ ├── thread_tree.h │ │ └── tree.h │ └── source/ │ ├── main.cpp │ └── test.cpp ├── Computer-Network/ │ ├── 0-summary-ex.md │ ├── 0-summary.md │ ├── 1-physical-layer-ex.md │ ├── 1-physical-layer.md │ ├── 2-data-link-layer-ex.md │ ├── 2-data-link-layer.md │ ├── 3-network-layer-ex.md │ ├── 3-network-layer.md │ ├── 4-transport-layer-ex.md │ ├── 4-transport-layer.md │ ├── 5-application-layer-ex.md │ └── 5-application-layer.md ├── Computer-Organization/ │ ├── 0-summary-ex.md │ ├── 0-summary.md │ ├── 1-data-representation-and-operation-ex.md │ ├── 1-data-representation-and-operation.md │ ├── 2-storage-system-ex.md │ ├── 2-storage-system.md │ ├── 3-instruction-system-ex.md │ ├── 3-instruction-system.md │ ├── 4-central-processing-unit-ex.md │ ├── 4-central-processing-unit.md │ ├── 5-bus-ex.md │ ├── 5-bus.md │ ├── 6-input-output-system-ex.md │ ├── 6-input-output-system.md │ └── 7-assembler.md ├── Data-Structrue/ │ ├── 0-summary-ex.md │ ├── 0-summary.md │ ├── 1-linear-list-ex.md │ ├── 1-linear-list.md │ ├── 2-stack-ex.md │ ├── 2-stack.md │ ├── 3-queue-ex.md │ ├── 3-queue.md │ ├── 4-array-ex.md │ ├── 4-array.md │ ├── 5-string-ex.md │ ├── 5-string.md │ ├── 6-tree-ex.md │ ├── 6-tree.md │ ├── 7-graph-ex.md │ ├── 7-graph.md │ ├── 8-search-ex.md │ ├── 8-search.md │ ├── 9-sort-ex.md │ └── 9-sort.md ├── Operate-System/ │ ├── 0-summary-ex.md │ ├── 0-summary.md │ ├── 1-process-management-ex.md │ ├── 1-process-management.md │ ├── 2-memory-management-ex.md │ ├── 2-memory-management.md │ ├── 3-file-management-ex.md │ ├── 3-file-management.md │ ├── 4-device-management-ex.md │ └── 4-device-management.md ├── README.md └── merge（工具程序，不要乱点，用前进去改路径！！）.py
SYMBOL INDEX (287 symbols across 42 files)
FILE: Code/C-Code/head/head.h
type element_type (line 8) | typedef char element_type;
FILE: Code/C-Code/head/link_list.h
type LinkListNode (line 6) | typedef struct LinkListNode {
function InitLinkListWithHead (line 13) | int InitLinkListWithHead(LinkList list) {
function InitLinkListWithoutHead (line 27) | int InitLinkListWithoutHead(LinkList list) {
function LinkList (line 33) | LinkList CreateLinkListWithHead() {
function LinkList (line 46) | LinkList CreateLinkListWithoutHead() {
function EmptyLinkListWithHead (line 52) | int EmptyLinkListWithHead(LinkList list) {
function EmptyLLinkListWithoutHead (line 62) | int EmptyLLinkListWithoutHead(LinkList list) {
function InsertLinkListWithHead (line 73) | int InsertLinkListWithHead(LinkList list, int index, element_type elem) {
function InsertLinkListWithoutHead (line 112) | int InsertLinkListWithoutHead(LinkList list, int index, element_type ele...
FILE: Code/C-Code/head/sequence_list.h
type StaticSequenceList (line 9) | typedef struct {
type DynamicSequenceList (line 16) | typedef struct {
function InitStaticSequenceList (line 26) | int InitStaticSequenceList(StaticSequenceList* list) {
function InitDynamicSequenceList (line 39) | int InitDynamicSequenceList(DynamicSequenceList* list) {
function PrintfStaticSequenceList (line 63) | int PrintfStaticSequenceList(StaticSequenceList list) {
function PrintfDynamicSequenceList (line 71) | int PrintfDynamicSequenceList(DynamicSequenceList list) {
function OtherIncreaseDynamicSequenceList (line 79) | int OtherIncreaseDynamicSequenceList(DynamicSequenceList* list, int len) {
function ReIncreaseDynamicSequenceList (line 105) | int ReIncreaseDynamicSequenceList(DynamicSequenceList* list, int len) {
function InsertStaticSequenceList (line 127) | int InsertStaticSequenceList(StaticSequenceList* list, int index, elemen...
function InsertDynamicSequenceList (line 148) | int InsertDynamicSequenceList(DynamicSequenceList* list, int index, elem...
function LoopInsertStaticSequenceList (line 171) | int LoopInsertStaticSequenceList(StaticSequenceList* list, element_type*...
function LoopInsertDynamicSequenceList (line 183) | int LoopInsertDynamicSequenceList(DynamicSequenceList* list, element_typ...
function DeleteStaticSequenceList (line 195) | int DeleteStaticSequenceList(StaticSequenceList* list, int index, elemen...
function DeleteDynamicSequenceList (line 209) | int DeleteDynamicSequenceList(DynamicSequenceList* list, int index, elem...
function MultiDeleteStaticSequenceList (line 223) | int MultiDeleteStaticSequenceList(StaticSequenceList* list, int index, i...
function MultiDeleteDynamicSequenceList (line 239) | int MultiDeleteDynamicSequenceList(DynamicSequenceList* list, int index,...
function element_type (line 255) | element_type GetStaticSequenceListElement(StaticSequenceList list, int i...
function element_type (line 264) | element_type GetDynamicSequenceListElement(DynamicSequenceList list, int...
function LocateStaticSequenceListElement (line 273) | int LocateStaticSequenceListElement(StaticSequenceList list, element_typ...
function LocateDynamicSequenceListElement (line 284) | int LocateDynamicSequenceListElement(DynamicSequenceList list, element_t...
function EmptyStaticSequenceList (line 295) | int EmptyStaticSequenceList(StaticSequenceList list) {
function EmptyDynamicSequenceList (line 305) | int EmptyDynamicSequenceList(DynamicSequenceList list) {
function DestroyDynamicSequenceList (line 315) | int DestroyDynamicSequenceList(DynamicSequenceList* list) {
FILE: Code/C-Code/source/main.c
function main (line 5) | int main()
FILE: Code/C-Code/source/test.c
function SequenceListTest (line 6) | int SequenceListTest() {
function LinkListTest (line 33) | int LinkListTest() {
FILE: Code/CPP-Code/head/double_link_list.h
function class (line 4) | class DoubleLinkListNode {
function SetNext (line 60) | bool DoubleLinkListNode::SetNext(DoubleLinkListNode *next) {
function Destory (line 93) | bool DoubleLinkListNode::Destory() {
FILE: Code/CPP-Code/head/dynamic_sequence_list.h
function class (line 4) | class DynamicSequenceList : public SequenceList {
function OtherIncrease (line 29) | bool DynamicSequenceList::OtherIncrease(int length) {
function ReIncrease (line 49) | bool DynamicSequenceList::ReIncrease(int length) {
function Insert (line 70) | bool DynamicSequenceList::Insert(int index, element_type elem) {
FILE: Code/CPP-Code/head/head.h
type element_type (line 8) | typedef char element_type;
FILE: Code/CPP-Code/head/link_list.h
function class (line 10) | class LinkListNode {
function Destory (line 73) | bool LinkListNode::Destory() {
function class (line 82) | class LinkList {
function SetLength (line 155) | bool LinkList::SetLength() {
function SetLength (line 160) | bool LinkList::SetLength(int length) {
function SetType (line 169) | bool LinkList::SetType(bool type) {
function element_type (line 183) | element_type LinkList::GetElem(int index) {
function Locate (line 196) | int LinkList::Locate(element_type elem) {
function PriorInsert (line 212) | bool LinkList::PriorInsert(element_type *elem, int start, int length) {
function NextInsert (line 236) | bool LinkList::NextInsert(element_type *elem, int start, int length) {
function element_type (line 260) | element_type LinkList::Delete(int index) {
function Destroy (line 264) | bool LinkList::Destroy() {
FILE: Code/CPP-Code/head/link_list_with_head.h
function class (line 3) | class LinkListWithHead : public LinkList
FILE: Code/CPP-Code/head/link_list_without_head.h
function class (line 3) | class LinkListWithoutHead : public LinkList
FILE: Code/CPP-Code/head/link_queue.h
function class (line 5) | class LinkQueueNode {
function SetData (line 41) | bool LinkQueueNode::SetData(element_type elem) {
function SetNext (line 50) | bool LinkQueueNode::SetNext(LinkQueueNode *next) {
function class (line 60) | class LinkQueue {
function SetRear (line 110) | bool LinkQueue::SetRear(LinkQueueNode *rear) {
function SetLength (line 119) | bool LinkQueue::SetLength() {
function SetLength (line 124) | bool LinkQueue::SetLength(int length) {
function Enter (line 144) | bool LinkQueue::Enter(element_type elem) {
function element_type (line 154) | element_type LinkQueue::Depart() {
FILE: Code/CPP-Code/head/link_stack.h
function class (line 6) | class LinkStackNode {
function Destroy (line 71) | bool LinkStackNode::Destroy() {
FILE: Code/CPP-Code/head/link_string.h
function class (line 4) | class LinkStringNode {
function SetData (line 46) | bool LinkStringNode::SetData() {
function SetData (line 51) | bool LinkStringNode::SetData(int data_size) {
function SetData (line 56) | bool LinkStringNode::SetData(char *character) {
function SetData (line 61) | bool LinkStringNode::SetData(int index, char character) {
function GetData (line 70) | char LinkStringNode::GetData(int index) {
function SetNext (line 74) | bool LinkStringNode::SetNext() {
function SetNext (line 79) | bool LinkStringNode::SetNext(LinkStringNode *next) {
function class (line 123) | class LinkString {
function SetRear (line 183) | bool LinkString::SetRear() {
function SetRear (line 188) | bool LinkString::SetRear(LinkStringNode *rear) {
function SetDataSize (line 197) | bool LinkString::SetDataSize() {
function SetDataSize (line 202) | bool LinkString::SetDataSize(int data_size) {
function SetLength (line 211) | bool LinkString::SetLength() {
function SetLength (line 216) | bool LinkString::SetLength(int length) {
FILE: Code/CPP-Code/head/sequence_list.h
function class (line 13) | class SequenceList {
function LoopInsert (line 169) | bool SequenceList::LoopInsert(element_type *elem, int index, int length) {
function element_type (line 181) | element_type SequenceList::Delete(int index) {
function element_type (line 211) | element_type SequenceList::GetElem(int index) const {
function Locate (line 221) | int SequenceList::Locate(element_type elem) const {
FILE: Code/CPP-Code/head/sequence_queue.h
function class (line 4) | class SequenceQueue {
function _max_size (line 11) | int _max_size{}
function GetFront (line 34) | int GetFront() const;
function SetData (line 91) | bool SequenceQueue::SetData(int max_size) {
function SetData (line 96) | bool SequenceQueue::SetData(element_type *elem) {
function SetData (line 101) | bool SequenceQueue::SetData(int index, element_type elem) {
function element_type (line 110) | element_type SequenceQueue::GetData(int index) {
function SetFront (line 114) | bool SequenceQueue::SetFront() {
function SetFront (line 119) | bool SequenceQueue::SetFront(int front) {
function SetRear (line 128) | bool SequenceQueue::SetRear() {
function SetRear (line 133) | bool SequenceQueue::SetRear(int rear) {
function SetMaxSize (line 142) | bool SequenceQueue::SetMaxSize() {
function SetMaxSize (line 147) | bool SequenceQueue::SetMaxSize(int max_size) {
function GetMaxSize (line 178) | bool SequenceQueue::FullCircular() const {
function EnterCircular (line 192) | bool SequenceQueue::EnterCircular(element_type elem) {
function element_type (line 202) | element_type SequenceQueue::Depart() {
function element_type (line 212) | element_type SequenceQueue::DepartCircular() {
function element_type (line 226) | element_type SequenceQueue::Head() {
FILE: Code/CPP-Code/head/sequence_stack.h
function class (line 6) | class SequenceStack {
FILE: Code/CPP-Code/head/sequence_string.h
function class (line 4) | class SequenceString {
FILE: Code/CPP-Code/head/share_stack.h
function class (line 4) | class ShareStack{
function _max_size (line 11) | int _max_size{}
function GetTopLeft (line 34) | int GetTopLeft() const;
function SetData (line 97) | bool ShareStack::SetData(element_type *data) {
function SetData (line 102) | bool ShareStack::SetData(int max_size) {
function SetData (line 107) | bool ShareStack::SetData(int index, element_type elem) {
function element_type (line 116) | element_type ShareStack::GetData(int index) {
function SetTopLeft (line 120) | bool ShareStack::SetTopLeft() {
function SetTopRight (line 125) | bool ShareStack::SetTopRight() {
function SetTopLeft (line 130) | bool ShareStack::SetTopLeft(int top) {
function SetTopRight (line 135) | bool ShareStack::SetTopRight(int top) {
function SetMaxSize (line 148) | bool ShareStack::SetMaxSize() {
function SetMaxSize (line 153) | bool ShareStack::SetMaxSize(int max_size) {
function PushLeft (line 196) | bool ShareStack::PushLeft(element_type elem) {
function PushRight (line 207) | bool ShareStack::PushRight(element_type elem) {
function element_type (line 217) | element_type ShareStack::PopLeft() {
function element_type (line 228) | element_type ShareStack::PopRight() {
function element_type (line 239) | element_type ShareStack::TopLeft() {
function element_type (line 248) | element_type ShareStack::TopRight() {
FILE: Code/CPP-Code/head/static_link_list.h
function _next (line 8) | int _next{}
function element_type (line 13) | element_type GetData() const;
function SetNext (line 39) | bool StaticLinkListNode::SetNext(int index) {
function Destroy (line 63) | bool StaticLinkListNode::Destroy() {
function _length (line 74) | int _length{}
function _max_size (line 76) | int _max_size{}
function GetFirst (line 85) | int GetFirst() const;
function SetLength (line 117) | bool StaticLinkList::SetLength() {
function SetLength (line 122) | bool StaticLinkList::SetLength(int length) {
function SetMaxSize (line 131) | bool StaticLinkList::SetMaxSize(int max_size) {
FILE: Code/CPP-Code/head/static_sequence_list.h
function class (line 4) | class StaticSequenceList : public SequenceList {
function Insert (line 23) | bool StaticSequenceList::Insert(int index, element_type elem) {
FILE: Code/CPP-Code/source/main.cpp
function main (line 4) | int main()
FILE: Code/CPP-Code/source/test.cpp
function SequenceListTest (line 12) | bool SequenceListTest() {
function LinkListTest (line 28) | bool LinkListTest() {
function StaticLinkListTest (line 54) | bool StaticLinkListTest(){
FILE: Code/Code/head/double_link_list.h
type DoubleLinkListNode (line 4) | typedef struct DoubleLinkListNode{
function DoubleLinkList (line 12) | DoubleLinkList InitDoubleLinkList(){
function DestroyDoubleLinkList (line 21) | bool DestroyDoubleLinkList(DoubleLinkList &list){
FILE: Code/Code/head/graph.h
type AdjacentArrayGraph (line 4) | typedef struct {
type EdgeNode (line 17) | typedef struct EdgeNode{
type VexNode (line 27) | typedef struct VexNode{
type AdjacentListGraph (line 35) | typedef struct {
FILE: Code/Code/head/head.h
type element_type (line 12) | typedef char element_type;
type weight_type (line 14) | typedef int weight_type;
type elem_type (line 16) | typedef int elem_type;
FILE: Code/Code/head/link_list.h
type LinkListNode (line 4) | typedef struct LinkListNode {
function InitLinkList (line 10) | bool InitLinkList(LinkList &list) {
function LinkList (line 16) | LinkList InitLinkList() {
function EmptyLinkList (line 24) | bool EmptyLinkList(LinkList list) {
function TypeLinkList (line 29) | bool TypeLinkList(LinkList list) {
function PrintLinkList (line 43) | bool PrintLinkList(LinkList list) {
function InsertLinkListWithHead (line 60) | bool InsertLinkListWithHead(LinkList &list, int index, element_type elem) {
function InsertLinkListWithoutHead (line 96) | bool InsertLinkListWithoutHead(LinkList &list, int index, element_type e...
function NextInsertLinkList (line 140) | bool NextInsertLinkList(LinkList &list, element_type *elem, int start, i...
function PriorInsertLinkList (line 162) | bool PriorInsertLinkList(LinkList &list, element_type *elem, int start, ...
function GetLengthLinkList (line 289) | int GetLengthLinkList(LinkList list) {
function element_type (line 300) | element_type GetLinkListElem(LinkList list, int index) {
function LocateLinkList (line 313) | int LocateLinkList(LinkList list, element_type elem) {
function DestroyLinkList (line 325) | bool DestroyLinkList(LinkList &list) {
FILE: Code/Code/head/link_queue.h
type LinkQueueNode (line 4) | typedef struct LinkQueueNode {
type LinkQueue (line 12) | typedef struct {
function InitLinkQueue (line 18) | bool InitLinkQueue(LinkQueue &queue){
function LinkQueue (line 27) | LinkQueue InitLinkQueue(){
function EmptyLinkQueue (line 37) | bool EmptyLinkQueue(LinkQueue queue){
function EnterLinkQueue (line 42) | bool EnterLinkQueue(LinkQueue &queue, element_type elem){
function element_type (line 55) | element_type DepartLinkQueue(LinkQueue &queue){
FILE: Code/Code/head/link_stack.h
type LinkStackNode (line 4) | struct LinkStackNode{
function LinkStack (line 12) | LinkStack InitLinkStack(){
function InitLinkStack (line 19) | bool InitLinkStack(LinkStack &stack){
function EmptyLinkStack (line 26) | bool EmptyLinkStack(LinkStack stack){
FILE: Code/Code/head/link_string.h
type LinkStringNode (line 4) | typedef struct LinkStringNode {
function InitLinkString (line 11) | bool InitLinkString(LinkString &string) {
function LinkString (line 17) | LinkString InitLinkString() {
FILE: Code/Code/head/link_tree.h
function CompareElem (line 6) | int CompareElem(element_type elem1, element_type elem2){
type BinaryTreeNode (line 11) | typedef struct BinaryTreeNode {
function PreOrderBinaryTree (line 17) | bool PreOrderBinaryTree(BinaryTree &tree, bool( *function)(BinaryTree &)) {
function InOrderBinaryTree (line 28) | bool InOrderBinaryTree(BinaryTree &tree, bool(*function)(BinaryTree &)) {
function PostOrderBinaryTree (line 39) | bool PostOrderBinaryTree(BinaryTree &tree, bool(*function)(BinaryTree &)) {
function PreOrderNonRecursiveBinaryTree (line 50) | bool PreOrderNonRecursiveBinaryTree(BinaryTree &tree, bool(*function)(Bi...
function InOrderNonRecursiveBinaryTree (line 84) | bool InOrderNonRecursiveBinaryTree(BinaryTree &tree, bool(*function)(Bin...
function LevelOrderBinaryTree (line 118) | bool LevelOrderBinaryTree(BinaryTree &tree, bool(*function)(BinaryTree &...
function BinaryTreeNode (line 147) | BinaryTreeNode *SearchBinarySortTree(BinaryTree tree, element_type elem) {
function InsertBinarySortTree (line 161) | bool InsertBinarySortTree(BinaryTree &tree, element_type elem) {
function CreateBinarySortTree (line 185) | bool CreateBinarySortTree(BinaryTree &tree, element_type* elem, int star...
FILE: Code/Code/head/search.h
type LinearTable (line 4) | typedef struct {
function SequenceSearch (line 10) | int SequenceSearch(LinearTable table, elem_type key) {
function BinarySearch (line 19) | int BinarySearch(LinearTable table, elem_type key) {
FILE: Code/Code/head/sequence_list.h
type StaticSequenceList (line 4) | typedef struct {
type DynamicSequenceList (line 10) | typedef struct {
function InitSequenceList (line 16) | bool InitSequenceList(StaticSequenceList &list) {
function InitSequenceList (line 22) | bool InitSequenceList(StaticSequenceList &list, int max_size) {
function StaticSequenceList (line 28) | StaticSequenceList InitStaticSequenceList() {
function StaticSequenceList (line 35) | StaticSequenceList InitStaticSequenceList(int max_size) {
function InitSequenceList (line 42) | bool InitSequenceList(DynamicSequenceList &list) {
function InitSequenceList (line 49) | bool InitSequenceList(DynamicSequenceList &list, int max_size) {
function DynamicSequenceList (line 56) | DynamicSequenceList InitDynamicSequenceList() {
function DynamicSequenceList (line 64) | DynamicSequenceList InitDynamicSequenceList(int max_size) {
function IncreaseSequenceList (line 82) | bool IncreaseSequenceList(DynamicSequenceList &list, int length) {
function InsertSequenceList (line 104) | bool InsertSequenceList(StaticSequenceList &list, int index, element_typ...
function InsertSequenceList (line 124) | bool InsertSequenceList(DynamicSequenceList &list, int index, element_ty...
function DestroyDynamicSequenceList (line 215) | int DestroyDynamicSequenceList(DynamicSequenceList &list) {
FILE: Code/Code/head/sequence_queue.h
type SequenceQueue (line 4) | typedef struct {
function InitSequenceQueue (line 14) | bool InitSequenceQueue(SequenceQueue &queue) {
function InitSequenceQueue (line 22) | bool InitSequenceQueue(SequenceQueue &queue, int max_size) {
function SequenceQueue (line 30) | SequenceQueue InitSequenceQueue() {
function SequenceQueue (line 39) | SequenceQueue InitSequenceQueue(int max_size) {
function EmptySequenceQueue (line 49) | bool EmptySequenceQueue(SequenceQueue queue) {
function FullSequenceQueue (line 54) | bool FullSequenceQueue(SequenceQueue queue) {
function FullCircularSequenceQueue (line 59) | bool FullCircularSequenceQueue(SequenceQueue queue) {
function EnterSequenceQueue (line 64) | bool EnterSequenceQueue(SequenceQueue &queue, element_type elem) {
function EnterCircularSequenceQueue (line 75) | bool EnterCircularSequenceQueue(SequenceQueue &queue, element_type elem) {
function element_type (line 87) | element_type DepartSequenceQueue(SequenceQueue &queue) {
function element_type (line 97) | element_type DepartCircularDepartSequence(SequenceQueue &queue) {
function LengthSequenceQueue (line 109) | int LengthSequenceQueue(SequenceQueue queue) {
function element_type (line 114) | element_type HeadSequenceQueue(SequenceQueue &queue) {
FILE: Code/Code/head/sequence_stack.h
type SequenceStack (line 4) | typedef struct SequenceStack {
function InitSequenceStack (line 14) | bool InitSequenceStack(SequenceStack &stack) {
function InitSequenceStack (line 21) | bool InitSequenceStack(SequenceStack &stack, int max_size) {
function SequenceStack (line 28) | SequenceStack InitSequenceStack(){
function SequenceStack (line 36) | SequenceStack InitSequenceStack(int max_size){
function EmptySequenceStack (line 45) | bool EmptySequenceStack(SequenceStack stack) {
function FullSequenceStack (line 50) | bool FullSequenceStack(SequenceStack stack) {
function LengthSequenceStack (line 55) | int LengthSequenceStack(SequenceStack stack) {
function PushSequenceStack (line 60) | bool PushSequenceStack(SequenceStack &stack, element_type elem){
function element_type (line 71) | element_type PopSequenceStack(SequenceStack &stack){
function element_type (line 81) | element_type TopSequenceStack(SequenceStack stack){
FILE: Code/Code/head/sequence_string.h
type SequenceString (line 4) | typedef struct {
function InitSequenceString (line 13) | bool InitSequenceString(SequenceString &string) {
function InitSequenceString (line 20) | bool InitSequenceString(SequenceString &string, int max_size) {
function SequenceString (line 27) | SequenceString InitSequenceString() {
function SequenceString (line 35) | SequenceString InitSequenceString(int max_size) {
function LocateSimple (line 44) | int LocateSimple(SequenceString string, SequenceString pattern) {
function LocateKMP (line 101) | int LocateKMP(SequenceString string, SequenceString pattern, const int *...
function LocateKMP (line 121) | int LocateKMP(SequenceString string, SequenceString pattern) {
function DestroySequenceString (line 142) | bool DestroySequenceString(SequenceString &string) {
FILE: Code/Code/head/share_stack.h
type ShareStack (line 3) | typedef struct {
function InitShareStack (line 13) | bool InitShareStack(ShareStack &stack) {
function InitShareStack (line 21) | bool InitShareStack(ShareStack &stack, int max_size) {
function ShareStack (line 29) | ShareStack InitShareStack() {
function ShareStack (line 38) | ShareStack InitShareStack(int max_size) {
function EmptyLeftShareStack (line 48) | bool EmptyLeftShareStack(ShareStack stack){
function EmptyRightShareStack (line 53) | bool EmptyRightShareStack(ShareStack stack){
function FullShareStack (line 58) | bool FullShareStack(ShareStack stack){
function LengthLeftShareStack (line 63) | int LengthLeftShareStack(ShareStack stack){
function LengthRightShareStack (line 68) | int LengthRightShareStack(ShareStack stack){
function PushLeftShareStack (line 73) | bool PushLeftShareStack(ShareStack &stack, element_type elem){
function PushRightShareStack (line 83) | bool PushRightShareStack(ShareStack &stack, element_type elem){
function element_type (line 93) | element_type PopLeftShareStack(ShareStack &stack){
function element_type (line 104) | element_type PopRightShareStack(ShareStack &stack){
function element_type (line 115) | element_type TopLeftShareStack(ShareStack stack){
function element_type (line 124) | element_type TopRightShareStack(ShareStack stack){
FILE: Code/Code/head/sort.h
function StraightInsertSort (line 4) | bool StraightInsertSort(LinearTable table) {
function BinaryInsertSort (line 24) | bool BinaryInsertSort(LinearTable table) {
function ShellSort (line 54) | bool ShellSort(LinearTable table) {
function BubbleSort (line 70) | bool BubbleSort(LinearTable table) {
function PartQuickSort (line 88) | int PartQuickSort(LinearTable table, int low, int high) {
function QuickSort (line 109) | bool QuickSort(LinearTable table, int low, int high) {
function SimpleSelectSort (line 122) | bool SimpleSelectSort(LinearTable table) {
function BuildHeap (line 144) | bool BuildHeap(LinearTable table, bool HeadAdjust(LinearTable table, int...
function HeadMaxAdjust (line 155) | bool HeadMaxAdjust(LinearTable table, int index) {
function HeapSort (line 180) | bool HeapSort(LinearTable table, bool mode){
FILE: Code/Code/head/thread_tree.h
type ThreadBinaryTreeNode (line 4) | typedef struct ThreadBinaryTreeNode {
function InOrderThreadBinaryTree (line 14) | bool InOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree &p...
function CreateInOrderThreadBinaryTree (line 39) | bool CreateInOrderThreadBinaryTree(ThreadBinaryTree tree) {
function ThreadBinaryTreeNode (line 52) | ThreadBinaryTreeNode *FirstInOrderBinaryTreeNode(ThreadBinaryTreeNode *n...
function ThreadBinaryTreeNode (line 62) | ThreadBinaryTreeNode *NextInOrderBinaryTreeNode(ThreadBinaryTreeNode *no...
function InOrderThreadBinaryTree (line 73) | bool InOrderThreadBinaryTree(ThreadBinaryTree *tree,bool( *function)(Thr...
function PreOrderThreadBinaryTree (line 82) | bool PreOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree &...
function CreatePreOrderThreadBinaryTree (line 110) | bool CreatePreOrderThreadBinaryTree(ThreadBinaryTree tree) {
function PostOrderThreadBinaryTree (line 123) | bool PostOrderThreadBinaryTree(ThreadBinaryTree &tree, ThreadBinaryTree ...
function CreatePostOrderThreadBinaryTree (line 148) | bool CreatePostOrderThreadBinaryTree(ThreadBinaryTree tree) {
FILE: Code/Code/head/tree.h
type ParentTreeNode (line 5) | typedef struct {
type ParentTree (line 11) | typedef struct {
type ChildSiblingTreeNode (line 22) | typedef struct ChildSiblingTreeNode {
FILE: Code/Code/source/main.cpp
function main (line 3) | int main()
FILE: Code/Code/source/test.cpp
function SequenceListTest (line 23) | bool SequenceListTest() {
function LinkListTest (line 41) | bool LinkListTest() {
function SortTest (line 62) | bool SortTest(){
Copy disabled (too large)
Download .json
Condensed preview — 110 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (17,748K chars).
[
{
"path": ".gitignore",
"chars": 165,
"preview": "*.pdf\n*.doc\n*.docx\n*.png\n*.jpg\n*.jpeg\n*.html\n*.htm\n*.vs/\n*.vscode/\n*.txt\n*.idea/\n*Debug/\n*x64/\n*out/\n*build.mingw/\n*buil"
},
{
"path": "Code/C-Code/C-Code.sln",
"chars": 1399,
"preview": "\nMicrosoft Visual Studio Solution File, Format Version 12.00\n# Visual Studio Version 16\nVisualStudioVersion = 16.0.3160"
},
{
"path": "Code/C-Code/C-Code.vcxproj",
"chars": 7252,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project DefaultTargets=\"Build\" xmlns=\"http://schemas.microsoft.com/developer/msb"
},
{
"path": "Code/C-Code/C-Code.vcxproj.filters",
"chars": 1295,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuil"
},
{
"path": "Code/C-Code/C-Code.vcxproj.user",
"chars": 163,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<Project ToolsVersion=\"Current\" xmlns=\"http://schemas.microsoft.com/developer/ms"
},
{
"path": "Code/C-Code/head/head.h",
"chars": 114,
"preview": "// ʼ\n#define MAXSIZE 5\n// Ĭֵ\n#define DEFAULTELEM '0'\n// ֵ\n#define INFINITY 32767\n// Ĭ\ntypedef char element_type;\n"
},
{
"path": "Code/C-Code/head/link_list.h",
"chars": 1754,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include \"head.h\"\n\n// \ntypedef struct LinkListNode {\n\telement_type data;\n\tstruct "
},
{
"path": "Code/C-Code/head/sequence_list.h",
"chars": 8384,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include \"head.h\"\n\n#pragma warning(disable:6385)\n#pragma warning(disable:6386)\n\n"
},
{
"path": "Code/C-Code/source/main.c",
"chars": 116,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n\n\nint main()\n{\n //SequenceListTest();\n LinkListTest();\n return 0;\n}"
},
{
"path": "Code/C-Code/source/test.c",
"chars": 1349,
"preview": "// ļ\n\n#include \"../Head/sequence_list.h\"\n#include \"../Head/link_list.h\"\n\nint SequenceListTest() {\n DynamicSequenceLis"
},
{
"path": "Code/CPP-Code/CMakeSettings.json",
"chars": 299,
"preview": "{\n \"configurations\": [\n {\n \"name\": \"x64-Debug\",\n \"generator\": \"Ninja\",\n \"configurationType\": \"Debug\""
},
{
"path": "Code/CPP-Code/head/double_link_list.h",
"chars": 2163,
"preview": "#include \"head.h\"\n\n// 单链表结点\nclass DoubleLinkListNode {\nprivate:\n // 数据\n element_type _data{};\n // 指针\n Double"
},
{
"path": "Code/CPP-Code/head/dynamic_sequence_list.h",
"chars": 2459,
"preview": "#include \"sequence_list.h\"\n\n// 动态顺序表\nclass DynamicSequenceList : public SequenceList {\npublic:\n // 构造函数\n DynamicSe"
},
{
"path": "Code/CPP-Code/head/head.h",
"chars": 135,
"preview": "// 初始化最大长度\n#define MAXSIZE 5\n// 定义默认值\n#define DEFAULTELEM '\\0'\n// 定义最大值\n//#define INFINITY 32767\n// 定义默认数据类型\ntypedef cha"
},
{
"path": "Code/CPP-Code/head/link_list.h",
"chars": 5987,
"preview": "#ifndef _LINK_LIST_\n#define _LINK_LIST_\n\n#include <iostream>\n#include \"head.h\"\n\nusing namespace std;\n\n// 单链表结点\nclass Lin"
},
{
"path": "Code/CPP-Code/head/link_list_with_head.h",
"chars": 5540,
"preview": "#include \"link_list.h\"\n\nclass LinkListWithHead : public LinkList\n{\npublic:\n // 构造函数\n LinkListWithHead();\n\n // 获"
},
{
"path": "Code/CPP-Code/head/link_list_without_head.h",
"chars": 7019,
"preview": "#include \"link_list.h\"\n\nclass LinkListWithoutHead : public LinkList\n{\nprivate:\n // 数据\n element_type _data{};\n\npubl"
},
{
"path": "Code/CPP-Code/head/link_queue.h",
"chars": 2928,
"preview": "#include <iostream>\n#include \"head.h\"\n\n// 链队结点\nclass LinkQueueNode {\nprivate:\n // 数据\n element_type _data;\n // 指"
},
{
"path": "Code/CPP-Code/head/link_stack.h",
"chars": 1326,
"preview": "#include \"head.h\"\n\nusing namespace std;\n\n// 链栈\nclass LinkStackNode {\nprivate:\n // 数据\n element_type _data{};\n //"
},
{
"path": "Code/CPP-Code/head/link_string.h",
"chars": 4308,
"preview": "#include \"head.h\"\n\n// 块链串结点\nclass LinkStringNode {\nprivate:\n // 数据\n char *_data{};\n // 指针\n LinkStringNode *_"
},
{
"path": "Code/CPP-Code/head/list.h",
"chars": 197,
"preview": "#include \"static_sequence_list.h\"\n#include \"dynamic_sequence_list.h\"\n#include \"link_list_with_head.h\"\n#include \"link_lis"
},
{
"path": "Code/CPP-Code/head/sequence_list.h",
"chars": 6091,
"preview": "#ifndef _SEQUENCE_LIST_\n#define _SEQUENCE_LIST_\n// 避免重复编译\n#include <iostream>\n#include \"head.h\"\n\n//#pragma warning(disab"
},
{
"path": "Code/CPP-Code/head/sequence_queue.h",
"chars": 4479,
"preview": "#include \"head.h\"\n\n// 顺序队列\nclass SequenceQueue {\nprivate:\n // 数据\n element_type *_data{};\n // 队头队尾指针\n int _fr"
},
{
"path": "Code/CPP-Code/head/sequence_stack.h",
"chars": 2468,
"preview": "#include \"head.h\"\n\nusing namespace std;\n\n// 顺序栈\nclass SequenceStack {\nprivate:\n // 栈内元素\n element_type *_data{};\n "
},
{
"path": "Code/CPP-Code/head/sequence_string.h",
"chars": 2667,
"preview": "#include \"head.h\"\n\n// 顺序串\nclass SequenceString {\nprivate:\n // 数据\n char *_data{};\n // 长度\n int _length{};\n "
},
{
"path": "Code/CPP-Code/head/share_stack.h",
"chars": 5082,
"preview": "#include \"head.h\"\n\n// 共享栈\nclass ShareStack{\nprivate:\n // 栈内元素\n element_type *_data{};\n // 栈顶指针，left从-1开始，right从"
},
{
"path": "Code/CPP-Code/head/static_link_list.h",
"chars": 2867,
"preview": "#include \"head.h\"\n\nclass StaticLinkListNode {\nprivate:\n // 数据元素\n element_type _data{};\n // 下一个元素的数组下标\n int _"
},
{
"path": "Code/CPP-Code/head/static_sequence_list.h",
"chars": 1206,
"preview": "#include \"sequence_list.h\"\n\n// 静态顺序表\nclass StaticSequenceList : public SequenceList {\npublic:\n // 构造函数\n StaticSequ"
},
{
"path": "Code/CPP-Code/source/main.cpp",
"chars": 96,
"preview": "#include \"test.cpp\"\n\n\nint main()\n{\n// SequenceListTest();\n LinkListTest();\n return 0;\n}"
},
{
"path": "Code/CPP-Code/source/test.cpp",
"chars": 1476,
"preview": "// 测试文件\n\n#include \"../head/list.h\"\n#include \"../head/sequence_stack.h\"\n#include \"../head/share_stack.h\"\n#include \"../hea"
},
{
"path": "Code/Code/CMakeSettings.json",
"chars": 389,
"preview": "{\n \"configurations\": [\n {\n \"name\": \"x64-Debug\",\n \"generator\": \"Ninja\",\n \"configurationType\": \"Debug\""
},
{
"path": "Code/Code/head/double_link_list.h",
"chars": 601,
"preview": "#include \"head.h\"\n\n// ˫\ntypedef struct DoubleLinkListNode{\n // \n element_type data;\n // ͷβָ\n struct DoubleLi"
},
{
"path": "Code/Code/head/graph.h",
"chars": 587,
"preview": "#include \"head.h\"\n\n// ڽӾͼ\ntypedef struct {\n // \n element_type* vex;\n // ߱\n weight_type *edge;\n // \n in"
},
{
"path": "Code/Code/head/head.h",
"chars": 216,
"preview": "//#pragma once\n\n// ʼ\n#define MAXSIZE 5\n// Ĭֵ\n#define DEFAULTELEM '\\0'\n// Ĭϴֵ\n#define DEFAULTCHAR '\\0'\n// 崮ݳ\n#define DAT"
},
{
"path": "Code/Code/head/link_list.h",
"chars": 7960,
"preview": "#include \"head.h\"\n\n// \ntypedef struct LinkListNode {\n element_type data;\n struct LinkListNode *next;\n} LinkListNod"
},
{
"path": "Code/Code/head/link_queue.h",
"chars": 1423,
"preview": "#include \"head.h\"\n\n// ӽ\ntypedef struct LinkQueueNode {\n // \n element_type data;\n // ָ\n struct LinkQueueNode "
},
{
"path": "Code/Code/head/link_stack.h",
"chars": 501,
"preview": "#include \"head.h\"\n\n// ջ\ntypedef struct LinkStackNode{\n // \n element_type data;\n // ָ\n LinkStackNode *next;\n}"
},
{
"path": "Code/Code/head/link_string.h",
"chars": 514,
"preview": "#include \"head.h\"\n\n// \ntypedef struct LinkStringNode {\n // \n char *data;\n // ָ\n LinkStringNode *next;\n} Link"
},
{
"path": "Code/Code/head/link_tree.h",
"chars": 4794,
"preview": "#include \"head.h\"\n#include <stack>\n#include <queue>\n\n// ȽԪط\nint CompareElem(element_type elem1, element_type elem2){\n "
},
{
"path": "Code/Code/head/search.h",
"chars": 634,
"preview": "#include \"head.h\"\n\n// Ա\ntypedef struct {\n elem_type *data;\n int length;\n} LinearTable;\n\n// ˳\nint SequenceSearch(Li"
},
{
"path": "Code/Code/head/sequence_list.h",
"chars": 5854,
"preview": "#include \"head.h\"\n\n// ̬˳\ntypedef struct {\n element_type *data;\n int length;\n} StaticSequenceList;\n\n// ̬˳\ntypedef s"
},
{
"path": "Code/Code/head/sequence_queue.h",
"chars": 2974,
"preview": "#include \"head.h\"\n\n// ˳\ntypedef struct {\n // \n element_type *data;\n // ͷβ\n int front, rear;\n // \n int "
},
{
"path": "Code/Code/head/sequence_stack.h",
"chars": 2035,
"preview": "#include \"head.h\"\n\n// ˳ջ\ntypedef struct SequenceStack {\n // ջԪ\n element_type *data;\n // ջָ\n int top;\n // "
},
{
"path": "Code/Code/head/sequence_string.h",
"chars": 3486,
"preview": "#include \"head.h\"\n\n// ˳\ntypedef struct {\n // \n char *data;\n // \n int length;\n // \n int max_size;\n} Seq"
},
{
"path": "Code/Code/head/share_stack.h",
"chars": 3090,
"preview": "#include \"head.h\"\n\ntypedef struct {\n // \n element_type *data;\n // ջָ\n int top_left, top_right;\n // \n i"
},
{
"path": "Code/Code/head/sort.h",
"chars": 4754,
"preview": "#include \"head.h\"\n\n// ֱӲ\nbool StraightInsertSort(LinearTable table) {\n // ѭӵڶʼ\n for (int i = 1; i < table.length; "
},
{
"path": "Code/Code/head/static_link_list.h",
"chars": 122,
"preview": "#include \"head.h\"\n\n// ̬\ntypedef struct {\n // Ԫ\n element_type data;\n // ±\n int next;\n} StaticLinkList[MAXSIZE"
},
{
"path": "Code/Code/head/thread_tree.h",
"chars": 3856,
"preview": "#include \"head.h\"\n\n// \ntypedef struct ThreadBinaryTreeNode {\n // \n element_type data;\n // Һӽ\n ThreadBinaryTr"
},
{
"path": "Code/Code/head/tree.h",
"chars": 470,
"preview": "#include \"head.h\"\n\n// ˫ױʾ\n// \ntypedef struct {\n element_type data;\n // ˫λ\n int parent;\n} ParentTreeNode;\n// \nty"
},
{
"path": "Code/Code/source/main.cpp",
"chars": 113,
"preview": "#include \"test.cpp\"\n\nint main()\n{\n //SequenceListTest();\n// LinkListTest();\n SortTest();\n return 0;\n}"
},
{
"path": "Code/Code/source/test.cpp",
"chars": 2106,
"preview": "// \n#include <iostream>\n#include \"../head/sequence_list.h\"\n#include \"../head/link_list.h\"\n#include \"../head/double_link_"
},
{
"path": "Computer-Network/0-summary-ex.md",
"chars": 8338,
"preview": "# 概述习题\n\n## 计算机网络\n\n**例题** 计算机网络可被理解为()。\n\n$A$.执行计算机数据处理的软件模块\n\n$B$.由自治的计算机互联起来的集合体\n\n$C$.多个处理器通过共享内存实现的紧耦合系统\n\n$D$.用于共同完成一项任务"
},
{
"path": "Computer-Network/0-summary.md",
"chars": 309871,
"preview": "# 概述\n\n计算机网络是互连（互联互通）、自治（无主从关系）的计算机集合。\n\n## 计算机功能\n\n+ 数据通信。\n+ 资源共享（硬件、软件、数据）。\n+ 分布式处理。\n+ 提高可靠性。\n+ 负载均衡。\n\n## 标准化\n\n### 标准的分类\n"
},
{
"path": "Computer-Network/1-physical-layer-ex.md",
"chars": 40290,
"preview": "# 物理层习题\n\n## 波特率与比特率\n\n**例题** 测得一个以太网的数据波特率是40MBaud，那么其数据率是()。\n\n$A.10Mb/s$\n\n$B.20Mb/s$\n\n$C.40Mb/s$\n\n$D.80Mb/s$\n\n解：$B$。对于以太"
},
{
"path": "Computer-Network/1-physical-layer.md",
"chars": 450517,
"preview": "# 物理层\n\n## 基本概念\n\n物理层需要考虑如何传输比特流，而不关心到底使用何种媒体传输数据。具体传输数据的层次是第$0$层。\n\n### 通信简述\n\n#### 通信流程\n\n信源->数字信号->调制解调器->模拟型号->广域网->模拟信号-"
},
{
"path": "Computer-Network/2-data-link-layer-ex.md",
"chars": 1145699,
"preview": "# 数据链路层习题\n\n## 数据链路层功能\n\n**例题** 数据链路层协议的功能不包括()。\n\n$A.$定义数据格式\n\n$B.$提供结点之间的可靠传输\n\n$C.$控制对物理传输介质的访问\n\n$D.$为终端结点隐蔽物理传输的细节\n\n解：$D$"
},
{
"path": "Computer-Network/2-data-link-layer.md",
"chars": 2051794,
"preview": "# 数据链路层\n\n## 基本概念\n\n+ 结点：主机、路由器。\n+ 链路：网络中两个结点之间的物理通道。\n+ 数据链路：网络中两个结点之间的逻辑通道。\n+ 帧：链路层的协议数据单元。\n\n### 数据链路层功能\n\n1. 为网络层提供服务：无确认"
},
{
"path": "Computer-Network/3-network-layer-ex.md",
"chars": 831890,
"preview": "# 网络层习题\n\n## 网络层功能\n\n**例题** 在路由器互联的多个局域网的结构中，要求每个局域网()。\n\n$A.$物理层协议可以不同，而数据链路层及其以上的高层协议必须相同\n\n$B.$物理层、数据链路层协议可以不同，而数据链路层以上的高"
},
{
"path": "Computer-Network/3-network-layer.md",
"chars": 1060090,
"preview": "# 网络层\n\n## 基本概念\n\n主要任务是将分组从源端发送到目的端，为分组交换网上的不同主机提供通信服务。在任意结点间进行数据报传输，但不可靠。\n\n<!-- ### 传输单位\n\n1. 应用层的传输单位是报文。\n2. 传输层的传输单位是报文或"
},
{
"path": "Computer-Network/4-transport-layer-ex.md",
"chars": 9012,
"preview": "# 传输层习题\n\n## 基本概念\n\n**例题** 可靠传输协议中的“可靠”指的是()。\n\n$A.$使用面向连接的会话\n\n$B.$使用尽力而为的传输\n\n$C.$使用滑动窗口来维持可靠性\n\n$D.$使用确认机制来确保传输的数据不丢失\n\n解：$D"
},
{
"path": "Computer-Network/4-transport-layer.md",
"chars": 2431770,
"preview": "# 传输层\n\n## 基本概念\n\n传输层只有主机才有，而路由器这种中间设备至多只有物理层、数据链路层和网络层三层架构。\n\n是面向通信的最高层，也是用户功能的最底层。\n\n### 传输层的功能\n\n1. 传输层提供进程与进程之间的逻辑通信。\n2. "
},
{
"path": "Computer-Network/5-application-layer-ex.md",
"chars": 373428,
"preview": "# 应用层习题\n\n## 网络应用模型\n\n### C/S模型\n\n**例题** 下面关于客户/服务器模型的描述，()存在错误。\n\nⅠ.客户端必须提前知道服务器的地址，而服务器则不需要提前知道客户端的地址\n\nⅡ.客户端主要实现如何显示信息与收集用"
},
{
"path": "Computer-Network/5-application-layer.md",
"chars": 1574230,
"preview": "# 应用层\n\n应用层对应用程序的通信提供服务。\n\n传输层功能：\n\n1. 文件传输、访问和管理。\n2. 电子邮件。\n3. 虚拟终端。\n4. 查询服务与远程作业登陆。\n\n## 网络应用模型\n\n### C/S模型\n\n客户/服务器模型中服务器提供计"
},
{
"path": "Computer-Organization/0-summary-ex.md",
"chars": 3541,
"preview": "# 概述习题\n\n## 计算机的发展\n\n**例题** 只有当程序执行时才将源程序翻译成机器语言，并且一次只能翻译一行语句，边翻译边执行的是()程序，把汇编语言源程序转变为机器语言程序的过程是()。\n\nⅠ.编译\n\nⅡ.目标\n\nⅢ.汇编\n\nⅣ.解"
},
{
"path": "Computer-Organization/0-summary.md",
"chars": 9841,
"preview": "# 概述\n\n软件基于数据结构，数据结构又基于计算机，计算机由操作系统运行，计算机的硬件基于计算机组成原理，计算机之间通过计算机网络连接，这就是四个的关系。计算机组成原理是关于计算机硬件的最底层知识。\n\n+ 计算机系统=硬件+软件。\n+ 软件"
},
{
"path": "Computer-Organization/1-data-representation-and-operation-ex.md",
"chars": 1333639,
"preview": "# 数据表示与运算习题\n\n## 数制与编码\n\n### 进位计数制\n\n#### 十进制转换为R进制\n\n**例题** 将十进制的$75.3$转换为二进制并保留三位。\n\n首先将$75$拿出来，以基数$2$相除：\n\n$75\\div2=37\\dots"
},
{
"path": "Computer-Organization/1-data-representation-and-operation.md",
"chars": 28650,
"preview": "# 数据表示与运算\n\n## 数制与编码\n\n### 进位计数制\n\n+ 真值：符合人类习惯的数字。\n+ 机器数：数字实际存到机器里的形式，正负号需要被“数字化”。\n\n#### 十进制\n\n+ 符号反映权重。\n+ 符号所在位置也反映权重。\n+ $K"
},
{
"path": "Computer-Organization/2-storage-system-ex.md",
"chars": 237568,
"preview": "# 存储系统习题\n\n## 存储器概念\n\n### 存储器层次化结构\n\n**例题** 下列关于多级存储系统的说法中，正确的有()。\nⅠ.多级存储系统是为了降低存储成本\nⅡ.虚拟存储器中主存和辅存之间的数据调动对任何程序员是透明的\nⅢ.$CPU$"
},
{
"path": "Computer-Organization/2-storage-system.md",
"chars": 930005,
"preview": "# 存储系统\n\n存储器被划分为若干个存储单元，每个存储单元都从$0$开始顺序编号。比如一个存储器有$128$个存储单元，则它的编号范围是$0\\sim127$。\n\n## 存储器概念\n\n### 存储器的分类\n\n#### 作用\n\n+ 主存储器：主"
},
{
"path": "Computer-Organization/3-instruction-system-ex.md",
"chars": 4280,
"preview": "# 指令系统习题\n\n## 指令格式\n\n### 操作码\n\n**例题** 一个计算机系统采用$32$位单字长指令，地址码为$12$位，若定义了$250$条二地址指令，则还可以有()条单地址指令。\n\n$A.4K$\n\n$B.8K$\n\n$C.16K$"
},
{
"path": "Computer-Organization/3-instruction-system.md",
"chars": 9443,
"preview": "# 指令系统\n\n指令和数据是应用上的概念，同一个数据可以被解释为数据也可以被解释为指令。同一串二进制代码，可以是指令，也可以是数据，这决定于我们的程序设计。如$1000100111011000$被应用为数据时，它等于$89D8H$，$H$表"
},
{
"path": "Computer-Organization/4-central-processing-unit-ex.md",
"chars": 1138915,
"preview": "# 中央处理器习题\n\n## CPU基本概念\n\n**例题** 间址周期结束时，$CPU$内寄存器$MDR$中的内容为()。\n\n$A.$指令\n\n$B.$操作数地址\n\n$C.$操作数\n\n$D.$无法确定\n\n解：$B$。结合指令周期。$MDR$存放"
},
{
"path": "Computer-Organization/4-central-processing-unit.md",
"chars": 19105,
"preview": "# 中央处理器\n\n即$CPU$，为最难的一章。\n\n## CPU基本概念\n\n### CPU功能\n\n#### CPU总功能\n\n1. 指令控制。完成取指令、分析指令和执行指令的操作，即程序的顺序控制。\n2. 操作控制。一条指令的功能往往是由若干操"
},
{
"path": "Computer-Organization/5-bus-ex.md",
"chars": 1658,
"preview": "# 总线习题\n\n## 总线概述\n\n### 总线类型\n\n**例题** 在系统总线的数据线上，不可能传输的是()。\n\n$A.$指令\n\n$B.$操作数\n\n$C.$握手（应答）信号\n\n$D.$中断类型号\n\n解：$C$。不是数据线上传输的就代表不是数"
},
{
"path": "Computer-Organization/5-bus.md",
"chars": 11245,
"preview": "# 总线\n\n## 总线概述\n\n### 总线基本定义\n\n+ 总线是一组能为多个部件分时共享的公共信息传送线路。是总线复用方式。\n+ 共享是指总线上可以挂接多个部件，各个部件之间互相交换的信息都可以通过这组线路分时共享。\n+ 分时是指同一时刻只"
},
{
"path": "Computer-Organization/6-input-output-system-ex.md",
"chars": 9545,
"preview": "# 输入输出系统习题\n\n## 输入输出基本概念\n\n**例题** 在微型机系统中，$I/O$设备通过()与主板的系统总线相连接。\n\n$A.DMA$控制器\n\n$B.$设备控制器\n\n$C.$中断控制器\n\n$D.I/O$端口\n\n解：$B$。$I/O"
},
{
"path": "Computer-Organization/6-input-output-system.md",
"chars": 258237,
"preview": "# 输入输出系统\n\n## 输入输出基本概念\n\n### I/O系统发展\n\n1. 早期，$CPU$和$I/O$串行工作，分散连接：\n + 程序查询方式：由$CPU$通过程序不断查询$I/O$设备是否已做好准备，从而控制$I/O$设备与主机交"
},
{
"path": "Computer-Organization/7-assembler.md",
"chars": 14527,
"preview": "# 汇编程序\n\n## 概念\n\n### 定义\n\n在计算机组成原理中会涉及汇编语言的基本指令，需要对基本命令有基本的掌握。\n\n机器语言是机器指令的集合。这些机器指令本质上就是由一组0和1组成的命令，是CPU唯一能解释执行的命令。\n\n机器语言和高"
},
{
"path": "Data-Structrue/0-summary-ex.md",
"chars": 3467,
"preview": "# 概述习题\n\n## 数据结构\n\n**例题** 以下关于数据结构的说法中，正确的是()。\n\n$A.$数据的逻辑结构独立于其存储结构\n\n$B.$数据的存储结构独立于其逻辑结构\n\n$C.$数据的逻辑结构唯一决定其存储结构\n\n$D.$数据结构仅由"
},
{
"path": "Data-Structrue/0-summary.md",
"chars": 1923,
"preview": "# 概述\n\n## 基本概念\n\n+ 数据项：一个数据元素由若干个数据项组成。\n+ 数据元素：组成数据对象的基本单元。\n+ 数据对象：性质相同的数据元素的集合。\n\n存储数据时要存储数据元素的值，也要存储数据元素之间的关系。\n\n### 数据类型与"
},
{
"path": "Data-Structrue/1-linear-list-ex.md",
"chars": 1143,
"preview": "# 线性表习题\n\n## 基本概念\n\n**例题** 以下()是一个线性表。\n\n$A.$由$n$个实数组成的集合\n\n$B.$由$100$个字符组成的序列\n\n$C.$所有整数组成的序列\n\n$D.$邻接表\n\n解：$B$。线性表定义的要求为：相同数据"
},
{
"path": "Data-Structrue/1-linear-list.md",
"chars": 5193,
"preview": "# 线性表\n\n## 基本概念\n\n### 逻辑结构\n\n是具有相同数据类型的$n$个数据元素的有限序列。$n$表示表长。\n\n$L=(a_1,a_2,\\cdots,a_i,\\cdots,a_n)$，其中$i$表示元素在线性表中的位序，从一开始。\n"
},
{
"path": "Data-Structrue/2-stack-ex.md",
"chars": 556305,
"preview": "# 栈习题\n\n## 概念\n\n**例题** 栈和队列具有相同的()。\n\n$A.$抽象数据类型\n\n$B.$逻辑结构\n\n$C.$存储结构\n\n$D.$运算\n\n解：$B$。栈和队列的逻辑结构都是相同的，都属于线性结构，只是它们对数据的运算不同。\n\n#"
},
{
"path": "Data-Structrue/2-stack.md",
"chars": 3374,
"preview": "# 栈\n\n栈结构与线性表类似，是只允许一端（表尾）进入或删除的线性表。即后进先出$LIFO$。\n\n栈顶就是允许插入和删除的一端，而另一端就是栈底。\n\n进栈顺序：$A\\rightarrow B\\rightarrow C\\rightarrow "
},
{
"path": "Data-Structrue/3-queue-ex.md",
"chars": 1587,
"preview": "# 队列习题\n\n## 顺序队列\n\n**例题** 火车车轨入口到出口之间有$n$条轨道，列车的行进方向均为从左至右，列车可驶入任意一条轨道且每条道路可以容纳任意多数量的列车。现有编号为$1\\sim9$的$9$列列车，驶入的次序依次是$8,4,"
},
{
"path": "Data-Structrue/3-queue.md",
"chars": 1334,
"preview": "# 队列\n\n队列是只允许一端进行插入（入队或进队），一端进行删除（出队或离队）的线性表。即先进先出$FIFO$。\n\n队列允许插入的一端就是队尾，允许删除的一端就是队头。\n\n队列和栈是逻辑结构和物理结构没有不同，只是操作方式不同。\n\n## 顺"
},
{
"path": "Data-Structrue/4-array-ex.md",
"chars": 1407,
"preview": "# 数组习题\n\n## 三对角矩阵\n\n**例题** 有一个$100$阶的三对角矩阵$M$，其元素$m_{i,j}$（$1\\leqslant i,j\\leqslant100$）按行优先依次压缩存入下标从$0$开始的一维数组$N$中。元素$m_{"
},
{
"path": "Data-Structrue/4-array.md",
"chars": 2189,
"preview": "# 数组\n\n## 数组的定义\n\n数组是由同类型的数据元素构成的有序集合，每个元素是数组元素，每个元素受$n$个线性关系的约束。其中每个元素在$n$个线性关系中的序号就是元素的下标，可以通过下标来访问元素。\n\n数组是对线性表的推广。\n\n数组一"
},
{
"path": "Data-Structrue/5-string-ex.md",
"chars": 2072,
"preview": "# 串习题\n\n基本上就是考察$KMP$算法\n\n## KMP算法\n\n**例题** 设主串$T=$'$abaabaabcabaabc$'，模式串$S=$'$abaabc$'，采用$KMP$算法进行模式匹配，到匹配成功时为止，在匹配过程中进行的单"
},
{
"path": "Data-Structrue/5-string.md",
"chars": 129857,
"preview": "# 串\n\n重点是字符串匹配模式，其他只做了解。\n\n## 基本概念\n\n+ 串：零个或多个字符组成的有限序列。\n+ 子串：串中任意个连续的字符组成的子序列。\n+ 空串：长度为零的串。\n+ 空白串（空格串）：仅由一个或多个空格组成的串。\n+ 空串"
},
{
"path": "Data-Structrue/6-tree-ex.md",
"chars": 6322,
"preview": "# 树习题\n\n## 基本概念\n\n**例题** 在一棵度为$4$的树$T$中，若有$20$个度为$4$的结点，$10$个度为$3$的结点，$1$个度为$2$的结点，$10$个度为$1$的结点，则树$T$的叶结点个数是()。\n\n$A.41$\n\n"
},
{
"path": "Data-Structrue/6-tree.md",
"chars": 138947,
"preview": "# 树\n\n## 基本概念\n\n### 树的基本概念\n\n+ 树：$n$个结点的有限集（树是一种递归的数据结构，适合于表示具有层次的数据结构）。是递归定义的。\n+ 根结点：只有子结点没有父结点的结点。除了根结点外，树任何结点都有且仅有一个前驱。\n"
},
{
"path": "Data-Structrue/7-graph-ex.md",
"chars": 93115,
"preview": "# 图习题\n\n## 基本概念\n\n### 连通边数\n\n**例题** 若无向图$G=(V,E)$中含有$7$个顶点，要保证图$G$在任何情况下都是连通的，则需要的边数最少是()。\n\n$A.6$\n\n$B.15$\n\n$C.16$\n\n$D.21$\n\n"
},
{
"path": "Data-Structrue/7-graph.md",
"chars": 594706,
"preview": "# 图\n\n主要了解概念，算法具体实现不是重点。\n\n## 基本概念\n\n### 图的定义\n\n图是顶点集和边集构成的二元组，即图$G$由顶点集$V$和边集$E$组成，记为$G=(V,E)$，其中$V(G)$表示图$G$中顶点的有限非空集，$E(G"
},
{
"path": "Data-Structrue/8-search-ex.md",
"chars": 254909,
"preview": "# 查找习题\n\n## 线性表查找\n\n### 顺序查找\n\n**例题** 由$n$个数据元素组成的两个表：一个递增有序，一个无序。采用顺序查找算法，对有序表从头开始查找，发现当前元素已不小于待查元素时，停止查找，确定查找不成功，已知查找任一元素"
},
{
"path": "Data-Structrue/8-search.md",
"chars": 167793,
"preview": "# 查找\n\n## 基本概念\n\n+ 查找：在数据集合中寻找满足某种条件的数据元素的过程。\n+ 查找表（查找结构）：用于查找的数据集合，由同一类型的数据元素或记录组成。\n+ 关键字：数据元素中唯一标识该元素的某个数据项的值，使用基于关键字的查找"
},
{
"path": "Data-Structrue/9-sort-ex.md",
"chars": 2502,
"preview": "# 排序习题\n\n## 基本概念\n\n**例题** 对任意$7$个关键字进行基于比较的排序，至少要进行()次关键字之间的两两比较。\n\n$A.13$\n\n$B.14$\n\n$C.15$\n\n$D.6$\n\n解：$A$。对于任意序列进行基于比较的排序，求最"
},
{
"path": "Data-Structrue/9-sort.md",
"chars": 106781,
"preview": "# 排序\n\n## 基本概念\n\n+ 排序：将一个数据元素的任意序列重新排列成一个按关键字有序的序列。\n+ 内部排序：待排序的记录存放在计算机的内存中所进行的排序操作称为内部排序。\n+ 外部排序：待排序的记录数量很大，以致内存一次不能容纳全部记"
},
{
"path": "Operate-System/0-summary-ex.md",
"chars": 19675,
"preview": "# 概述习题\n\n## 基本概念\n\n### 功能\n\n**例题** 系统调用是由操作系统提供给用户的，它()。\n\n$A.$直接通过键盘交互方式使用\n\n$B.$只能通过用户程序间接使用\n\n$C.$是命令接口中的命令\n\n$D.$与系统的命令一样\n\n"
},
{
"path": "Operate-System/0-summary.md",
"chars": 11227,
"preview": "# 概述\n\n## 操作系统的定义\n\n+ 是系统最基本最核心的软件，属于系统软件。\n+ 控制和管理整个计算机的硬件和软件资源。\n+ 合理的组织、调度计算机的工作与资源的分配。\n+ 为用户和其它软件提供方便的接口和环境。\n\n## 操作系统的功能"
},
{
"path": "Operate-System/1-process-management-ex.md",
"chars": 144186,
"preview": "# 进程管理习题\n\n## 进程与线程\n\n### 进程\n\n#### 进程概念\n\n**例题** 进程与程序的根本区别是()。\n\n$A.$静态和动态特点\n\n$B.$是不是被调入内存\n\n$C.$是不是具有就绪、运行和等待三种状态\n\n$D.$是不是占"
},
{
"path": "Operate-System/1-process-management.md",
"chars": 45488,
"preview": "# 进程管理\n\n## 进程与线程\n\n### 进程概念\n\n+ 程序指一个指令序列。\n+ 进程为了满足操作系统的并发性和共享性。\n+ 进程和程序的根本区别在于其动态性。（<span style=\"color:orange\">注意：</span>"
},
{
"path": "Operate-System/2-memory-management-ex.md",
"chars": 9012,
"preview": "# 内存管理习题\n\n## 普通内存管理\n\n### 内存管理基础知识\n\n#### 内存管理内容\n\n**例题** 下面关于存储管理的叙述中，正确的是()。\n\n$A.$存储保护的目的是限制内存的分配\n\n$B.$在内存为$M$、有$N$个用户的分时"
},
{
"path": "Operate-System/2-memory-management.md",
"chars": 21403,
"preview": "# 内存管理\n\n## 内存管理基础知识\n\n### 内存概念\n\n+ 内存是用于存放数据的硬件。程序执行前需要先放到内存中才能被$CPU$处理。用于缓冲速度。\n+ 内存地址从$0$开始，每个地址对应一个存储单元。\n+ 存储单元的大小不定：\n "
},
{
"path": "Operate-System/3-file-management-ex.md",
"chars": 148275,
"preview": "# 文件管理习题\n\n## 文件系统\n\n### 文件系统基础\n\n#### 文件基本操作\n\n**例题** 若一个用户进程通过$read$系统调用读取一个磁盘文件中的数据，则下列关于此过程的叙述中，正确的是(）。\n\nⅠ.若该文件的数据不在内存，则"
},
{
"path": "Operate-System/3-file-management.md",
"chars": 15027,
"preview": "# 文件管理\n\n## 文件系统\n\n文件系统不仅管理普通文件，对于$UNIX$系统所有设备都被视为特殊文件。\n\n### 文件系统基础\n\n#### 文件基本概念\n\n用户输入输出以文件为基本单位。\n\n+ 数据项：最低级数据组织形式。\n + 基本"
},
{
"path": "Operate-System/4-device-management-ex.md",
"chars": 4274,
"preview": "# 设备管理习题\n\n## I/O概述\n\n### I/O设备的基本概念、\n\n**例题** 以下关于设备属性的叙述中，正确的是()。\n\n$A.$字符设备的基本特征是可寻址到字节，即能指定输入的源地址或输出的目标地址\n\n$B.$共享设备必须是可寻"
},
{
"path": "Operate-System/4-device-management.md",
"chars": 19605,
"preview": "# 设备管理\n\n## I/O概述\n\n### I/O设备基本概念\n\n#### I/O设备定义\n\n+ “$I/O$”就是“输入/输出”（$Input/Output$）。$I/O$设备就是可以将数据输入到计算机，或者可以接收计算机输出数据的外部设"
},
{
"path": "README.md",
"chars": 123,
"preview": "# CS408\n考研计算机科学408笔记整理\n\n参考资料：\n\n+ 数据结构考研复习指导 王道论坛\n+ 计算机网络考研复习指导 王道论坛\n+ 计算机组成原理考研复习指导 王道论坛\n+ 操作系统考研复习指导 王道论坛\n+ 计算机网络（第七版）谢"
},
{
"path": "merge（工具程序，不要乱点，用前进去改路径！！）.py",
"chars": 1140,
"preview": "from dataclasses import replace\r\nimport os\r\nimport datetime,time\r\nimport shutil\r\n\r\n\r\npath = \"E:\\考研专业课\\笔记\\CS408-main\\Data"
}
]
About this extraction
This page contains the full source code of the Didnelpsun/CS408 GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 110 files (16.2 MB), approximately 4.2M tokens, and a symbol index with 287 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.