更新顺序表

Code/Code.vcxproj

@@ -141,6 +141,7 @@
   <ItemGroup>
     <ClCompile Include="head.h" />
     <ClCompile Include="main.c" />
+    <ClCompile Include="test.c" />
     <ClCompile Include="sequence_tree.h" />
     <ClCompile Include="sequence_stack.h" />
     <ClCompile Include="thread_tree.h" />

Code/Code.vcxproj.filters

@@ -24,12 +24,15 @@
     <ClCompile Include="sequence_stack.h">
       <Filter>头文件</Filter>
     </ClCompile>
-    <ClCompile Include="sequence_tree.cpp">
-      <Filter>源文件</Filter>
-    </ClCompile>
     <ClCompile Include="thread_tree.h">
       <Filter>头文件</Filter>
     </ClCompile>
+    <ClCompile Include="sequence_tree.h">
+      <Filter>头文件</Filter>
+    </ClCompile>
+    <ClCompile Include="test.c">
+      <Filter>源文件</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="link_list.h">
@@ -62,5 +65,14 @@
     <ClInclude Include="sequence_string.h">
       <Filter>头文件</Filter>
     </ClInclude>
+    <ClInclude Include="graph.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="search.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="sort.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Code/head.h

@@ -1,5 +1,8 @@
 // 初始化最大长度
-#define MAXSIZE 25
+#define MAXSIZE 5
+// 定义默认值
 #define DEFAULTELEM 0
+// 定义最大值
 #define INFINITY 32767
+// 定义默认数据类型
 typedef char element_type;

Code/link_list.h

@@ -333,7 +333,7 @@ LinkList TailBuildLinkListWithHead(LinkList list, int length) {
 	element_type x;
 	if (length < 1) {
 		printf("TailBuildLinkListWithHead:输入的单链表长度过小！");
-		return 1;
+		return NULL;
 	}
 	while (i < length) {
 		scanf("%d", &x);
@@ -359,7 +359,7 @@ LinkList HeadBuildLinkListWithHead(LinkList list, int length) {
 	element_type x;
 	if (length < 1) {
 		printf("HeadBuildLinkListWithHead:输入的单链表长度过小！");
-		return 1;
+		return NULL;
 	}
 	while (i < length) {
 		scanf("%d", &x);

Code/main.c

@@ -1,30 +1,9 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include "head.h"
-#include "sequence_list.h"
-#include "link_list.h"
+
 
 int main()
 {
-    /*StaticSequenceList static_list;
-    InitStaticSequenceList(&static_list);
-    DynamicSequenceList dynamic_list;
-    InitDynamicSequenceList(&dynamic_list);
-    printf("%d\n", dynamic_list.max_size);
-    ReIncreaseDynamicSequenceList(&dynamic_list, 25);
-    printf("%d\n", dynamic_list.max_size);
-    InsertStaticSequenceList(&static_list, 0, 2);
-    InsertStaticSequenceList(&static_list, 1, 6);
-    InsertStaticSequenceList(&static_list, 2, 5);
-    PrintfStaticSequenceList(static_list);
-    element_type i = DEFAULTELEM;
-    DeleteStaticSequenceList(&static_list, 1, &i);
-    PrintfStaticSequenceList(static_list);
-    printf("%d", i);
-    int elem = 65;
-    int index = LocateStaticSequenceListElement(static_list, elem);
-    printf("²éÕÒÔªËØ%dÔÚÐòÁÐ%dλ\n", elem, index + 1);
-    return 0;*/
-    LinkList list;
-    InitLinkList(&list);
+    SequenceListTest();
+    return 0;
 }

Code/sequence_list.h

@@ -8,28 +8,61 @@
 // 静态顺序表
 typedef struct {
     element_type data[MAXSIZE];
+    // 长度
     int length;
 } StaticSequenceList;
 
 // 动态顺序表
 typedef struct {
+    // 给一个指针来分配动态数组
     element_type *data;
     // 已分配的最大容量
     int max_size;
+    // 长度
     int length;
 } DynamicSequenceList;
 
 // 初始化静态顺序表
 int InitStaticSequenceList(StaticSequenceList* list) {
-    // 初初始化静态顺序表长度为0
-    list->length = 0;
-    return 0;
+    if (list == NULL) {
+        printf("InitStaticSequenceList:指针指向为NULL！\n");
+        return 1;
+    }
+    else {
+        // 初初始化静态顺序表长度为0
+        list->length = 0;
+        return 0;
+    }
+}
+
+// 初始化动态顺序表
+int InitDynamicSequenceList(DynamicSequenceList* list) {
+    if (list == NULL) {
+        printf("InitDynamicSequenceList:指针指向为NULL！\n");
+        return 1;
+    }
+    else {
+        // 初初始化动态顺序表长度为0
+        list->length = 0;
+        list->max_size = 0;
+        // 申请一片连续的存储空间
+        element_type* space = (element_type*)malloc(MAXSIZE * sizeof(element_type));
+        if (space != NULL) {
+            list->data = space;
+            list->max_size = MAXSIZE;
+            return 0;
+        }
+        else {
+            printf("InitDynamicSequenceList:分配空间失败！\n");
+            return 1;
+        }
+    }
 }
 
 // 打印静态顺序表
 int PrintfStaticSequenceList(StaticSequenceList list) {
     for (int i = 0; i < list.length; i++) {
-        printf("第%d个元素值为%d\n", i + 1, list.data[i]);
+        printf("第%d个元素值为%c\n", i + 1, list.data[i]);
     }
     return 0;
 }
@@ -37,30 +70,11 @@ int PrintfStaticSequenceList(StaticSequenceList list) {
 // 打印动态顺序表
 int PrintfDynamicSequenceList(DynamicSequenceList list) {
     for (int i = 0; i < list.length; i++) {
-        printf("第%d个元素值为%d\n", i + 1, list.data[i]);
+        printf("第%d个元素值为%c\n", i + 1, list.data[i]);
     }
     return 0;
 }
 
-// 初始化动态顺序表
-int InitDynamicSequenceList(DynamicSequenceList* list) {
-    // 初初始化动态顺序表长度为0
-    list->length = 0;
-    list->max_size = 0;
-    // 申请一片连续的存储空间
-    element_type* space = (element_type*)malloc(MAXSIZE * sizeof(element_type));
-    if (space != NULL) {
-        list->data = space;
-        list->max_size = MAXSIZE;
-        return 0;
-    }
-    else {
-        list->max_size = 0;
-        printf("InitDynamicSequenceList:初始化失败！\n");
-        return 1;
-    }
-}
-
 // 分配其他地址增长动态顺序表的数据空间长度
 int OtherIncreaseDynamicSequenceList(DynamicSequenceList* list, int len) {
     if (len <= 0) {
@@ -73,7 +87,7 @@ int OtherIncreaseDynamicSequenceList(DynamicSequenceList* list, int len) {
     if (space != NULL) {
         // 建立中间变量
         list->data = space;
-        int* temp = list->data;
+        element_type* temp = list->data;
         for (int i = 0; i < list->length; i++) {
             list->data[i] = temp[i];
         }
@@ -111,14 +125,17 @@ int ReIncreaseDynamicSequenceList(DynamicSequenceList* list, int len) {
 
 // 插入静态顺序表
 int InsertStaticSequenceList(StaticSequenceList* list, int index, element_type elem) {
-    if (list->length == MAXSIZE) {
+    // 当静态顺序表已经满了就不能插入任何元素
+    if (list->length >= MAXSIZE) {
         printf("InsertStaticSequenceList:静态顺序表空间不足，插入失败！\n");
         return 1;
     }
+    // 索引位置从0开始，所以可以插入的范围是0到list->length
     if (index > list->length || index < 0) {
-        printf("InsertStaticSequenceList:插入索引超过索引范围！\n");
+        printf("InsertStaticSequenceList:插入索引%d超过索引范围！\n", index);
         return 1;
     }
+    // 从最后一个元素开始交换后移，list->length是空的
     for (int i = list->length; i > index; i--) {
         list->data[i] = list->data[i - 1];
     }
@@ -129,13 +146,19 @@ int InsertStaticSequenceList(StaticSequenceList* list, int index, element_type e
 
 // 插入动态顺序表
 int InsertDynamicSequenceList(DynamicSequenceList* list, int index, element_type elem) {
-    if (list->length == MAXSIZE) {
-        ReIncreaseDynamicSequenceList(list, 1);
-    }
     if (index > list->length || index < 0) {
-        printf("InsertDynamicSequenceList:插入索引超过索引范围！\n");
+        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];
     }
@@ -144,6 +167,30 @@ int InsertDynamicSequenceList(DynamicSequenceList* list, int index, element_type
     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) {
@@ -152,7 +199,7 @@ int DeleteStaticSequenceList(StaticSequenceList* list, int index, element_type *
     }
     *elem = list->data[index];
     for (int i = index; i < list->length; i++) {
-        list->data[i] = list->data[i+1];
+        list->data[i] = list->data[i + 1];
     }
     list->length--;
     return 0;
@@ -172,6 +219,47 @@ int DeleteDynamicSequenceList(DynamicSequenceList* list, int index, element_type
     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;
+    }
+    elem = (element_type*)malloc(len * sizeof(element_type));
+    if (elem == NULL) {
+        printf("MultiDeleteStaticSequenceList:分配空间失败！\n");
+    }
+    else {
+        for (int i = index; i < list->length - len; i++) {
+            elem[i - index] = list->data[i];
+            list->data[i] = list->data[i + len];
+        }
+        list->length -= 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;
+    }
+    elem = (element_type*)malloc(len * sizeof(element_type));
+    if (elem == NULL) {
+        printf("MultiDeleteDynamicSequenceList:分配空间失败！\n");
+    }
+    else {
+        for (int i = index; i < list->length - len; i++) {
+            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) {
@@ -210,4 +298,30 @@ int LocateDynamicSequenceListElement(DynamicSequenceList list, element_type elem
     }
     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) {
+    free(list);
+}
+

Code/test.c

@@ -0,0 +1,27 @@
+// ²âÊÔÎļþ
+
+#include "head.h"
+#include "sequence_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");
+    element_type elem;
+    MultiDeleteDynamicSequenceList(&list, 2, 2, &elem);
+    PrintfDynamicSequenceList(list);
+    /*DynamicSequenceList dlist;
+    InitDynamicSequenceList(&dlist);
+    OtherIncreaseDynamicSequenceList(&dlist, 15);
+    printf("%d", dlist.max_size);*/
+    int index = LocateDynamicSequenceListElement(list, '5');
+    printf("%d", index);
+    return 0;
+}
+

Code/thread_tree.h

@@ -24,6 +24,7 @@ int InorderThread(ThreadTreeNode* node) {
 		pre->rtag = 1;
 	}
 	pre = node;
+	return 0;
 }
 
 // 找到以node为根结点的子树中第一个被中序遍历的结点
@@ -51,6 +52,7 @@ int InorderTraversalThreadTree(ThreadTree tree, int(*visit)(ThreadTreeNode* node
 	for (ThreadTreeNode* p = FristInOrderNode(tree); p != NULL; p = NextInOrderNode(p)) {
 		visit(p);
 	}
+	return 0;
 }
 
 // 找到以node为根结点的子树中前面最后一个被中序遍历的结点
@@ -78,4 +80,5 @@ int ReverseInorderTraversalThreadTree(ThreadTree tree, int(*visit)(ThreadTreeNod
 	for (ThreadTreeNode* p = LastInOrderNode(tree); p != NULL; p = PreInOrderNode(p)) {
 		visit(p);
 	}
+	return 0;
 }

Data-Structrue/0-summary-ex.md

@@ -199,3 +199,10 @@ $C.O(n)$
 $D.O(n^2)$
 
 解：$A$。令执行次数为$t$，基本运算是$t+1$，然后第$t$次$x+1=t$，所以根据判断条件$t^2>n$，所以解得$t>\sqrt{n}$，所以$O(n^\frac{1}{2})$。
+2^k
+**例题** 一个算法所需时间由下述递归方程表示，试求出该算法的时间复杂度的级别（或阶)。
+
+$T(n)=\left\{\begin{array}{lc} 1, & n=1 \\ 2T(n/2)+n , & n>1 \end{array}\right.$
+式中，$n$是问题的规模，为简单起见，设$n$是$2$的整数次幂。
+
+解：设$n$是$2$的整数次幂，所以设$n=2^k$，当执行$k$次时，$n=1$跳出循环。当$n>1$时，$T(2^k)=2T(2^{k-1})+2^k$，又$T(2^{k-1})=2T(2^{k-2})+2^{k-1}$，所以$T(2^k)=4T(2^{k-2})+2\times2^k$，根据递推式规律所以得到$T(2^k)=2^iT(2^{k-i})+i\times2^k$，即$T(2^k)=2^kT(1)+k\times2^k=2^k+k\times2^k=(k+1)\times2^k$，即$T(n)=(\log_2n+1)\times n$，即$O(n\log_2n)$。

Data-Structrue/1-linear-list-ex.md

@@ -0,0 +1,35 @@
+# 线性表习题
+
+## 基本概念
+
+**例题** 以下()是一个线性表。
+
+$A.$由$n$个实数组成的集合
+
+$B.$由$100$个字符组成的序列
+
+$C.$所有整数组成的序列
+
+$D.$邻接表
+
+解：$B$。线性表定义的要求为：相同数据类型、有限序列。选项$C$的元素个数是无穷个，错误；选项$A$集合中的元素没有前后驱关系，错误；选项$D$属于存储结构，线性表是一种逻辑结构，不要将二者混为一谈。只有选项$B$符合线性表定义的要求。
+
+## 顺序表
+
+**例题** 设线性表有$n$个元素，严格说来，以下操作中，()在顺序表上实现要比在链表上实现的效率高。
+
+Ⅰ.输出第$i$（$1\leqslant i\leqslant n$）个元素值。
+
+Ⅱ.交换第$3$个元素与第$4$个元素的值
+
+Ⅲ.顺序输出这$n$个元素的值
+
+$A.$Ⅰ
+
+$B.$Ⅰ、Ⅲ
+
+$C.$Ⅰ、Ⅱ
+
+$D.$Ⅱ、Ⅲ
+
+解：$C$。对于Ⅱ，顺序表仅需$3$次交换操作；链表则需要分别找到两个结点前驱，第$4$个结点断链后再插入到第$2$个结点后，效率较低。对于Ⅲ，需依次顺序访问每个元素，时间复杂度相同。

Data-Structrue/1-linear-list.md

@@ -4,14 +4,14 @@
 
 ### 逻辑结构
 
-是具有相同数据类型的n个数据元素的有限序列。n表示表长。
+是具有相同数据类型的$n$个数据元素的有限序列。$n$表示表长。
 
 $L=(a_1,a_2,\cdots,a_i,\cdots,a_n)$，其中$i$表示元素在线性表中的位序，从一开始。
 
 + 存在惟一的第一个元素。
 + 存在惟一的最后一个元素。
-+ 除第一个元素之外，每个元素均只有一个直接前驱。
-+ 除最后一个元素之外，每个元素均只有一个直接后继。
++ 除第一个元素（表头元素）之外，每个元素均只有一个直接前驱。
++ 除最后一个元素（表尾元素）之外，每个元素均只有一个直接后继。
 
 ### 物理结构
 
@@ -20,7 +20,7 @@ $L=(a_1,a_2,\cdots,a_i,\cdots,a_n)$，其中$i$表示元素在线性表中的位
 
 ## 顺序表
 
-把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来实现。
+把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来实现。$i$是元素$a_i$在线性表中的位序。
 
 ### 顺序表特点
 
@@ -28,14 +28,49 @@ $L=(a_1,a_2,\cdots,a_i,\cdots,a_n)$，其中$i$表示元素在线性表中的位
 2. 存储密度高，只用存储数据。
 3. 拓展容量不方便。
 4. 插入删除操作不方便。
+5. 表中元素的逻辑地址与物理地址顺序相同。
 
 ### 顺序表定义
 
-使用C语言的结构体定义顺序表，使用`typedef`定义一个ElemType表示数据基本类型，并定义最大长度MaxSize：
+使用$C$语言的结构体定义顺序表，使用`typedef`定义一个`ElemType`表示数据基本类型，并定义最大长度`MAXSIZE`：
 
-可以使用静态分配空间，也可以使用动态分配空间：
+```c
+// 初始化最大长度
+#define MAXSIZE 25
+// 定义默认值
+#define DEFAULTELEM 0
+// 定义最大值
+#define INFINITY 32767
+// 定义默认数据类型
+typedef char element_type;
+```
 
-MAXSIZE表示动态顺序表当前可以使用的最大存储空间。
+可以使用静态分配空间：
+
+```c
+// 静态顺序表
+typedef struct {
+    element_type data[MAXSIZE];
+    // 长度
+    int length;
+} StaticSequenceList;
+```
+
+也可以使用动态分配空间，动态分配空间还是顺序的，只不过可以替换原来空间：
+
+```c
+// 动态顺序表
+typedef struct {
+    // 给一个指针来分配动态数组
+    element_type *data;
+    // 已分配的最大容量
+    int max_size;
+    // 长度
+    int length;
+} DynamicSequenceList;
+```
+
+其中长度是指有数据的长度，而最大容量是指已经分配给动态数组的长度，插入时要考虑这个长度，不能溢出。
 
 ### 顺序表操作
 
@@ -51,10 +86,12 @@ MAXSIZE表示动态顺序表当前可以使用的最大存储空间。
 
 #### 顺序表插入
 
-倒序移动元素，最后将数据插入对应索引并长度减一。
+倒序移动元素，最后将数据插入对应索引并长度加一。（这是一个较好的方式，因为如果插入的话其他元素会被挤住，倒序移动元素可以正好空出位置）
 
 插入时间复杂度为：$T(n)=O(n)$，空间复杂度为$S(n)=O(1)$。
 
+平均时间复杂度：假设$p_i$（$n_i=\dfrac{1}{n+1}$）是$i$位置上插入一个结点的概率，则在长度为$n$的线性表中插入一个结点时所需要移动结点的平均次数为$\sum\limits_{i=1}^{n+1}p_i(n-i+1)=\sum\limits_{i=1}^{n+1}\dfrac{1}{n+1}(n-i+1)=\dfrac{1}{n+1}\sum\limits_{i=1}^{n+1}(n-i+1)=\dfrac{1}{n+1}\times\dfrac{n(n+1)}{2}=\dfrac{n}{2}$。
+
 #### 顺序表删除
 
 正序移动元素并长度减一。
@@ -65,7 +102,7 @@ MAXSIZE表示动态顺序表当前可以使用的最大存储空间。
 
 按位查找时间复杂度为$T(n)=O(1)$。
 
-按值查找一般都是找到第一个元素等于指定值的元素，返回其位序，如果没有找到就返回-1。按位查找时间复杂度为$T(n)=O(n)$。
+按值查找一般都是找到第一个元素等于指定值的元素，返回其位序，如果没有找到就返回$-1$。按位查找时间复杂度为$T(n)=O(n)$。
 
 ## 单链表