From ec1dba661f7921a421bde9b77cb9cf8dad82eacc Mon Sep 17 00:00:00 2001 From: "142vip.cn" Date: Sun, 19 Nov 2023 23:39:36 +0800 Subject: [PATCH] =?UTF-8?q?feat(=E6=95=B0=E6=8D=AE=E7=BB=93=E6=9E=84):=20?= =?UTF-8?q?=E6=96=B0=E5=A2=9E=E4=B8=8D=E5=90=8C=E8=AF=AD=E8=A8=80=E7=9A=84?= =?UTF-8?q?=E6=9F=A5=E6=89=BE=E7=AE=97=E6=B3=95=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- code/ds/c++版本/BinaryInsertSort.cpp | 35 ++++++ code/ds/c++版本/BubbleSort.cpp | 43 ++++++++ code/ds/c++版本/LinkList.cpp | 115 ++++++++++++++++++++ code/ds/c++版本/LinkStack.cpp | 69 ++++++++++++ code/ds/c++版本/LoopQueue.cpp | 42 +++++++ code/ds/c++版本/QuickSort.cpp | 35 ++++++ code/ds/c++版本/ShellSort.cpp | 48 ++++++++ code/ds/c++版本/SqList.cpp | 70 ++++++++++++ code/ds/c++版本/SqStack.cpp | 71 ++++++++++++ code/ds/c++版本/StraightInsertSort.cpp | 19 ++++ code/ds/c版本/BinaryInsertSort.cpp | 35 ++++++ code/ds/c版本/BubbleSort.cpp | 43 ++++++++ code/ds/c版本/LinkList.cpp | 115 ++++++++++++++++++++ code/ds/c版本/LinkStack.cpp | 69 ++++++++++++ code/ds/c版本/LoopQueue.cpp | 42 +++++++ code/ds/c版本/QuickSort.cpp | 35 ++++++ code/ds/c版本/ShellSort.cpp | 48 ++++++++ code/ds/c版本/SqList.cpp | 70 ++++++++++++ code/ds/c版本/SqStack.cpp | 71 ++++++++++++ code/ds/c版本/StraightInsertSort.cpp | 19 ++++ code/ds/js版本/BinaryInsertSort.js | 44 ++++++++ code/ds/js版本/BubbleSort.js | 37 +++++++ code/ds/js版本/QuickSort.js | 54 +++++++++ code/ds/js版本/ShellSort.js | 83 ++++++++++++++ code/ds/js版本/StraightInsertSort.js | 34 ++++++ code/ds/ts版本/BinaryInsertSort.ts | 44 ++++++++ code/ds/ts版本/BubbleSort.ts | 47 ++++++++ code/ds/ts版本/QuickSort.ts | 54 +++++++++ code/ds/ts版本/ShellSort.ts | 83 ++++++++++++++ code/ds/ts版本/StraightInsertSort.ts | 34 ++++++ docker-compose.yaml | 4 +- docs/.vuepress/public/mark-map/ccp-map.html | 6 +- docs/.vuepress/public/mark-map/cn-map.html | 6 +- docs/.vuepress/public/mark-map/ds-map.html | 6 +- docs/.vuepress/public/mark-map/os-map.html | 6 +- docs/manuscripts/ds/查找/1.基本概念.md | 26 ++++- nginx.conf | 10 +- scripts/bundle | 4 +- scripts/deploy | 5 +- scripts/docker | 2 - 40 files changed, 1660 insertions(+), 23 deletions(-) create mode 100644 code/ds/c++版本/BinaryInsertSort.cpp create mode 100644 code/ds/c++版本/BubbleSort.cpp create mode 100644 code/ds/c++版本/LinkList.cpp create mode 100644 code/ds/c++版本/LinkStack.cpp create mode 100644 code/ds/c++版本/LoopQueue.cpp create mode 100644 code/ds/c++版本/QuickSort.cpp create mode 100644 code/ds/c++版本/ShellSort.cpp create mode 100644 code/ds/c++版本/SqList.cpp create mode 100644 code/ds/c++版本/SqStack.cpp create mode 100644 code/ds/c++版本/StraightInsertSort.cpp create mode 100644 code/ds/c版本/BinaryInsertSort.cpp create mode 100644 code/ds/c版本/BubbleSort.cpp create mode 100644 code/ds/c版本/LinkList.cpp create mode 100644 code/ds/c版本/LinkStack.cpp create mode 100644 code/ds/c版本/LoopQueue.cpp create mode 100644 code/ds/c版本/QuickSort.cpp create mode 100644 code/ds/c版本/ShellSort.cpp create mode 100644 code/ds/c版本/SqList.cpp create mode 100644 code/ds/c版本/SqStack.cpp create mode 100644 code/ds/c版本/StraightInsertSort.cpp create mode 100644 code/ds/js版本/BinaryInsertSort.js create mode 100644 code/ds/js版本/BubbleSort.js create mode 100644 code/ds/js版本/QuickSort.js create mode 100644 code/ds/js版本/ShellSort.js create mode 100644 code/ds/js版本/StraightInsertSort.js create mode 100644 code/ds/ts版本/BinaryInsertSort.ts create mode 100644 code/ds/ts版本/BubbleSort.ts create mode 100644 code/ds/ts版本/QuickSort.ts create mode 100644 code/ds/ts版本/ShellSort.ts create mode 100644 code/ds/ts版本/StraightInsertSort.ts diff --git a/code/ds/c++版本/BinaryInsertSort.cpp b/code/ds/c++版本/BinaryInsertSort.cpp new file mode 100644 index 0000000..41a7cb8 --- /dev/null +++ b/code/ds/c++版本/BinaryInsertSort.cpp @@ -0,0 +1,35 @@ +// 折半查找 +void BinaryInsertSort(ElemType Arr[],int n){ + int i,j,lowIndex,highIndex,midIndex; + + for(i=2;j<=n;i++){ + // 将待排序的元素暂存在Arr[0]上 + Arr[0]=Arr[i]; + + lowIndex=1; // 左侧子表 折半查找起始位置 + highIndex=i-1; // 左侧子表 折半查找结束位置 + while(lowIndex<=highIndex){ + + // 左侧有序子表的中间位置角标 + midIndex=(lowIndex+heightIndex)/2; + + if(Arr[midIndex].key>Arr[0].key){ + // 小于中间元素，插入位置在子表左侧 + highIndex=mid-1 + }else{ + // 大于或者等于中间元素，插入位置在子表右侧 + lowIndex=midIndex+1; + } + } + + // 跳出循环需要（lowIndex>heightIndex）， + // 说明待插入位置的角标在heightIndex之后，为 heightIndex+1,此时需要将（heightIndex，i）之间的所有元素后移 + + for(j=i-1;j>highIndex;--j){ + Arr[j+1]=Arr[j] + } + + // 后移完成后，将元素Arr[0]赋值到位置（highIndex+1）上 + Arr[highIndex+1]=Arr[0] + } +} diff --git a/code/ds/c++版本/BubbleSort.cpp b/code/ds/c++版本/BubbleSort.cpp new file mode 100644 index 0000000..6b30db4 --- /dev/null +++ b/code/ds/c++版本/BubbleSort.cpp @@ -0,0 +1,43 @@ +// 冒泡排序 +void BubbleSwapSort(ElemType A[], int n){ + for(i=0;ii;j--){ + if(A[j-1].key>A[j].key){ + // 将两个元素A[j-1]、A[j]进行交换，有多种方法 + swap(A[j-1],A[j]) + // 确认已发生交换 + flag=true + } + } + + // 本趟遍历后没有发生交换，说明表已经有序 + if(flag==false){ + return ; + } + } +} + +/** + * 加减法实现两个元素值互换 + */ +void swap(int a, int b){ + // 此时a为两值的和 + a=a+b; + // 此时b的值为a + b=a-b + // 如何实现让a的值为b呢？？此时a的值为b + a=a-b; +} + + +// 临时变量实现两个元素值的互换 +void swap(int a,int b){ + int temp; + temp=a; + a=b; + b=temp +} + diff --git a/code/ds/c++版本/LinkList.cpp b/code/ds/c++版本/LinkList.cpp new file mode 100644 index 0000000..bb6d6bf --- /dev/null +++ b/code/ds/c++版本/LinkList.cpp @@ -0,0 +1,115 @@ +// 单链表头插法 +LinkList CreateListWithStartNode(LinkList &L){ + + LNode *s; + int x; + L=(LinkList)malloc(sizeof(LNode)); // 创建头结点L + L->next=NULL; // 初始化空链表 + + // 控制台输入值 + scanf("%d",&x); + + // 输入9999 表示结束 + while(x!==9999){ + // 开辟新结点存储空间 + s=(LNode*)malloc(sizeof(LNode)); + // 结点数据域赋值 + s->data=x; + // 修改指针，新结点插入表中【注意：L->next为头结点的指针域】 + s->next=L->next; + L->next=s; + scanf("%d",&x); + } + + // 返回单链表 + return L; +} + +// 单链表尾插法 +LinkList CreateListWithEndNode(LinkList &L){ + + + int x; // 输入结点值 + L=(LinkList)malloc(sizeof(LNode)); + LNode *s; // 新结点s + LNode *r=L; // r为尾指针 + + // 控制台输入值 + scanf("%d",&x); + + while(x!==9999){ + // 开辟新结点存储空间 + s=(LNode *)malloc(sizeof(LNode)); + + // 新结点s的数据域赋值为x + s->data=x; + // 单链表L的尾指针指向新的结点s + r->next=s; + + // 指针r指向新的表尾结点 + r=s; + + scanf("%d",&x); + } + + // 表尾指针置空【重要】 + r->next=NULL; + + // 返回单链表 + return L; + +} + +// 单链表按序号查找 +LNode *GetElem(LinkList L,int i){ + int j=1; // 查询计数，初始为1 + LNode *p=L->next; // 单链表头结点指针赋值给指针p + + + // 第0个元素，则指向头结点，返回头结点 + if(i==0){ + // 头结点包含数据域和指针域 + return L; + } + + // 不等于0，却小于1，则i为负数无效，直接返回NULL，查询结果空； + if(i<1){ + return NULL; + } + + // p存在且计数没有走到初始i的位置 + while(p&&jnext; + + // 计数标记+1 + j++; + } + + // 注意： 当p不存在时， 跳出循环，p=NULL; 当p存在但是j大于等于i，跳出循环，返回查找的结果，返回p + // 从跳出循环上来分析，p要么存在即：找到的结点元素，要么为空即NULL + + // 跳出循环，返回第i个结点的指针 + return p; + +} + +//单链表按值查找 +LNode *LocateElem(LinkList L,ElemType e){ + + // 指针【哨兵】 + LNode *p=L->next; + // 从第1个结点开始查找数据域(data)为e的结点 + while(p!=NULL&&p->data!=e){ + // 无法匹配，指针后移 + p=p->next; + } + + // 注意：p为NULL的时候，说明单链表已经遍历的尾结点了，跳出循环，没有找到目标结点； + + // 查找到第1个匹配的结点，跳出循环，返回结点指针 + return p; + // +} + diff --git a/code/ds/c++版本/LinkStack.cpp b/code/ds/c++版本/LinkStack.cpp new file mode 100644 index 0000000..baf008d --- /dev/null +++ b/code/ds/c++版本/LinkStack.cpp @@ -0,0 +1,69 @@ +// 链栈类型定义【基础】 +typedef struct LinkNode{ + ElemType data; // 栈元素结点数据域 + struct LinkNode *next; // 栈元素结点指针域 +} *LinkStack; + +// 更为详细的定义 + +typedef struct StackNode +{ + int data;//结点数据域 + struct StackNode* next;//结点指针域 +}StackNode,* LinkTop; + +//链栈的数据结构 +typedef struct LinkStack +{ + LinkTop top; //栈顶结点,定义了一个指向上个结构体的指针 + int count;//元素个数 +}LinkStack; + + +// 基于单链表链栈的进栈操作 +bool linkStackPushNode(LinkStack* linkStack,int e){ + + // 判断链栈是否存在 + if (!linkStack){ + //链栈不存在，无法进栈操作，返回false + return false; + } + // 开辟栈结点元素内存控件 + StackNode* node = (StackNode*)malloc(sizeof(StackNode)); + // 新结点指针域指向链表，即栈顶指针位置，元素加入链表 + node->next = linkStack->top; + // 新结点数据域赋值 + node->data = e; + // 元素进栈，移动栈顶指针，指向新入栈的元素 + linkStack->top = node; + // 链栈元素总数+1 + linkStack->count++; + //链栈入栈成功，返回true + return true; +} + + +/* + * 基于单链表链栈的出栈操作 + * + */ +bool linkStackPopNode(LinkStack* linkStack,int *e){ + // 判断链栈是否存在及是否为空 + if (!linkStack || linkStack->count==0){ + //出栈失败，返回false + return false; + } + // 获取栈顶元素结点 + StackNode* node = stack->top; + + // 结点元素数据域赋值给变量e + *e = linkStack->data; + // 移动栈顶指向，栈顶指针指向待出栈结点的后继结点 + linkStack->top = node->next; + // 变量e已被赋值，释放链栈出栈元素的内存控件 + free(node); + // 链栈元素个数-1 + linkStack->count--; + // 出栈成功，返回true. + return true; +} diff --git a/code/ds/c++版本/LoopQueue.cpp b/code/ds/c++版本/LoopQueue.cpp new file mode 100644 index 0000000..cac5aef --- /dev/null +++ b/code/ds/c++版本/LoopQueue.cpp @@ -0,0 +1,42 @@ +// 队列最大存储元素个数 +#define MaxSize 50 + +// 结构体定义 +typedef struct { + // 存放队列元素 + ElemType data[MaxSize]; + // 队头指针和队尾指针 + int front,rear; +} SqQueue; + +// 入队算法 +// 尾插法：Q.data[Q.rear]=x;Q.rear=(Q.rear+1)%Maxsize;Q.tag=1 +// 队空条件：Q.front== Q.rear且Q.tag==0 +int EnLoopQueue(SqQueue &Q, ElemType x){ + if(Q.front==Q.rear&&Q.tag==1){ + return 0; + } + Q.data[Q.rear]=x; + Q.rear=(Q.rear+1)%MaxSize; + Q.tag=1; + return 1; +} + + + +// 出队算法 +// 头结点删除：x=Q.data[Q.front];Q.front=(Q.front +1)%Maxsize;Q.tag=0 +// 队满条件：Q.front == Q.rear且Q.tag=1 +// 注意：当删除之后链表为空时，还需增加一步，将尾指针指向头结点 +int DeLoopQueue(SqQueue &Q, ElemType &x){ + if (Q.front==Q.rear&&Q.tag==0){ + return 0; + } + x=Q.data[Q.front]; + Q.front=(Q.front+1)%MaxSize; + Q.tag=0; + return 1; +} + + + diff --git a/code/ds/c++版本/QuickSort.cpp b/code/ds/c++版本/QuickSort.cpp new file mode 100644 index 0000000..749c747 --- /dev/null +++ b/code/ds/c++版本/QuickSort.cpp @@ -0,0 +1,35 @@ +// 快速排序【伪代码】 +void QuickSort(ElemType A[] , int low , int high){ + // low > high 表角标越界，low=high 子表只有一个元素，不需要进行快排，已经有序 + if(low=pivot) --high + A[low]=A[high] // 比pivot小的都移到左表 注意--high 从后往前遍历 + + while(lowhigh 跳出循环后即找到能将当前表一分为二的pivotKey值 + A[low]=pivot + // 基准元素pivot对应最终的位置角标 + return low +} \ No newline at end of file diff --git a/code/ds/c++版本/ShellSort.cpp b/code/ds/c++版本/ShellSort.cpp new file mode 100644 index 0000000..3140e5d --- /dev/null +++ b/code/ds/c++版本/ShellSort.cpp @@ -0,0 +1,48 @@ + +// 希尔排序【伪代码】 +void ShellSort(ElemType Arr[] , int n){ + // k是增量 + for(k=n/2;k>=1;k=k/2){ + + // 增量子表进行直接插入排序 + for(i=k+1;i<=n;++i){ + + if(Arr[i].key0&&Arr[0].key=1;n/=2){ + + // // 步长为k，则对应分为k个组，分别对其进行 直接插入排序 + + for(i=1,i<=k;i++){ + + // 第一步： 对应组的元素找出来，组成新的待排序的数列 + // 第二步： 对待排序数列进行 直接插入排序 + + specialStraightInsertSort(ElemType Arr[], int n , int k , int i) + + } + + } + // 返回 + return Arr; +} + \ No newline at end of file diff --git a/code/ds/c++版本/SqList.cpp b/code/ds/c++版本/SqList.cpp new file mode 100644 index 0000000..bd7b877 --- /dev/null +++ b/code/ds/c++版本/SqList.cpp @@ -0,0 +1,70 @@ +// 顺序表的基础操作 + +// 基础结构体 +define MaxSize 50; +typedef struct{ + ElemType data[MaxSize]; // ElemType 代表元素类型 int、string..... + int length; +}SqList + + + +bool ListInsert(SqList &L, int i, ElemType e){ + + // i非法 i=1 表头 i=L.length+1 表尾巴 + if(i<1||i>L.length+1){ + return false; + } + + // 存储空间满，无法插入 + if(L.length >= MaxSize){ + return false; + } + + // 遍历，将位置元素往后移动，注意从后往前循环，避免值被覆盖 + for(int j=L.length; j>=i;j--){ + L.data[j]=L.data[j-1]; + } + + // 此时，表L中的第i个元素和第i+1元素素值一样，将新元素存入i位置即可 + + // 第i个元素，对应的位置角标为i-1 + L.data[i-1]=e; + + // 表长度加1 + L.length++; + + // 返回插入成功 + return true; +} + + +bool ListDelete(SqList &L, int i, ElemType &e){ + + // i非法 i=1 表头 i=L.length+1 表尾巴 + if(i<1||i>L.length+1){ + return false; + } + + // 存储空间满，无法插入 + if(L.length >= MaxSize){ + return false; + } + + // 引用变量e赋值 + e=L.data[i-1] + + // 遍历，第i个元素后面的往前移动 + for(int j=i; j<=L.length;j++){ + // 从第i个元素开始，角标从i-1开始 + L.data[j-1]=L.data[j]; + } + + // 此时，表L中的表尾元素和倒数第二个元素值一样，将表的长度-1 + + // 表长度减1 + L.length--; + + // 返回删除成功 + return true; +} \ No newline at end of file diff --git a/code/ds/c++版本/SqStack.cpp b/code/ds/c++版本/SqStack.cpp new file mode 100644 index 0000000..b09b304 --- /dev/null +++ b/code/ds/c++版本/SqStack.cpp @@ -0,0 +1,71 @@ +// 定义栈中元素的最大个数 +# define MaxSize 50 + +// 结构体定义 +typedef struct{ + ElemType data[MaxSize]; // 存放栈中元素 + int top; // 栈顶指针 +}SqStack; + + +// 初始化 +void InitStack(&S){ + // 栈顶指针-1 + s.top=-1; +} + +// 栈空判断 +bool StackEmpty(S){ + if(S.top==-1){ + // 栈空 + return true; + }else{ + // 栈非空 + return false; + } +} + +// 进栈 +bool Push(SqStack &S,ElemType x){ + if(S.top==MaxSize-1){ + // 栈满，返回false，元素无法进行进栈操作 + return false; + }else{ + // 可进栈，栈顶指针+1，再元素入栈 + S.data[++S.top]=x; + + // 入栈成功 + return true; + } +} + + +// 出栈 +bool Pop(SqStack &S,ElemType &x){ + if(S.top==-1){ + // 栈空，无栈顶元素可出栈，返回false + return false; + }else{ + // 栈非空，先元素出栈，再进行指针-1 + x=S.data[S.top--]; + + // 出栈成功，返回true + return true; + } +} + +// 读（获取）栈顶元素 +bool GetTop(SqStack S,ElemType &x){ + + if(S.top==-1){ + // 栈空，无栈顶元素,返回false + return false; + }else{ + + // 通过栈顶指针，获取栈顶元素，赋值给变量x + x=S.data[S.top]; + + // 读取栈顶元素成功，返回true + return true; + } +} diff --git a/code/ds/c++版本/StraightInsertSort.cpp b/code/ds/c++版本/StraightInsertSort.cpp new file mode 100644 index 0000000..098ed8d --- /dev/null +++ b/code/ds/c++版本/StraightInsertSort.cpp @@ -0,0 +1,19 @@ +// 直接插入排序【伪代码】 +void straightInsertSort(ElemType A[], int n){ + int i,j; + + // 依次将前面的第2到第n个元素插入到前面的有序序列 + for(i=2;i<=n;i++){ + if(A[i].key< A[i-1].key){ + // 哨兵元素 + A[0]=A[i]; + // 循环向后挪动 + for(j=i-1;A[0].keyArr[0].key){ + // 小于中间元素，插入位置在子表左侧 + highIndex=mid-1 + }else{ + // 大于或者等于中间元素，插入位置在子表右侧 + lowIndex=midIndex+1; + } + } + + // 跳出循环需要（lowIndex>heightIndex）， + // 说明待插入位置的角标在heightIndex之后，为 heightIndex+1,此时需要将（heightIndex，i）之间的所有元素后移 + + for(j=i-1;j>highIndex;--j){ + Arr[j+1]=Arr[j] + } + + // 后移完成后，将元素Arr[0]赋值到位置（highIndex+1）上 + Arr[highIndex+1]=Arr[0] + } +} diff --git a/code/ds/c版本/BubbleSort.cpp b/code/ds/c版本/BubbleSort.cpp new file mode 100644 index 0000000..6b30db4 --- /dev/null +++ b/code/ds/c版本/BubbleSort.cpp @@ -0,0 +1,43 @@ +// 冒泡排序 +void BubbleSwapSort(ElemType A[], int n){ + for(i=0;ii;j--){ + if(A[j-1].key>A[j].key){ + // 将两个元素A[j-1]、A[j]进行交换，有多种方法 + swap(A[j-1],A[j]) + // 确认已发生交换 + flag=true + } + } + + // 本趟遍历后没有发生交换，说明表已经有序 + if(flag==false){ + return ; + } + } +} + +/** + * 加减法实现两个元素值互换 + */ +void swap(int a, int b){ + // 此时a为两值的和 + a=a+b; + // 此时b的值为a + b=a-b + // 如何实现让a的值为b呢？？此时a的值为b + a=a-b; +} + + +// 临时变量实现两个元素值的互换 +void swap(int a,int b){ + int temp; + temp=a; + a=b; + b=temp +} + diff --git a/code/ds/c版本/LinkList.cpp b/code/ds/c版本/LinkList.cpp new file mode 100644 index 0000000..bb6d6bf --- /dev/null +++ b/code/ds/c版本/LinkList.cpp @@ -0,0 +1,115 @@ +// 单链表头插法 +LinkList CreateListWithStartNode(LinkList &L){ + + LNode *s; + int x; + L=(LinkList)malloc(sizeof(LNode)); // 创建头结点L + L->next=NULL; // 初始化空链表 + + // 控制台输入值 + scanf("%d",&x); + + // 输入9999 表示结束 + while(x!==9999){ + // 开辟新结点存储空间 + s=(LNode*)malloc(sizeof(LNode)); + // 结点数据域赋值 + s->data=x; + // 修改指针，新结点插入表中【注意：L->next为头结点的指针域】 + s->next=L->next; + L->next=s; + scanf("%d",&x); + } + + // 返回单链表 + return L; +} + +// 单链表尾插法 +LinkList CreateListWithEndNode(LinkList &L){ + + + int x; // 输入结点值 + L=(LinkList)malloc(sizeof(LNode)); + LNode *s; // 新结点s + LNode *r=L; // r为尾指针 + + // 控制台输入值 + scanf("%d",&x); + + while(x!==9999){ + // 开辟新结点存储空间 + s=(LNode *)malloc(sizeof(LNode)); + + // 新结点s的数据域赋值为x + s->data=x; + // 单链表L的尾指针指向新的结点s + r->next=s; + + // 指针r指向新的表尾结点 + r=s; + + scanf("%d",&x); + } + + // 表尾指针置空【重要】 + r->next=NULL; + + // 返回单链表 + return L; + +} + +// 单链表按序号查找 +LNode *GetElem(LinkList L,int i){ + int j=1; // 查询计数，初始为1 + LNode *p=L->next; // 单链表头结点指针赋值给指针p + + + // 第0个元素，则指向头结点，返回头结点 + if(i==0){ + // 头结点包含数据域和指针域 + return L; + } + + // 不等于0，却小于1，则i为负数无效，直接返回NULL，查询结果空； + if(i<1){ + return NULL; + } + + // p存在且计数没有走到初始i的位置 + while(p&&jnext; + + // 计数标记+1 + j++; + } + + // 注意： 当p不存在时， 跳出循环，p=NULL; 当p存在但是j大于等于i，跳出循环，返回查找的结果，返回p + // 从跳出循环上来分析，p要么存在即：找到的结点元素，要么为空即NULL + + // 跳出循环，返回第i个结点的指针 + return p; + +} + +//单链表按值查找 +LNode *LocateElem(LinkList L,ElemType e){ + + // 指针【哨兵】 + LNode *p=L->next; + // 从第1个结点开始查找数据域(data)为e的结点 + while(p!=NULL&&p->data!=e){ + // 无法匹配，指针后移 + p=p->next; + } + + // 注意：p为NULL的时候，说明单链表已经遍历的尾结点了，跳出循环，没有找到目标结点； + + // 查找到第1个匹配的结点，跳出循环，返回结点指针 + return p; + // +} + diff --git a/code/ds/c版本/LinkStack.cpp b/code/ds/c版本/LinkStack.cpp new file mode 100644 index 0000000..baf008d --- /dev/null +++ b/code/ds/c版本/LinkStack.cpp @@ -0,0 +1,69 @@ +// 链栈类型定义【基础】 +typedef struct LinkNode{ + ElemType data; // 栈元素结点数据域 + struct LinkNode *next; // 栈元素结点指针域 +} *LinkStack; + +// 更为详细的定义 + +typedef struct StackNode +{ + int data;//结点数据域 + struct StackNode* next;//结点指针域 +}StackNode,* LinkTop; + +//链栈的数据结构 +typedef struct LinkStack +{ + LinkTop top; //栈顶结点,定义了一个指向上个结构体的指针 + int count;//元素个数 +}LinkStack; + + +// 基于单链表链栈的进栈操作 +bool linkStackPushNode(LinkStack* linkStack,int e){ + + // 判断链栈是否存在 + if (!linkStack){ + //链栈不存在，无法进栈操作，返回false + return false; + } + // 开辟栈结点元素内存控件 + StackNode* node = (StackNode*)malloc(sizeof(StackNode)); + // 新结点指针域指向链表，即栈顶指针位置，元素加入链表 + node->next = linkStack->top; + // 新结点数据域赋值 + node->data = e; + // 元素进栈，移动栈顶指针，指向新入栈的元素 + linkStack->top = node; + // 链栈元素总数+1 + linkStack->count++; + //链栈入栈成功，返回true + return true; +} + + +/* + * 基于单链表链栈的出栈操作 + * + */ +bool linkStackPopNode(LinkStack* linkStack,int *e){ + // 判断链栈是否存在及是否为空 + if (!linkStack || linkStack->count==0){ + //出栈失败，返回false + return false; + } + // 获取栈顶元素结点 + StackNode* node = stack->top; + + // 结点元素数据域赋值给变量e + *e = linkStack->data; + // 移动栈顶指向，栈顶指针指向待出栈结点的后继结点 + linkStack->top = node->next; + // 变量e已被赋值，释放链栈出栈元素的内存控件 + free(node); + // 链栈元素个数-1 + linkStack->count--; + // 出栈成功，返回true. + return true; +} diff --git a/code/ds/c版本/LoopQueue.cpp b/code/ds/c版本/LoopQueue.cpp new file mode 100644 index 0000000..cac5aef --- /dev/null +++ b/code/ds/c版本/LoopQueue.cpp @@ -0,0 +1,42 @@ +// 队列最大存储元素个数 +#define MaxSize 50 + +// 结构体定义 +typedef struct { + // 存放队列元素 + ElemType data[MaxSize]; + // 队头指针和队尾指针 + int front,rear; +} SqQueue; + +// 入队算法 +// 尾插法：Q.data[Q.rear]=x;Q.rear=(Q.rear+1)%Maxsize;Q.tag=1 +// 队空条件：Q.front== Q.rear且Q.tag==0 +int EnLoopQueue(SqQueue &Q, ElemType x){ + if(Q.front==Q.rear&&Q.tag==1){ + return 0; + } + Q.data[Q.rear]=x; + Q.rear=(Q.rear+1)%MaxSize; + Q.tag=1; + return 1; +} + + + +// 出队算法 +// 头结点删除：x=Q.data[Q.front];Q.front=(Q.front +1)%Maxsize;Q.tag=0 +// 队满条件：Q.front == Q.rear且Q.tag=1 +// 注意：当删除之后链表为空时，还需增加一步，将尾指针指向头结点 +int DeLoopQueue(SqQueue &Q, ElemType &x){ + if (Q.front==Q.rear&&Q.tag==0){ + return 0; + } + x=Q.data[Q.front]; + Q.front=(Q.front+1)%MaxSize; + Q.tag=0; + return 1; +} + + + diff --git a/code/ds/c版本/QuickSort.cpp b/code/ds/c版本/QuickSort.cpp new file mode 100644 index 0000000..749c747 --- /dev/null +++ b/code/ds/c版本/QuickSort.cpp @@ -0,0 +1,35 @@ +// 快速排序【伪代码】 +void QuickSort(ElemType A[] , int low , int high){ + // low > high 表角标越界，low=high 子表只有一个元素，不需要进行快排，已经有序 + if(low=pivot) --high + A[low]=A[high] // 比pivot小的都移到左表 注意--high 从后往前遍历 + + while(lowhigh 跳出循环后即找到能将当前表一分为二的pivotKey值 + A[low]=pivot + // 基准元素pivot对应最终的位置角标 + return low +} \ No newline at end of file diff --git a/code/ds/c版本/ShellSort.cpp b/code/ds/c版本/ShellSort.cpp new file mode 100644 index 0000000..3140e5d --- /dev/null +++ b/code/ds/c版本/ShellSort.cpp @@ -0,0 +1,48 @@ + +// 希尔排序【伪代码】 +void ShellSort(ElemType Arr[] , int n){ + // k是增量 + for(k=n/2;k>=1;k=k/2){ + + // 增量子表进行直接插入排序 + for(i=k+1;i<=n;++i){ + + if(Arr[i].key0&&Arr[0].key=1;n/=2){ + + // // 步长为k，则对应分为k个组，分别对其进行 直接插入排序 + + for(i=1,i<=k;i++){ + + // 第一步： 对应组的元素找出来，组成新的待排序的数列 + // 第二步： 对待排序数列进行 直接插入排序 + + specialStraightInsertSort(ElemType Arr[], int n , int k , int i) + + } + + } + // 返回 + return Arr; +} + \ No newline at end of file diff --git a/code/ds/c版本/SqList.cpp b/code/ds/c版本/SqList.cpp new file mode 100644 index 0000000..bd7b877 --- /dev/null +++ b/code/ds/c版本/SqList.cpp @@ -0,0 +1,70 @@ +// 顺序表的基础操作 + +// 基础结构体 +define MaxSize 50; +typedef struct{ + ElemType data[MaxSize]; // ElemType 代表元素类型 int、string..... + int length; +}SqList + + + +bool ListInsert(SqList &L, int i, ElemType e){ + + // i非法 i=1 表头 i=L.length+1 表尾巴 + if(i<1||i>L.length+1){ + return false; + } + + // 存储空间满，无法插入 + if(L.length >= MaxSize){ + return false; + } + + // 遍历，将位置元素往后移动，注意从后往前循环，避免值被覆盖 + for(int j=L.length; j>=i;j--){ + L.data[j]=L.data[j-1]; + } + + // 此时，表L中的第i个元素和第i+1元素素值一样，将新元素存入i位置即可 + + // 第i个元素，对应的位置角标为i-1 + L.data[i-1]=e; + + // 表长度加1 + L.length++; + + // 返回插入成功 + return true; +} + + +bool ListDelete(SqList &L, int i, ElemType &e){ + + // i非法 i=1 表头 i=L.length+1 表尾巴 + if(i<1||i>L.length+1){ + return false; + } + + // 存储空间满，无法插入 + if(L.length >= MaxSize){ + return false; + } + + // 引用变量e赋值 + e=L.data[i-1] + + // 遍历，第i个元素后面的往前移动 + for(int j=i; j<=L.length;j++){ + // 从第i个元素开始，角标从i-1开始 + L.data[j-1]=L.data[j]; + } + + // 此时，表L中的表尾元素和倒数第二个元素值一样，将表的长度-1 + + // 表长度减1 + L.length--; + + // 返回删除成功 + return true; +} \ No newline at end of file diff --git a/code/ds/c版本/SqStack.cpp b/code/ds/c版本/SqStack.cpp new file mode 100644 index 0000000..b09b304 --- /dev/null +++ b/code/ds/c版本/SqStack.cpp @@ -0,0 +1,71 @@ +// 定义栈中元素的最大个数 +# define MaxSize 50 + +// 结构体定义 +typedef struct{ + ElemType data[MaxSize]; // 存放栈中元素 + int top; // 栈顶指针 +}SqStack; + + +// 初始化 +void InitStack(&S){ + // 栈顶指针-1 + s.top=-1; +} + +// 栈空判断 +bool StackEmpty(S){ + if(S.top==-1){ + // 栈空 + return true; + }else{ + // 栈非空 + return false; + } +} + +// 进栈 +bool Push(SqStack &S,ElemType x){ + if(S.top==MaxSize-1){ + // 栈满，返回false，元素无法进行进栈操作 + return false; + }else{ + // 可进栈，栈顶指针+1，再元素入栈 + S.data[++S.top]=x; + + // 入栈成功 + return true; + } +} + + +// 出栈 +bool Pop(SqStack &S,ElemType &x){ + if(S.top==-1){ + // 栈空，无栈顶元素可出栈，返回false + return false; + }else{ + // 栈非空，先元素出栈，再进行指针-1 + x=S.data[S.top--]; + + // 出栈成功，返回true + return true; + } +} + +// 读（获取）栈顶元素 +bool GetTop(SqStack S,ElemType &x){ + + if(S.top==-1){ + // 栈空，无栈顶元素,返回false + return false; + }else{ + + // 通过栈顶指针，获取栈顶元素，赋值给变量x + x=S.data[S.top]; + + // 读取栈顶元素成功，返回true + return true; + } +} diff --git a/code/ds/c版本/StraightInsertSort.cpp b/code/ds/c版本/StraightInsertSort.cpp new file mode 100644 index 0000000..098ed8d --- /dev/null +++ b/code/ds/c版本/StraightInsertSort.cpp @@ -0,0 +1,19 @@ +// 直接插入排序【伪代码】 +void straightInsertSort(ElemType A[], int n){ + int i,j; + + // 依次将前面的第2到第n个元素插入到前面的有序序列 + for(i=2;i<=n;i++){ + if(A[i].key< A[i-1].key){ + // 哨兵元素 + A[0]=A[i]; + // 循环向后挪动 + for(j=i-1;A[0].key highIndex; --j) { + arr[j + 1] = arr[j] + } + arr[highIndex + 1] = temp + } + // 返回经过折半插入排序处理的有序数组 + return arr +} + + +// 测试用例 +const dealArr = [5, 2, 7, 3, 18, 8, 12, 1] +console.log('插入排序前：', dealArr) +const sortResult = binaryInsertSort(dealArr, 7) +console.log('插入排序后：', sortResult) + diff --git a/code/ds/js版本/BubbleSort.js b/code/ds/js版本/BubbleSort.js new file mode 100644 index 0000000..605a80f --- /dev/null +++ b/code/ds/js版本/BubbleSort.js @@ -0,0 +1,37 @@ +/** + * 冒泡排序【JavaScript版本】 + */ +function BubbleSort(arr, len) { + // 校正数组的长度 + len = arr.length === len ? len : arr.length + + // 冒泡排序，让数组arr有序 + for (let i = 0; i < len - 1; i++) { + let isSorted = false + + // len个数组，进行len-1趟，即：一趟冒泡 + for (let j = len - 1; j > i; j--) { + // 注意：这里的for循环倒序是有讲究的，想象一下泡泡不都是网上升的么.... + if (arr[j - 1] > arr[j]) { + // 交换元素，始终让最小的元素往上走（冒泡） + const temp = arr[j - 1] + arr[j - 1] = arr[j] + arr[j] = temp + + // 需要冒泡 + isSorted = true + } + } + // 第一趟比较后，如果本身序列是有序的，就直接跳出循环 + if (isSorted === false) { + break + } + } + + return arr +} + +const initArr = [1, 5, 8, 3, 2, 9, 16] +console.log(`冒泡排序前：${initArr}`) +const sortedArr = BubbleSort(initArr, 7) +console.log(`冒泡排序后：${sortedArr}`) diff --git a/code/ds/js版本/QuickSort.js b/code/ds/js版本/QuickSort.js new file mode 100644 index 0000000..ea9192b --- /dev/null +++ b/code/ds/js版本/QuickSort.js @@ -0,0 +1,54 @@ +/** + * 基于分治法思想，将数组进行快速排序 + * @param {Array} arr 待排序的数组 + * @param {int} low 数组低位角标 左指针 + * @param {int} high 数组高位角标 右指针 + */ +function QuickSort(arr, low, high) { + // low=high 说明只有一个元素，理解为有序，不做处理 + // low>high 说明左、右指针已经重合，数组已经遍历完，需要跳出 + if (low < high) { + const pivotIndex = Partition(arr, low, high) + // 处理左侧 + QuickSort(arr, low, pivotIndex - 1) + // 处理右侧 + QuickSort(arr, pivotIndex + 1, high) + } + + // 经过快排处理的数组 + return arr +} + + +/** + * + * 寻找数组中的基准pivot，使得左侧元素全部小于等于pivot，右侧元素全部大于等于pivot + * @param {Array} arr 分治思想处理后的数组 + * @param {int} low 数组低位角标 左指针 + * @param {int} high 数组高位角标 右指针 + */ +function Partition(arr, low, high) { + // 假设低位指针对应数组角标元素为基准pivot + const pivot = arr[low] + while (low < high) { + // 从右往左直到比pivot小跳出循环 + while (low < high && arr[high] >= pivot) --high + arr[low] = arr[high] + + // 从左往右直到比pivot大跳出循环 + while (low < high && arr[low] <= pivot) ++low + arr[high] = arr[low] + } + + // 基准值移到最终的位置，此时左侧小于等于pivot 右侧大于等于pivot + arr[low] = pivot + + // 返回基准值的角标 + return low +} + + +const initArr = [2, 18, 6, 25, 19, 4, 8, 3, 7] +console.log(`快速排序处理前：${initArr}`) +const quickSortResult = QuickSort(initArr, 0, 8) +console.log(`快速排序处理后：${quickSortResult}`) diff --git a/code/ds/js版本/ShellSort.js b/code/ds/js版本/ShellSort.js new file mode 100644 index 0000000..5396b87 --- /dev/null +++ b/code/ds/js版本/ShellSort.js @@ -0,0 +1,83 @@ +/** + * 数组的希尔排序 + * - 返回已排序的数组，从小到大 + * @param {Array} arr 待排序数组 + * @param {int} len 数组长度，可校验 + * @returns + */ +function shellSort(arr, len) { + // 校对数组长度 + len = arr.length === len ? len : arr.length + + // 注意处理浮点【向上取整】 防止空指针 + for (let increment = Math.floor(len / 2); increment >= 1; increment = Math.floor(increment / 2)) { + // 对每组数据，进行直接排序 + for (let groupIndex = 0; groupIndex < increment; ++groupIndex) { + specialStraightInsertSort(arr, len, increment, groupIndex) + } + } + + return arr +} + +/** + * 根据希尔排序的步长对分组进行直接插入排序处理 + * @param {Array} arr 排序数组 + * @param {int} len 数组长度 + * @param {int} increment 增量步长 + * @param {int} groupIndex 分组，第几个分组 + */ +function specialStraightInsertSort(arr, len, increment, groupIndex) { + len = arr.length === len ? len : arr.length + console.log(`数组长度：${len}----->当前步长：${increment}---->分组：${groupIndex}`) + + for (let eleStartIndex = groupIndex + increment; eleStartIndex < len; eleStartIndex += increment) { + // 此时eleStartIndex为直接插入排序的比较元素 + + + // 直接插入排序中的哨兵元素【重要】 + const temp = arr[eleStartIndex] + let j + // 向前比较 从小到大 + for (j = eleStartIndex - increment; j >= 0 && arr[j] > temp; j -= increment) { + arr[j + increment] = arr[j] + } + arr[j + increment] = temp + } + + console.log('specialStraightInsertSort处理后：', arr) + return arr +} + + +const dealArr = [5, 8, 2, 16, 3, 9, 1] +console.log('插入排序前：', dealArr) +const sortResult = shellSort(dealArr, 7) +console.log('插入排序后：', sortResult) + + +/** + * 简化的希尔排序 + * - 返回已排序号的数组，从小到大 + * @param {Array} arr + */ +function shellSortBetter(arr) { + const len = arr.length + let increment = Math.floor(len / 2) + while (increment !== 0) { + for (let i = increment; i < len; i++) { + const temp = arr[i] + for (let j = i - increment; j >= 0 && temp < arr[j]; j -= increment) { + arr[j + increment] = arr[j] + } + arr[i + increment] = temp + } + increment = Math.floor(increment / 2) + } + return arr +} + + +console.log('简化shellSortBetter希尔排序前：', dealArr) +const sortResultBetter = shellSortBetter(dealArr) +console.log('简化shellSortBetter希尔排序后：', sortResultBetter) diff --git a/code/ds/js版本/StraightInsertSort.js b/code/ds/js版本/StraightInsertSort.js new file mode 100644 index 0000000..d99b507 --- /dev/null +++ b/code/ds/js版本/StraightInsertSort.js @@ -0,0 +1,34 @@ +/** + * 直接插入排序【JavaScript版本】 + */ +function straightInsertSort(arr, len) { + // 重新确定数组长度 + len = arr.length === len ? len : arr.length + + // 从第二个元素开始循环，共len-1次 + for (let i = 1; i < len; i++) { + // 后面的额元素比前面的元素小，需要把前面大于哨兵元素有序序列，移动后面一位 + if (arr[i] < arr[i - 1]) { + let j + // 哨兵元素 + const temp = arr[i] + for (j = i - 1; arr[j] > temp; --j) { + // 后移 + arr[j + 1] = arr[j] + } + // 跳出循环逻辑，出现arr[j] > arr[j-1] + // 哨兵即待排序的 + arr[j + 1] = temp + } + } + + return arr +} + +const dealArr = [5, 2, 7, 3, 18, 8, 12, 1] +console.log('插入排序前：', dealArr) +const sortResult = straightInsertSort(dealArr, 7) + +console.log('插入排序后：', sortResult) + + diff --git a/code/ds/ts版本/BinaryInsertSort.ts b/code/ds/ts版本/BinaryInsertSort.ts new file mode 100644 index 0000000..8c5a623 --- /dev/null +++ b/code/ds/ts版本/BinaryInsertSort.ts @@ -0,0 +1,44 @@ +/** + * 折半插入排序【JavaScript版本】 + */ +function binaryInsertSort(arr, len) { + // 数组长度校验【非必须】 + len = arr.length === len + ? len + : arr.length + + // 遍历 + for (let i = 1; i < len; i++) { + const temp = arr[i] + let lowIndex = 0 + let highIndex = i - 1 + + while (lowIndex <= highIndex) { + // 注意：取整,javascript这里取整，会出现空指针 + const mid = Math.ceil((lowIndex + highIndex) / 2) + + if (arr[mid] <= temp) { + // 右侧 + lowIndex = mid + 1 + } else { + // 左侧 + highIndex = mid - 1 + } + } + // 元素后移 + for (let j = i - 1; j > highIndex; --j) { + arr[j + 1] = arr[j] + } + arr[highIndex + 1] = temp + } + // 返回经过折半插入排序处理的有序数组 + return arr +} + + +// 测试用例 +const dealArr = [5, 2, 7, 3, 18, 8, 12, 1] +console.log('插入排序前：', dealArr) +const sortResult = binaryInsertSort(dealArr, 7) +console.log('插入排序后：', sortResult) + diff --git a/code/ds/ts版本/BubbleSort.ts b/code/ds/ts版本/BubbleSort.ts new file mode 100644 index 0000000..b026dc6 --- /dev/null +++ b/code/ds/ts版本/BubbleSort.ts @@ -0,0 +1,47 @@ +/** + * 排序算法：冒泡排序 + * 给定一个数组，按照从小到大或从大到小排序，打印排序前后结果对比 + * 编程语言：TypeScript + */ +function BubbleSort(arr:Array):number[] { + // 获取数组长度 + const len = arr.length + + // 冒泡排序，让数组arr有序 + for (let i = 0; i < len - 1; i++) { + let isSorted = false + + // len个数组，进行len-1趟，即：一趟冒泡 + for (let j = len - 1; j > i; j--) { + // 注意：这里的for循环倒序是有讲究的，想象一下泡泡不都是网上升的么.... + if (arr[j - 1] > arr[j]) { + // 交换元素，始终让最小的元素往上走（冒泡） + const temp = arr[j - 1] + arr[j - 1] = arr[j] + arr[j] = temp + + // 需要冒泡 + isSorted = true + } + } + // 第一趟比较后，如果本身序列是有序的，就直接跳出循环 + if (isSorted === false) { + break + } + } + + return arr +} + +/** + * 将两个变量数值交换 + */ +function switchValue(params:{ a: number, b: number }):{a:number, b:number} { + const { a: newB, b: newA } = params + return { a: newA, b: newB } +} + +const initArr = [1, 5, 8, 3, 2, 9, 16] +console.log(`冒泡排序前：${initArr}`) +const sortedArr = BubbleSort(initArr) +console.log(`冒泡排序后：${sortedArr}`) diff --git a/code/ds/ts版本/QuickSort.ts b/code/ds/ts版本/QuickSort.ts new file mode 100644 index 0000000..ea9192b --- /dev/null +++ b/code/ds/ts版本/QuickSort.ts @@ -0,0 +1,54 @@ +/** + * 基于分治法思想，将数组进行快速排序 + * @param {Array} arr 待排序的数组 + * @param {int} low 数组低位角标 左指针 + * @param {int} high 数组高位角标 右指针 + */ +function QuickSort(arr, low, high) { + // low=high 说明只有一个元素，理解为有序，不做处理 + // low>high 说明左、右指针已经重合，数组已经遍历完，需要跳出 + if (low < high) { + const pivotIndex = Partition(arr, low, high) + // 处理左侧 + QuickSort(arr, low, pivotIndex - 1) + // 处理右侧 + QuickSort(arr, pivotIndex + 1, high) + } + + // 经过快排处理的数组 + return arr +} + + +/** + * + * 寻找数组中的基准pivot，使得左侧元素全部小于等于pivot，右侧元素全部大于等于pivot + * @param {Array} arr 分治思想处理后的数组 + * @param {int} low 数组低位角标 左指针 + * @param {int} high 数组高位角标 右指针 + */ +function Partition(arr, low, high) { + // 假设低位指针对应数组角标元素为基准pivot + const pivot = arr[low] + while (low < high) { + // 从右往左直到比pivot小跳出循环 + while (low < high && arr[high] >= pivot) --high + arr[low] = arr[high] + + // 从左往右直到比pivot大跳出循环 + while (low < high && arr[low] <= pivot) ++low + arr[high] = arr[low] + } + + // 基准值移到最终的位置，此时左侧小于等于pivot 右侧大于等于pivot + arr[low] = pivot + + // 返回基准值的角标 + return low +} + + +const initArr = [2, 18, 6, 25, 19, 4, 8, 3, 7] +console.log(`快速排序处理前：${initArr}`) +const quickSortResult = QuickSort(initArr, 0, 8) +console.log(`快速排序处理后：${quickSortResult}`) diff --git a/code/ds/ts版本/ShellSort.ts b/code/ds/ts版本/ShellSort.ts new file mode 100644 index 0000000..5396b87 --- /dev/null +++ b/code/ds/ts版本/ShellSort.ts @@ -0,0 +1,83 @@ +/** + * 数组的希尔排序 + * - 返回已排序的数组，从小到大 + * @param {Array} arr 待排序数组 + * @param {int} len 数组长度，可校验 + * @returns + */ +function shellSort(arr, len) { + // 校对数组长度 + len = arr.length === len ? len : arr.length + + // 注意处理浮点【向上取整】 防止空指针 + for (let increment = Math.floor(len / 2); increment >= 1; increment = Math.floor(increment / 2)) { + // 对每组数据，进行直接排序 + for (let groupIndex = 0; groupIndex < increment; ++groupIndex) { + specialStraightInsertSort(arr, len, increment, groupIndex) + } + } + + return arr +} + +/** + * 根据希尔排序的步长对分组进行直接插入排序处理 + * @param {Array} arr 排序数组 + * @param {int} len 数组长度 + * @param {int} increment 增量步长 + * @param {int} groupIndex 分组，第几个分组 + */ +function specialStraightInsertSort(arr, len, increment, groupIndex) { + len = arr.length === len ? len : arr.length + console.log(`数组长度：${len}----->当前步长：${increment}---->分组：${groupIndex}`) + + for (let eleStartIndex = groupIndex + increment; eleStartIndex < len; eleStartIndex += increment) { + // 此时eleStartIndex为直接插入排序的比较元素 + + + // 直接插入排序中的哨兵元素【重要】 + const temp = arr[eleStartIndex] + let j + // 向前比较 从小到大 + for (j = eleStartIndex - increment; j >= 0 && arr[j] > temp; j -= increment) { + arr[j + increment] = arr[j] + } + arr[j + increment] = temp + } + + console.log('specialStraightInsertSort处理后：', arr) + return arr +} + + +const dealArr = [5, 8, 2, 16, 3, 9, 1] +console.log('插入排序前：', dealArr) +const sortResult = shellSort(dealArr, 7) +console.log('插入排序后：', sortResult) + + +/** + * 简化的希尔排序 + * - 返回已排序号的数组，从小到大 + * @param {Array} arr + */ +function shellSortBetter(arr) { + const len = arr.length + let increment = Math.floor(len / 2) + while (increment !== 0) { + for (let i = increment; i < len; i++) { + const temp = arr[i] + for (let j = i - increment; j >= 0 && temp < arr[j]; j -= increment) { + arr[j + increment] = arr[j] + } + arr[i + increment] = temp + } + increment = Math.floor(increment / 2) + } + return arr +} + + +console.log('简化shellSortBetter希尔排序前：', dealArr) +const sortResultBetter = shellSortBetter(dealArr) +console.log('简化shellSortBetter希尔排序后：', sortResultBetter) diff --git a/code/ds/ts版本/StraightInsertSort.ts b/code/ds/ts版本/StraightInsertSort.ts new file mode 100644 index 0000000..d99b507 --- /dev/null +++ b/code/ds/ts版本/StraightInsertSort.ts @@ -0,0 +1,34 @@ +/** + * 直接插入排序【JavaScript版本】 + */ +function straightInsertSort(arr, len) { + // 重新确定数组长度 + len = arr.length === len ? len : arr.length + + // 从第二个元素开始循环，共len-1次 + for (let i = 1; i < len; i++) { + // 后面的额元素比前面的元素小，需要把前面大于哨兵元素有序序列，移动后面一位 + if (arr[i] < arr[i - 1]) { + let j + // 哨兵元素 + const temp = arr[i] + for (j = i - 1; arr[j] > temp; --j) { + // 后移 + arr[j + 1] = arr[j] + } + // 跳出循环逻辑，出现arr[j] > arr[j-1] + // 哨兵即待排序的 + arr[j + 1] = temp + } + } + + return arr +} + +const dealArr = [5, 2, 7, 3, 18, 8, 12, 1] +console.log('插入排序前：', dealArr) +const sortResult = straightInsertSort(dealArr, 7) + +console.log('插入排序后：', sortResult) + + diff --git a/docker-compose.yaml b/docker-compose.yaml index 20f7179..ca31c08 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -1,6 +1,8 @@ +### +### 408CSFamily服务，ip范围 172.30.0.100 +### version: '2' services: - ### 408CSFamily服务，ip范围 172.30.0.200 408CSFamily: image: registry.cn-hangzhou.aliyuncs.com/142vip/doc_book:408CSFamily-0.0.1 container_name: 408CSFamily diff --git a/docs/.vuepress/public/mark-map/ccp-map.html b/docs/.vuepress/public/mark-map/ccp-map.html index 514f3a0..709e414 100644 --- a/docs/.vuepress/public/mark-map/ccp-map.html +++ b/docs/.vuepress/public/mark-map/ccp-map.html @@ -16,11 +16,11 @@ height: 100vh; } - + - + })(() => window.markmap,null,{"type":"heading","depth":0,"payload":{"lines":[1,2]},"content":"计算机组成原理","children":[{"type":"fence","depth":1,"content":"
root(计算机组成原理)\n    (引论)\n    (数据的表示和运算)\n    (储存系统)\n    (指令系统)\n    (中央处理器)\n    (总线)\n    (输入输出系统)\n
\n","children":[],"payload":{"lines":[3,13]}},{"type":"heading","depth":1,"payload":{"lines":[16,17]},"content":"引论","children":[]},{"type":"heading","depth":1,"payload":{"lines":[18,19]},"content":"数据的表示和运算","children":[]},{"type":"heading","depth":1,"payload":{"lines":[20,21]},"content":"存储系统","children":[]},{"type":"heading","depth":1,"payload":{"lines":[22,23]},"content":"指令系统","children":[]},{"type":"heading","depth":1,"payload":{"lines":[24,25]},"content":"中央处理器","children":[]},{"type":"heading","depth":1,"payload":{"lines":[26,27]},"content":"总线","children":[]},{"type":"heading","depth":1,"payload":{"lines":[28,29]},"content":"输入输出系统","children":[]},{"type":"heading","depth":1,"payload":{"lines":[30,31]},"content":"一些总结","children":[]}]},null) diff --git a/docs/.vuepress/public/mark-map/cn-map.html b/docs/.vuepress/public/mark-map/cn-map.html index e928b0b..df8d4eb 100644 --- a/docs/.vuepress/public/mark-map/cn-map.html +++ b/docs/.vuepress/public/mark-map/cn-map.html @@ -16,11 +16,11 @@ height: 100vh; } - + - + })(() => window.markmap,null,{"type":"heading","depth":0,"payload":{"lines":[1,2]},"content":"计算机网络","children":[{"type":"fence","depth":1,"content":"
root(计算机网络)\n    (体系机构)\n    (物理层)\n    (数据链路层)\n    (网络层)\n    (传输层)\n    (应用层)\n
\n","children":[],"payload":{"lines":[3,12]}},{"type":"heading","depth":1,"payload":{"lines":[15,16]},"content":"体系结构","children":[]},{"type":"heading","depth":1,"payload":{"lines":[17,18]},"content":"物理层","children":[]},{"type":"heading","depth":1,"payload":{"lines":[19,20]},"content":"数据链路层","children":[]},{"type":"heading","depth":1,"payload":{"lines":[21,22]},"content":"网络层","children":[]},{"type":"heading","depth":1,"payload":{"lines":[23,24]},"content":"传输层","children":[]},{"type":"heading","depth":1,"payload":{"lines":[25,26]},"content":"应用层","children":[]},{"type":"heading","depth":1,"payload":{"lines":[27,28]},"content":"一些总结","children":[]}]},null) diff --git a/docs/.vuepress/public/mark-map/ds-map.html b/docs/.vuepress/public/mark-map/ds-map.html index 19f6b2c..9ca3506 100644 --- a/docs/.vuepress/public/mark-map/ds-map.html +++ b/docs/.vuepress/public/mark-map/ds-map.html @@ -16,11 +16,11 @@ height: 100vh; } - + - + })(() => window.markmap,null,{"type":"heading","depth":0,"payload":{"lines":[1,2]},"content":"数据结构","children":[{"type":"fence","depth":1,"content":"
root(数据结构)\n    (基础入门)\n    (线性表)\n    (栈和队列)\n    (队列)\n    (串)\n    (树与二叉树)\n    (图论)\n    (查找)\n    (排序)\n
\n","children":[],"payload":{"lines":[3,15]}},{"type":"heading","depth":1,"payload":{"lines":[18,19]},"content":"基础入门","children":[{"type":"heading","depth":2,"payload":{"lines":[20,21]},"content":"基本概念","children":[{"type":"list_item","depth":3,"payload":{"lines":[22,23]},"content":"数据","children":[{"type":"list_item","depth":4,"payload":{"lines":[24,25]},"content":"信息的载体","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[25,26]},"content":"客观事物属性的数、字符以及所有能够输入到计算机包中并且被计算机程序识别和处理的集合","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[27,28]},"content":"数据元素","children":[{"type":"list_item","depth":4,"payload":{"lines":[29,30]},"content":"数据的基本单位","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[30,31]},"content":"一个数据元素由若干个数据项组成","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[31,32]},"content":"数据项是构成数组元素的最小单位，且不可分割","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[33,34]},"content":"数据对象","children":[{"type":"list_item","depth":4,"payload":{"lines":[35,36]},"content":"具有相同性质的数据元素的集合","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[36,37]},"content":"数据的子集","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[38,39]},"content":"数据类型","children":[{"type":"list_item","depth":4,"payload":{"lines":[40,41]},"content":"原子类型：不可再分的数据类型","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[41,42]},"content":"结构类型：可以分解成若干分量（成分）的数据类型","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[42,43]},"content":"抽象数据类型：抽象出具组织和其相关的操作","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[44,45]},"content":"抽象数据类型（ADT）","children":[{"type":"list_item","depth":4,"payload":{"lines":[46,47]},"content":"定义：一个数学模型以及定义在该模型上的一组操作","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[47,48]},"content":"特点：与计算机内部如何表示和实现是没有关系","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[48,49]},"content":"作用：数据封装和信息隐藏，让实现与使用相分离","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[49,50]},"content":"注意：不论内部结构如何变化，只要其数学特性不变，就不会影响到外部的使用","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[51,52]},"content":"数据结构（三要素）","children":[{"type":"list_item","depth":3,"payload":{"lines":[53,54]},"content":"逻辑结构","children":[{"type":"list_item","depth":4,"payload":{"lines":[55,56]},"content":"线性结构：线性表、栈、队列、串、数组...","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[56,57]},"content":"非线性结构：树、图、集合...","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[57,58]},"content":"集合：除了“同属于一个集合”的关系外，别无其他关系。","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[58,59]},"content":"线性结构：只存在一对一的关系。","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[59,60]},"content":"树形结构：存在一对多的关系。","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[60,61]},"content":"图状结构和网状结构：存在多对多的关系。","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[62,63]},"content":"存储（物理）结构","children":[{"type":"list_item","depth":4,"payload":{"lines":[64,65]},"content":"顺序存储","children":[{"type":"list_item","depth":5,"payload":{"lines":[66,67]},"content":"逻辑上相邻的元素存储在物理位置上也相邻的存储单元里，元素之间的关系由存储单元的邻接关系来体现","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[67,68]},"content":"优点","children":[{"type":"list_item","depth":6,"payload":{"lines":[69,70]},"content":"可以实现随机存取","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[70,71]},"content":"元素占用最少的存储空间","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[72,73]},"content":"缺点","children":[{"type":"list_item","depth":6,"payload":{"lines":[74,75]},"content":"只能使用相邻的一整块存储单元，依赖于物理结构相邻","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[75,76]},"content":"容易产生外部碎片","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[77,78]},"content":"链式存储","children":[{"type":"list_item","depth":5,"payload":{"lines":[79,80]},"content":"与顺序存储不同，链式存储不要求逻辑上相邻的元素在物理位置上也相邻","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[80,81]},"content":"优点","children":[{"type":"list_item","depth":6,"payload":{"lines":[82,83]},"content":"不会出现碎片现象","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[83,84]},"content":"充分利用所有存储单元","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[85,86]},"content":"缺点","children":[{"type":"list_item","depth":6,"payload":{"lines":[87,88]},"content":"除了存储元素外，还需要额外存储指针，会占用额外的存储空间（结合数据库索引学习）","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[88,89]},"content":"链式存储，只能实现顺序存取，不能实现随机存取（指针的遍历）","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[90,91]},"content":"索引存储","children":[{"type":"list_item","depth":5,"payload":{"lines":[92,93]},"content":"存放数据元素和元素间关系的存储方式，在存储元素信息的同时，还需要建立附加的索引表","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[93,94]},"content":"优点","children":[{"type":"list_item","depth":6,"payload":{"lines":[95,96]},"content":"检索快（就好比字典有了目录，查询就很快了）","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[97,98]},"content":"缺点","children":[{"type":"list_item","depth":6,"payload":{"lines":[99,100]},"content":"增加了索引表，占用较多的存储空间（典型的空间换时间策略）","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[100,101]},"content":"增加、删除数据时，需要对应修改索引表，花费更多时间","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[102,103]},"content":"散列（Hash）存储","children":[{"type":"list_item","depth":5,"payload":{"lines":[104,105]},"content":"根据元素的关键字直接通过散列（Hash）函数计算出元素的存储地址。","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[105,106]},"content":"优点","children":[{"type":"list_item","depth":6,"payload":{"lines":[107,108]},"content":"检索快","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[108,109]},"content":"添加、删除元素结点操作快（获取元素地址直接，整体时间就少了）","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[110,111]},"content":"缺点","children":[{"type":"list_item","depth":6,"payload":{"lines":[112,113]},"content":"非常依赖于散列函数","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[113,114]},"content":"会出现散列冲突（主要依赖与散列函数，散列函数不好就很容易出现散列冲突）","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[114,115]},"content":"出现散列冲突时，解决冲突就会增加时间和空间上的开销","children":[]}]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[116,117]},"content":"数据的运算","children":[{"type":"list_item","depth":4,"payload":{"lines":[118,119]},"content":"运算的定义：针对逻辑结构，指出运算的功能","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[119,120]},"content":"运算的实现：针对存储结构，指出运算的具体操作步骤","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[121,122]},"content":"算法与算法评价","children":[{"type":"list_item","depth":3,"payload":{"lines":[123,124]},"content":"算法","children":[{"type":"list_item","depth":4,"payload":{"lines":[125,126]},"content":"定义","children":[{"type":"list_item","depth":5,"payload":{"lines":[127,128]},"content":"对特定问题求解步骤的一种描述","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[128,129]},"content":"是指令的有序集合","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[129,130]},"content":"每一条指令表示一个或多个操作","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[131,132]},"content":"五大特性","children":[{"type":"list_item","depth":5,"payload":{"lines":[133,134]},"content":"有穷性：执行有穷步后结束、在有穷时间内完成","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[134,135]},"content":"确定性：每条指令的含义明确，不会产生二义性，对相同的输入只能得出相同的结果","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[135,136]},"content":"可行性：算法中描述的操作都是可以通过已经实现的基本运算执行有限次来实现的","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[136,137]},"content":"输入：有零个或者多个输入，输入取决于某个特定的对象的集合","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[137,138]},"content":"输出：有一个或者多个输出，输出是和输入有着某种特定关系的量","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[139,140]},"content":"好算法追求的目标","children":[{"type":"list_item","depth":5,"payload":{"lines":[141,142]},"content":"正确性：需要正确的解决求解问题","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[142,143]},"content":"可读性：便于理解","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[143,144]},"content":"健壮性：在输入非法数据时，算法也能适当地做出反应或进行处理，而不会产生莫名奇妙的输出结果","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[144,145]},"content":"效率与低存储量需求","children":[{"type":"list_item","depth":6,"payload":{"lines":[146,147]},"content":"效率：算法执行的时间--->时间复杂度","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[147,148]},"content":"存储量需求：算法那执行过程中所有要的最大存储空间--->空间复杂度","children":[]}]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[149,150]},"content":"算法的评价","children":[{"type":"list_item","depth":4,"payload":{"lines":[151,152]},"content":"程序语句频度：程序语句在算法中被重复执行的次数","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[152,153]},"content":"时间复杂度O(n)","children":[{"type":"list_item","depth":5,"payload":{"lines":[154,155]},"content":"最坏空间复杂度：最坏情况下，算法的时间复杂度","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[155,156]},"content":"平均空间复杂度：所有可能输入实例在同等概率出现的情况下，算法的期望运行时间","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[156,157]},"content":"最好空间复杂度：最好的情况下，算法的时间复杂度","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[158,159]},"content":"空间复杂度S(n)","children":[{"type":"list_item","depth":5,"payload":{"lines":[160,161]},"content":"用来定义算法运行过程中需要耗费的存储空间","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[161,163]},"content":"渐进空间复杂度也被称为空间复杂度
\n记作：S(n)=O(g(n))","children":[]}]}]}]}]},{"type":"heading","depth":1,"payload":{"lines":[164,165]},"content":"线性表","children":[{"type":"heading","depth":2,"payload":{"lines":[166,167]},"content":"定义和基本操作","children":[{"type":"list_item","depth":3,"payload":{"lines":[168,169]},"content":"基本概念","children":[{"type":"list_item","depth":4,"payload":{"lines":[170,171]},"content":"定义：线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[171,172]},"content":"逻辑特性","children":[{"type":"list_item","depth":5,"payload":{"lines":[173,174]},"content":"除表头元素外，线性表中每个元素有且仅有一个","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[174,175]},"content":"除表尾元素外，线性表中每个元素有且仅有一个直接后继","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[176,177]},"content":"基本特点","children":[{"type":"list_item","depth":5,"payload":{"lines":[178,179]},"content":"元素个数有限","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[179,180]},"content":"逻辑上具有顺序性","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[180,181]},"content":"每个元素都是单个元素","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[181,182]},"content":"数据类型都相同，元素存储空间大小一致","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[182,183]},"content":"元素具有抽象性，只讨论逻辑关系","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[184,185]},"content":"基本操作","children":[{"type":"list_item","depth":4,"payload":{"lines":[186,187]},"content":"InitList(&L)： 初始化表。构造空的线性表","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[187,188]},"content":"Length(L)：获取表的长度。返回线性表L的长度，即表中的数据元素个数","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[188,189]},"content":"LocateElem(L,e)：按值查找操作。在表L中国查找具有给定关键字的元素","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[189,190]},"content":"GetElem(L,i)：按位查找操作。获取表中第i个位置的元素的值","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[190,191]},"content":"ListInsert(&L,i,e)：插入操作。在表的第i个位置上插入指定元素e","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[191,192]},"content":"ListDelete(&L,i,&e)：删除操作。删除表中第i个位置的元素，并用e返回删除元素的值","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[192,193]},"content":"PrintList(L)：输出操作。按照前后顺序（如：1、2....n）输出线性表的所有元素值","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[193,194]},"content":"Empty(L)：判空操作。当表L为空，则返回true，否则返回false","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[194,195]},"content":"DestoryList(&L)：销毁操作。将线性表销毁，释放线性表L所占用的内存空间","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[196,197]},"content":"顺序表示","children":[{"type":"list_item","depth":3,"payload":{"lines":[198,199]},"content":"基础概念","children":[{"type":"list_item","depth":4,"payload":{"lines":[200,201]},"content":"定义","children":[{"type":"list_item","depth":5,"payload":{"lines":[202,203]},"content":"顺序表：顺序存储的线性表","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[203,204]},"content":"顺序表中的元素的逻辑顺序与实际的物理位置相同","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[204,205]},"content":"线性表中的元素的位序是从1开始的，数组中的元素的下标是从0开始的","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[206,207]},"content":"存储分配","children":[{"type":"list_item","depth":5,"payload":{"lines":[208,209]},"content":"静态分配：数组的大小和空间都是实现确定好的，一旦存储空间占满就会产生溢出，直接导致程序崩溃","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[209,210]},"content":"动态分配：存储数据的空间在程序执行过程中通过动态存储分配语句分配的，即便是数据空间占满，也可以另外开辟一块更大的空间，来替换原来的存储空间","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[210,211]},"content":"malloc()函数： 指针型函数，返回的指针指向该分配域的开头的位置。作用是在内存的动态存储区中分配一个长度为size的连续空间","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[211,212]},"content":"动态分配不是链式存储，而是属于顺序存储结构，动态分配的物理结构没有改变，依然是随机存取的方式。只是分配的空间大小可以在运行时决定","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[213,214]},"content":"重要特点","children":[{"type":"list_item","depth":5,"payload":{"lines":[215,216]},"content":"随机访问【重要】","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[216,217]},"content":"存储密度高","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[217,218]},"content":"逻辑上相邻的元素物理上也相邻","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[219,220]},"content":"基本操作","children":[{"type":"list_item","depth":4,"payload":{"lines":[221,222]},"content":"插入元素","children":[{"type":"list_item","depth":5,"payload":{"lines":[223,224]},"content":"在顺序表L的第i（1≤i≤L.length+1）个位置插入新元素，成功返回true,失败返回false","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[224,225]},"content":"时间复杂度","children":[{"type":"list_item","depth":6,"payload":{"lines":[226,227]},"content":"最好情况：在表尾插入，元素向后移动循环没有执行，时间复杂度O(1);","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[227,228]},"content":"最坏情况：在表头插入，元素后移循环执行n次，时间复杂度为O(n);","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[228,229]},"content":"平均情况：随机插入，平均次数为：n/2，对应的平均复杂度为O(n);","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[230,231]},"content":"平均时间复杂度为：O(n)","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[232,233]},"content":"删除元素","children":[{"type":"list_item","depth":5,"payload":{"lines":[234,235]},"content":"删除顺序表L中第i（1≤i≤L.length+1）个位置的元素。成功则返回true,将被删除的元素用引用变量返回，失败则返回false","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[235,236]},"content":"时间复杂度","children":[{"type":"list_item","depth":6,"payload":{"lines":[237,238]},"content":"最好情况：删除表尾元素，不需要移动任何元素，时间复杂度为O(1)；","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[238,239]},"content":"最坏情况：删除表头元素，需要移动除第一个元素外的所有元素，时间复杂度为O(n)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[239,240]},"content":"平均情况：随机删除，平均需要(n-1)/2，对应的时间复杂度为O(n)","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[241,242]},"content":"平均时间复杂度为O(n)","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[243,244]},"content":"按值查找（顺序查找）","children":[{"type":"list_item","depth":5,"payload":{"lines":[245,246]},"content":"在顺序表L中查找第一个元素值等于e的元素查找成功返回该元素位序（不是角标），查找失败返回0","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[246,247]},"content":"位序（个人理解）：元素在线性表中的位置序号，角标为i（角标从0开始）,对应的位序为i+1（位序从1开始）。当返回为0时，则直接代表没有命中","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[247,248]},"content":"时间复杂度","children":[{"type":"list_item","depth":6,"payload":{"lines":[249,250]},"content":"最好情况：查找的元素在表头，只需要比较一次，循环成本最小，时间复杂度为O(1);","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[250,251]},"content":"最坏情况：查找的元素在表尾或者不存在，需要完整遍历，比较n次，时间复杂度为O(n);","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[251,252]},"content":"平均情况：随机查找表上的第i个（1≤i≤L.length）元素,平均次数为(n+1)/2,对应时间复杂度为O(n)","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[253,254]},"content":"平均时间复杂度为O(n)","children":[]}]}]}]},{"type":"heading","depth":2,"payload":{"lines":[255,256]},"content":"链式表示","children":[{"type":"list_item","depth":3,"payload":{"lines":[257,258]},"content":"基础理解","children":[{"type":"list_item","depth":4,"payload":{"lines":[259,260]},"content":"链式存储线性表时，不需要使用连续的存储单元，不要求逻辑上相邻的两个元素在物理位置上也相邻","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[260,261]},"content":"链式存储线性表时，对线性表的插入、删除元素是不需要移动元素的，只是需要修改指针","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[261,262]},"content":"理解“链”的含义，链条--->捆绑、指向------>指针","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[263,264]},"content":"单链表","children":[{"type":"list_item","depth":4,"payload":{"lines":[265,266]},"content":"定义：线性表的链式存储称作单链表，通过一组任意的存储单元来存储线性表中的数据元素。","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[266,267]},"content":"每个链表结点（node）除了存放元素自身的信息外，还需要存放一个指向其后继结点的指针。通过指针建立起链表元素之间的线性关系","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[267,268]},"content":"单链表可以解决顺序表需要大量连续存储空间的缺点，但是单链表在数据域的基础上附加了指针域，存在浪费存储空间的缺点","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[268,269]},"content":"单链表的元素是离散地分布在存储空间中的，不能直接找到表中特定的结点，需要从头开始遍历、一次查找【单链表是非随机存取的存储结构】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[269,270]},"content":"头结点相关","children":[{"type":"list_item","depth":5,"payload":{"lines":[271,272]},"content":"定义：为了操作上的方便，在单链表第一个结点之前附加一个结点，叫做头结点。","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[272,273]},"content":"基本特点","children":[{"type":"list_item","depth":6,"payload":{"lines":[274,275]},"content":"不论单链表是否带头结点【可选】，头指针始终指向链表的第一个结点","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[275,276]},"content":"头结点的指针域指向线性表的第一个元素结点","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[276,277]},"content":"头结点的数据域可以不存任何信息、也可以记录表长等基础信息","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[277,278]},"content":"头结点是带头结点的链表中的第一个结点","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[279,280]},"content":"优点","children":[{"type":"list_item","depth":6,"payload":{"lines":[281,282]},"content":"因为开始结点的位置被存放在头结点的指针域中，所以在链表的第一个位置上的操作和在表的其他位置上的操作一致，不需要进行特殊处理","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[282,283]},"content":"无论链表是否为空，头指针始终是指向头结点的头结点的非空指针","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[283,284]},"content":"头结点的引入，很好的统一了空表和非空表的操作，有效避免头指针空指针异常问题","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[285,286]},"content":"基本操作","children":[{"type":"list_item","depth":5,"payload":{"lines":[287,288]},"content":"链表创建","children":[{"type":"list_item","depth":6,"payload":{"lines":[289,290]},"content":"头插法","children":[{"type":"list_item","depth":7,"payload":{"lines":[291,292]},"content":"定义：从空表开始，生成新的结点，将读取的数据存放在新结点的数据域中，将新结点插入到当前链表的表头【头结点之后】","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[292,293]},"content":"读入数据的顺序与生成的链表中的元素顺序是相反的","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[293,294]},"content":"每个结点插入的时间复杂度为O(1),单链表长度为n时，头插法的时间复杂度为O(n)","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[295,296]},"content":"尾插法","children":[{"type":"list_item","depth":7,"payload":{"lines":[297,298]},"content":"定义：新结点插入到当前链表的表尾上，必须增加一个尾指针r,始终指向当前链表的尾结点","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[298,299]},"content":"读入数据的顺序与生成的链表中的元素顺序完全一致","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[299,300]},"content":"每个结点插入的时间复杂度为O(1),单链表长度为n时，尾巴插法的时间复杂度为O(n)","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[300,301]},"content":"相比头插法附设了一个指向表尾结点的指针，但时间复杂度与头插法相同","children":[]}]}]},{"type":"list_item","depth":5,"payload":{"lines":[302,303]},"content":"按序号查找","children":[{"type":"list_item","depth":6,"payload":{"lines":[304,305]},"content":"定义：在单链表中从第一个结点出发，顺指针next域逐个往下搜索、遍历，直到找出第i个结点为止，否则返回最后一个结点指针域NULL","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[305,306]},"content":"时间复杂度为：O(n)","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[307,308]},"content":"按值查找","children":[{"type":"list_item","depth":6,"payload":{"lines":[309,310]},"content":"定义：从单链表的第一个结点开始，从前往后依次比较表中个结点数据域的值，等于给定值e，则返回该结点的指针；若整个单链表【遍历完】中没有数据域值为e的结点，则返回NULL；","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[310,311]},"content":"时间复杂度为：O(n)","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[312,313]},"content":"插入结点","children":[{"type":"list_item","depth":6,"payload":{"lines":[314,315]},"content":"定义：单链表中，将值为x的新结点插入到单链表的第i个位置上","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[315,316]},"content":"基本步骤","children":[{"type":"list_item","depth":7,"payload":{"lines":[317,318]},"content":"第一步： 检查插入位置的合法性；","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[318,319]},"content":"第二步： 找到待插入位置的前驱结点，即第（i-1）个结点；","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[319,320]},"content":"第三部： 在前驱结点后插入新结点；","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[320,321]},"content":"过程不能更换，避免后继指针不存在的问题","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[322,323]},"content":"时间复杂度","children":[{"type":"list_item","depth":7,"payload":{"lines":[324,325]},"content":"插入结点的时间复杂度集中在查找第(i-1)个元素，时间复杂度为O(n)","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[325,326]},"content":"如果在给定结点的后面插入新结点，只需要执行p->next=s操作，时间复杂度为O(1)","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[327,328]},"content":"前插操作：在某结点的前面插入一个新的结点","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[328,329]},"content":"后插操作：在某结点的后面插入一个新的结点，单链表插入算法中，通常采用后插操作的","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[329,330]},"content":"对结点的前插操作都可以转化为后插操作，前提：需要从单链表的头结点开始顺序查找到其前驱结点；时间复杂度为O(n)。","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[331,332]},"content":"删除结点","children":[{"type":"list_item","depth":6,"payload":{"lines":[333,334]},"content":"定义：将单链表L的第i个结点元素删除；","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[334,335]},"content":"基本步骤","children":[{"type":"list_item","depth":7,"payload":{"lines":[336,337]},"content":"第一步： 先检查删除位置的合法性；","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[337,338]},"content":"第二步： 查找表中的第（i-1）个结点，即被删结点的前驱结点；","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[338,339]},"content":"第三步： 移动指针，删除结点元素；","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[340,341]},"content":"和插入算法一样，时间都消耗在查询前驱结点上，时间复杂度为：O(n)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[341,342]},"content":"利用p结点的后继结点将p结点删除【经典思路】","children":[{"type":"list_item","depth":7,"payload":{"lines":[343,344]},"content":"第一步：申请结点q，使其只想p结点的后继结点；","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[344,345]},"content":"第二步：将p结点的数据域值换成其后继结点的数据域；【注意，交换没什么意义，最终p的后继结点会删除、释放】","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[345,346]},"content":"第三步：p的指针域指向q的指针域，q结点从链中“断开”","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[346,347]},"content":"第四步：释放q的内存空间","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[347,348]},"content":"相比按值查找前驱结点来删除给定的结点p，利用后继结点来删除的时间复杂度更小，为：O(1)","children":[]}]}]},{"type":"list_item","depth":5,"payload":{"lines":[349,350]},"content":"计算表长(遍历)","children":[{"type":"list_item","depth":6,"payload":{"lines":[351,352]},"content":"定义：计算单链表中数据结点（不含头结点）的个数","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[352,353]},"content":"算法思路：从第一个结点开始顺序依次访问表中的每一个结点，为此需要设置一个计数器变量，每访问一个结点，计算器加1，直到访问到空结点为止。","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[353,354]},"content":"时间复杂度：O(n)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[354,355]},"content":"判空条件","children":[{"type":"list_item","depth":7,"payload":{"lines":[356,357]},"content":"不带头结点的单链表L为空,判定条件是L=NULL。","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[357,358]},"content":"带头结点的单链表L为空，判空条件：L->next=NULL","children":[]}]}]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[359,360]},"content":"双链表","children":[{"type":"list_item","depth":4,"payload":{"lines":[361,362]},"content":"定义：在单链表的结点中增加了一个指向结点前驱的prior指针，由prior指针域、data数据域、next指针域三部分组成。","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[362,363]},"content":"基本特点","children":[{"type":"list_item","depth":5,"payload":{"lines":[364,365]},"content":"双链表仅仅在单链表的结点中增加了一个指向结点前驱的prior指针","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[365,366]},"content":"按值查找、按序号查找在单链表和双链表上的操作是相同的","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[366,367]},"content":"和单链表不同，插入、删除操作除了修改next指针域，双链表还需要修改prior指针域，确保不断链【重要】","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[368,369]},"content":"基本操作","children":[{"type":"list_item","depth":5,"payload":{"lines":[370,371]},"content":"插入结点","children":[{"type":"list_item","depth":6,"payload":{"lines":[372,373]},"content":"第一步：s->next=p->next","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[373,374]},"content":"第二步：p->next-prior=s","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[374,375]},"content":"第三步：s->prior=p","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[375,376]},"content":"第四步：p->next=s","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[376,377]},"content":"时间复杂度：O(1)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[377,378]},"content":"注意：结点p和s的前驱、后继指针要关联清楚，第一二步必须在第四步之前完成【重要】","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[379,380]},"content":"删除结点","children":[{"type":"list_item","depth":6,"payload":{"lines":[381,382]},"content":"第一步：p->next=q->next","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[382,383]},"content":"第二步：q->next->prior=p","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[383,384]},"content":"第三步：free(q) 释放结点内存空间","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[384,385]},"content":"时间复杂度：O(1)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[385,386]},"content":"注意：删除双链表结点p的后继结点的第一二步，顺序可换，及时释放内存空间【重要】","children":[]}]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[387,388]},"content":"循环链表","children":[{"type":"list_item","depth":4,"payload":{"lines":[389,390]},"content":"循环单链表","children":[{"type":"list_item","depth":5,"payload":{"lines":[391,392]},"content":"定义：在单链表的基础上，将最后一个结点（尾结点）的指针由NULL改为指向头结点，形成环。【单链表----->循环单链表】","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[392,393]},"content":"判断条件","children":[{"type":"list_item","depth":6,"payload":{"lines":[394,395]},"content":"不是判断头结点的指针是否为空，而是需要判断是否等于头指针","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[395,396]},"content":"表为空时，头结点的next指针域其实是指向自己","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[396,397]},"content":"结点的next指针指向自己，也就能判断表为空","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[398,399]},"content":"基本特点","children":[{"type":"list_item","depth":6,"payload":{"lines":[400,401]},"content":"在循环单链表中，尾结点*p的next指针域指向链表L（即：头结点），形成了闭环,不存在指针域为NULL的结点","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[401,402]},"content":"由于循环单链表是个环,在任何位置上的插入、删除操作都是等价的，不需要去判断是否是表尾","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[402,403]},"content":"单链表只能从头结点（表头结点）开始往后顺序遍历整个表，循环单链表可以从表中任意位置开始遍历整个链表，结点是等价的","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[403,404]},"content":"循环单链表可以抽象为时钟，形成的环是有顺序的","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[404,405]},"content":"频繁的表头和表尾操作，可以对循环单链表设置尾指针，而不设置头指针，明确尾指针r后，头指针即为：r->next ，减少头指针到尾指针间的遍历，时间复杂度:O(n)---->O(1)","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[406,407]},"content":"循环双链表","children":[{"type":"list_item","depth":5,"payload":{"lines":[408,409]},"content":"定义：在双链表的基础上，将尾结点的next指针指向头结点，将头结点的prior指针指向尾结点。【双链表----->循环双链表】","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[409,410]},"content":"判空条件","children":[{"type":"list_item","depth":6,"payload":{"lines":[411,412]},"content":"循环双链表为空时，头结点*p的prior指针和next指针都指向L","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[412,413]},"content":"同时满足","children":[{"type":"list_item","depth":7,"payload":{"lines":[414,415]},"content":"p->prior=L","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[415,416]},"content":"p->next=L","children":[]}]}]},{"type":"list_item","depth":5,"payload":{"lines":[417,418]},"content":"基本特点：从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[419,420]},"content":"静态链表","children":[{"type":"list_item","depth":4,"payload":{"lines":[421,422]},"content":"定义：借助数组来描述线性表的链式存储结构，结点元素同样存在数据域data和指针域next","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[422,423]},"content":"需要注意","children":[{"type":"list_item","depth":5,"payload":{"lines":[424,425]},"content":"和普通的链表的指针域不同的是，静态链表的指针是结点元素的相对地址(数组下标)，也称为游标，建议结合高级语言中数组的概念来理解；","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[425,426]},"content":"与顺序表一样，虽然静态链表属于链表，但是存储时需要预先分配一块连续的内存空间","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[426,427]},"content":"静态链表是通过数组游标来访问下一个结点元素","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[428,429]},"content":"特点","children":[{"type":"list_item","depth":5,"payload":{"lines":[430,431]},"content":"静态链表以next=-1作为结束的标志【尾结点】","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[431,432]},"content":"和动态链表相同，插入、删除操作不需要移动元素，只需要修改指针；","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[432,433]},"content":"总体来说，静态链表没有单链表使用方便，需要将整个链表存储在一块连续的内存空间中，内部的存储可以分散，通过指针构成链的关系","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[434,435]},"content":"零碎知识补充","children":[{"type":"list_item","depth":4,"payload":{"lines":[436,437]},"content":"无论是链表的插入还是删除操作，必须保证不断链【重要】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[437,438]},"content":"顺序存储结构可以随机存取也能顺序存取，链式结构只能进行顺序存取","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[438,439]},"content":"顺序存储方式同样适合图和树的存储，例如：满二叉树的顺序存储","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[439,440]},"content":"队列需要在表头删除元素，在表尾插入元素【先进先出】，采用带尾指针的循环单链表比较方便","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[440,441]},"content":"静态链表中的指针称为游标，指示下一个元素在数组中的下标","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[441,442]},"content":"静态链表用数组表示，需要预先分配较大的连续空间，同时具有一般链表的特点（插入、删除元素不需要移动元素）","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[442,443]},"content":"单链表设置头结点的","children":[{"type":"list_item","depth":5,"payload":{"lines":[444,445]},"content":"目的：方便运算","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[445,446]},"content":"好处","children":[{"type":"list_item","depth":6,"payload":{"lines":[447,448]},"content":"有头结点后，插入、删除数据元素的算法统一起来了，不需要判断是否在第一个元素之前插入或者删除第一个元素了","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[448,449]},"content":"不论链表是否为空，头指针是指向头结点的非空指针，链表的头指针不变，因此空链表和非空链表的处理也就统一起来了。","children":[]}]}]}]}]},{"type":"heading","depth":2,"payload":{"lines":[450,451]},"content":"顺序表和链表的比较","children":[{"type":"list_item","depth":3,"payload":{"lines":[452,453]},"content":"存取方式","children":[{"type":"list_item","depth":4,"payload":{"lines":[454,455]},"content":"顺序表支持顺序存取和随机存取","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[455,456]},"content":"链表只能从表头顺序存取元素，支持顺序存取","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[457,458]},"content":"逻辑结构与物理结构","children":[{"type":"list_item","depth":4,"payload":{"lines":[459,460]},"content":"顺序存储时，逻辑上相邻的元素，对应的物理存储位置也相邻【一定性】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[460,461]},"content":"链式存储时，逻辑上相邻的元素，对应的物理存储位置不一定相邻【可以相邻，也可以不相邻】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[461,462]},"content":"链式存储的逻辑关系通过指针链接表示","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[463,464]},"content":"时间复杂度","children":[{"type":"list_item","depth":4,"payload":{"lines":[465,466]},"content":"按值查找","children":[{"type":"list_item","depth":5,"payload":{"lines":[467,468]},"content":"顺序表无序的情况下，顺序表和链表的时间复杂度均为O(n)；","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[468,469]},"content":"顺序表有序的情况下，顺序表的时间复杂度为O(log2n),链表为O(n)；","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[470,471]},"content":"按序号查找","children":[{"type":"list_item","depth":5,"payload":{"lines":[472,473]},"content":"顺序表支持随机访问，时间复杂度为O(1)；","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[473,474]},"content":"顺序表不支持随机访问，时间复杂度为O(n)；","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[475,476]},"content":"插入、删除","children":[{"type":"list_item","depth":5,"payload":{"lines":[477,478]},"content":"顺序表平均需要移动半个表长的元素；","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[478,479]},"content":"链表只需要修改相应结点的指针域，不需要移动元素；","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[479,480]},"content":"链表结点除了数据域，还有指针域，在存储空间上比顺序存储需要更大的存储空间，付出更大的存储代价，存储密度不够大","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[481,482]},"content":"空间分配","children":[{"type":"list_item","depth":4,"payload":{"lines":[483,484]},"content":"顺序存储","children":[{"type":"list_item","depth":5,"payload":{"lines":[485,486]},"content":"静态分配","children":[{"type":"list_item","depth":6,"payload":{"lines":[487,488]},"content":"需要预先分配足够大的存储空间","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[488,489]},"content":"空间装满后不能扩充，存储新元素将出现内存溢出","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[489,490]},"content":"存储空间过大，顺序表后部闲置空间过多，造成内部碎片","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[490,491]},"content":"存储空间过小，会造成内存溢出","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[492,493]},"content":"动态分配","children":[{"type":"list_item","depth":6,"payload":{"lines":[494,495]},"content":"能够扩充存储空间","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[495,496]},"content":"需要移动大量元素，操作效率降低","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[496,497]},"content":"内存中没有更大块的连续存储空间，将会导致空间分配失败；","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[498,499]},"content":"链式存储","children":[{"type":"list_item","depth":5,"payload":{"lines":[500,501]},"content":"结点空间只在需要的时候申请分配","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[501,502]},"content":"只要内存由空间就可以分配，操作灵活、高效","children":[]}]}]}]},{"type":"heading","depth":2,"payload":{"lines":[503,504]},"content":"存储结构选取","children":[{"type":"list_item","depth":3,"payload":{"lines":[505,506]},"content":"基于存储的考虑","children":[{"type":"list_item","depth":4,"payload":{"lines":[507,508]},"content":"对线性表的长度和存储规模难以估计时，不宜采用顺序表存储","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[508,509]},"content":"链表不用事先估计存储规模，但存储密度较低","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[509,510]},"content":"链式存储结构的存储密度小于1，不要求连续的存储空间","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[511,512]},"content":"基于运算的考虑","children":[{"type":"list_item","depth":4,"payload":{"lines":[513,514]},"content":"随机存取","children":[{"type":"list_item","depth":5,"payload":{"lines":[515,516]},"content":"顺序表支持随机存取，按序号查找顺序表的时间复杂度为O(1)，相对较好","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[516,517]},"content":"链表不支持随机存取，按序号查找链表的时间复杂度为O(n)","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[518,519]},"content":"插入、删除操作","children":[{"type":"list_item","depth":5,"payload":{"lines":[520,521]},"content":"顺序表的插入、删除操作，平均需要移动表中一半的元素，当表的数据量较大时，这种情况需要重点考虑的","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[521,522]},"content":"链表的插入、删除操作，也是需要找插入位置（前驱结点、后继结点），主要的操作还是比较操作，相对较好","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[523,524]},"content":"基于环境的考虑","children":[{"type":"list_item","depth":4,"payload":{"lines":[525,526]},"content":"顺序表容易实现，任何高级语言中都有数组类型","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[526,527]},"content":"链表操作是基于指针的，指针移动，相对复杂","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[528,529]},"content":"综合结论","children":[{"type":"list_item","depth":4,"payload":{"lines":[530,531]},"content":"通常比较稳定的线性表选择顺序存储","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[531,532]},"content":"频繁进行插入、删除操作的线性表，应该选择链式存储，动态性较强","children":[]}]}]}]},{"type":"heading","depth":1,"payload":{"lines":[533,534]},"content":"栈和队列","children":[{"type":"heading","depth":2,"payload":{"lines":[535,536]},"content":"栈【后进先出】","children":[{"type":"list_item","depth":3,"payload":{"lines":[537,538]},"content":"基础概念","children":[{"type":"list_item","depth":4,"payload":{"lines":[539,540]},"content":"定义： 只允许在一端进行插入或者删除操作的线性表。","children":[{"type":"list_item","depth":5,"payload":{"lines":[541,542]},"content":"后进先出","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[542,543]},"content":"明确栈是一种线性表","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[543,544]},"content":"限定栈只能在某一端进行插入或者删除操作","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[545,546]},"content":"栈顶：线性表允许进行插入和删除的一端","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[546,547]},"content":"栈底：不允许进行插入和删除的另外一端，是固定的","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[547,548]},"content":"空栈：不含任何元素的空表，也叫栈空","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[549,550]},"content":"基本操作","children":[{"type":"list_item","depth":4,"payload":{"lines":[551,552]},"content":"InitStack(&S): 初始化一个空栈S，栈顶指针初始化为-1","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[552,553]},"content":"StackEmpty(S): 判断一个栈是否为空，如果栈空则返回true,否则返回false","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[553,554]},"content":"Push(&S,x): 进栈，若栈未满，x进栈操作，插入到栈内成为新的栈顶元素","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[554,555]},"content":"Pop(&S,&x): 出栈，若栈非空，出栈操作，弹出栈顶元素，用指针x进行返回","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[555,556]},"content":"GetTop(S,&x): 读栈顶元素，若栈S非空，用x返回栈顶元素","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[556,557]},"content":"ClearStack(&S): 销毁栈，释放栈S占用的存储空间","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[558,559]},"content":"顺序存储结构","children":[{"type":"list_item","depth":4,"payload":{"lines":[560,561]},"content":"顺序栈","children":[{"type":"list_item","depth":5,"payload":{"lines":[562,563]},"content":"定义：栈的顺序存储，利用一组地址连续的存储单元存放自栈底到栈顶的所有元素，同时附加一个用来指向当前栈顶位置的指针","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[563,564]},"content":"顺序栈S【重要，栈顶指针初始化为-1】","children":[{"type":"list_item","depth":6,"payload":{"lines":[565,566]},"content":"栈顶指针S.top","children":[{"type":"list_item","depth":7,"payload":{"lines":[567,568]},"content":"初始时，S.top=-1","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[568,569]},"content":"栈顶元素:S.data[S.top]","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[570,571]},"content":"进栈操作：栈不满时，栈顶+1，再进栈","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[571,572]},"content":"出栈操作：栈非空时，取栈顶元素，栈顶-1","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[572,573]},"content":"栈满条件：S.top=MaxSize-1","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[573,574]},"content":"栈空条件：S.top=-1","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[574,575]},"content":"栈长：S.top+1","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[575,576]},"content":"当对栈的最大使用空间估计不足时，容易出现栈上溢(外溢)，需要主动向用户报告反馈，避免出现错误；","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[577,578]},"content":"栈顶指针初始化为0【更多是为-1】","children":[{"type":"list_item","depth":6,"payload":{"lines":[579,580]},"content":"入栈： S.data[S.top++]=x","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[580,581]},"content":"出栈： x=S.data[--S.top]","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[581,582]},"content":"同时， 栈空、栈满条件也会有变化","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[583,584]},"content":"基本运算","children":[{"type":"list_item","depth":6,"payload":{"lines":[585,586]},"content":"InitStack(&S): 初始化一个空栈S,栈顶指针初始化为-1","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[586,587]},"content":"StackEmpty(S): 判断一个栈是否为空，即：栈顶指针是否为-1，如果栈空则返回true,否则返回false","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[587,588]},"content":"Push(&S,x): 进栈，若栈未满，x进栈操作，插入到栈内成为新的栈顶元素。","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[588,589]},"content":"Pop(&S,&x): 出栈，若栈非空，出栈操作，弹出栈顶元素，用指针x进行返回。","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[589,590]},"content":"GetTop(S,&x): 读（获取）栈顶元素，若栈S非空，用x返回栈顶元素。","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[591,592]},"content":"共享栈","children":[{"type":"list_item","depth":5,"payload":{"lines":[593,594]},"content":"定义：利用栈底位置相对不变的特性，可以让两个顺序栈共享一个一维存储空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶则向共享空间的中间延伸","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[594,595]},"content":"基础概念","children":[{"type":"list_item","depth":6,"payload":{"lines":[596,597]},"content":"两个栈（0、1号顺序栈）的栈顶指针都指向栈顶元素","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[597,598]},"content":"0号栈栈顶指针top=-1时，0号栈为空","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[598,599]},"content":"1号栈栈顶指针top=MaxSize时，1号栈为空","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[599,600]},"content":"当且仅当两个栈的栈顶指针相邻(top1-top0=1),可以判断共享栈栈满","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[601,602]},"content":"进栈【先移动指针，后赋值】","children":[{"type":"list_item","depth":6,"payload":{"lines":[603,604]},"content":"当0号栈进栈时，0号栈栈顶指针top0先加1后赋值","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[604,605]},"content":"当1号栈进栈时，0号栈栈顶指针top1先减1后赋值","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[606,607]},"content":"出栈【先赋值，后移动指针】","children":[{"type":"list_item","depth":6,"payload":{"lines":[608,609]},"content":"当0号栈进栈时，0号栈栈顶指针top0先赋值后减1","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[609,610]},"content":"当1号栈进栈时，0号栈栈顶指针top1先赋值后加1","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[611,612]},"content":"重要特性","children":[{"type":"list_item","depth":6,"payload":{"lines":[613,614]},"content":"共享栈能够更有效的利用存储空间，两个栈空间进行相互调节","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[614,615]},"content":"只有当这个存储空间（即：共享空间）被占满时才会发生上溢","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[615,616]},"content":"共享栈对存取效率没有什么影响，存取数据的时间复杂度都为O(1)，在栈顶操作。","children":[]}]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[617,618]},"content":"链式存储结构","children":[{"type":"list_item","depth":4,"payload":{"lines":[619,620]},"content":"基本概念","children":[{"type":"list_item","depth":5,"payload":{"lines":[621,622]},"content":"链栈： 采用链式存储的栈","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[622,623]},"content":"栈满：对于链栈来说，是基于链式存储的，基本不存在栈满的情况，除非内存已经没有使用空间了","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[623,624]},"content":"栈空：对于空栈来说，链表原来的定义是头指针指向空，那么链栈的空其实就是top＝NULL,链栈元素总数为0","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[624,625]},"content":"通常对于链栈来说，是不需要头结点的，当然也存在带头结点的链栈","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[626,627]},"content":"基础操作【基于单链表】","children":[{"type":"list_item","depth":5,"payload":{"lines":[628,629]},"content":"入栈","children":[{"type":"list_item","depth":6,"payload":{"lines":[630,631]},"content":"如果链栈不存在，则栈满，入栈操作失败，返回false;","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[631,632]},"content":"如果链栈存在，进行单链表的结点插入操作，移动指针，结点元素赋值，再将结点压入链栈中，移动链栈栈顶指针，最后链栈元素总数+1，返回true","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[633,634]},"content":"出栈","children":[{"type":"list_item","depth":6,"payload":{"lines":[635,636]},"content":"如果链栈不存在，或者为空栈，则无法进行出栈操作，返回false","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[636,637]},"content":"如果链栈满足出栈条件，则通过栈顶指针获取到链栈栈底结点，将其数据域赋值给变量e，移动栈顶指针指向待出栈元素的后继结点，同时释放待出栈元素的内存空间，链栈元素总数-1 ，出栈成功，返回true.","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[638,639]},"content":"基于单链表的链栈入栈、出栈操作，时间复杂度都为O(1）【重要】","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[640,641]},"content":"优点","children":[{"type":"list_item","depth":5,"payload":{"lines":[642,643]},"content":"便于多个栈共享存储空间","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[643,644]},"content":"不存在栈满上溢的情况，避免程序因溢出导致出错","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[644,645]},"content":"有效的提高存取效率","children":[]}]}]}]},{"type":"heading","depth":2,"payload":{"lines":[646,647]},"content":"队列【先进先出】","children":[{"type":"list_item","depth":3,"payload":{"lines":[648,649]},"content":"基本概念","children":[{"type":"list_item","depth":4,"payload":{"lines":[650,651]},"content":"队列：和栈一样，是一种操作受限制的线性表,只允许在表的一端进行插入，在表的另外一端进行删除，简称为队，常记作：Queue","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[651,652]},"content":"队头：允许进行删除操作的一端，也叫做队首，常记作：Front","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[652,653]},"content":"队尾：允许进行插入操作的一端，常记作：Rear","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[653,654]},"content":"空队列：不含任何元素的空表，注意这个表是指线性表","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[654,655]},"content":"入队： 向队列中插入元素，也叫做进队","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[655,656]},"content":"出队： 删除队列元素，也叫做离队","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[657,658]},"content":"基础操作","children":[{"type":"list_item","depth":4,"payload":{"lines":[659,660]},"content":"InitQueue(&Q)： 初始化一个队列，构造空队列Q","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[660,661]},"content":"QueueEmpty(Q)： 判断队列是否为空，队空返回true,否则返回false","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[661,662]},"content":"EnEmpty(&Q,x)： 入队，如果队列Q未满，将x入队，成为新的队尾元素","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[662,663]},"content":"DeEmpty(&Q,&x)： 出队，如果队列Q非空，删除队头元素，复制给x返回","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[663,664]},"content":"GetHead(Q,&x)： 读取队头元素，如果队列Q非空，则将队头元素赋值给x","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[665,666]},"content":"顺序存储","children":[{"type":"list_item","depth":4,"payload":{"lines":[667,668]},"content":"顺序队列","children":[{"type":"list_item","depth":5,"payload":{"lines":[669,670]},"content":"队列的顺序实现是指分配一块连续的存储单元用来存放队列中的元素，并且附加两个指针","children":[{"type":"list_item","depth":6,"payload":{"lines":[671,672]},"content":"front指针： 指向队头元素的位置","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[672,673]},"content":"rear指针： 指向队尾元素的位置","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[674,675]},"content":"初始状态（队空条件）：Q.front===Q.rear===0","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[675,676]},"content":"入队操作：队不满时，先赋值给队尾元素，再移动队尾指针+1","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[676,677]},"content":"出队操作： 队不空时，先取队头元素值，再移动队头指针+1","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[677,678]},"content":"Q.front===Q.rear===0,那能用Q.rear==MaxSize来表示队满嘛？【不行】","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[679,680]},"content":"循环队列","children":[{"type":"list_item","depth":5,"payload":{"lines":[681,682]},"content":"把顺序队列臆想为一个环状的空间，将存储队列元素的表从逻辑上看做为一个环","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[682,683]},"content":"初始时：Q.front=Q.rear=0","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[683,684]},"content":"队首指针进1： Q.front=(Q.front+1)%MaxSize","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[684,685]},"content":"队尾指针进1： Q.rear=(Q.rear+1)%MaxSize","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[685,686]},"content":"队列长度： (Q.rear+MaxSize-Q.front)%MaxSize","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[686,687]},"content":"除法取余运算（%）【解决顺序队列“上溢出”】问题","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[687,688]},"content":"如何区别队空还是队满？","children":[{"type":"list_item","depth":6,"payload":{"lines":[689,690]},"content":"方案一：牺牲一个单元来区分队空和队满","children":[{"type":"list_item","depth":7,"payload":{"lines":[691,692]},"content":"前提：队头指针在队尾指针在队尾指针的下一个位置作为队满标志【重要】","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[692,693]},"content":"队满条件：(Q.rear+1)%MaxSize==Q.front","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[693,694]},"content":"队空条件：Q.front==Q.rear","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[694,695]},"content":"队列中元素个数：(Q.rear+MaxSize-Q.front)%MaxSize","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[696,697]},"content":"方案二：类型中增设表示元素个数的数据成员","children":[{"type":"list_item","depth":7,"payload":{"lines":[698,699]},"content":"直接和MaxSize去比较","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[699,700]},"content":"队空条件： Q.count=0","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[700,701]},"content":"队满条件： Q.count=MaxSize","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[701,702]},"content":"【注意】不论是队空还是队满，对会存在Q.front=Q.rear,这个可以通过前面方案一解决","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[703,704]},"content":"方案三：类型中增设tag数据成员标记","children":[{"type":"list_item","depth":7,"payload":{"lines":[705,706]},"content":"通过添加tag标记的方式，区分队空还是队满","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[706,707]},"content":"tag0的情况下，如果因为删除导致Q.frontQ.rear，则队空；","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[707,708]},"content":"tag1的情况下，如果因为插入导致Q.frontQ.rear，则队满；","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[708,709]},"content":"tag的主要作用","children":[{"type":"list_item","depth":8,"payload":{"lines":[710,711]},"content":"在有元素入队的时候，设置tag=1","children":[]},{"type":"list_item","depth":8,"payload":{"lines":[711,712]},"content":"在有元素出队的时候，设置tag=0","children":[]}]}]}]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[713,714]},"content":"链式存储","children":[{"type":"list_item","depth":4,"payload":{"lines":[715,716]},"content":"链队列","children":[{"type":"list_item","depth":5,"payload":{"lines":[717,718]},"content":"链队列：和顺序队列一样，基于队列的链式表示叫做链队列，实际上为：一个同时带有队头指针和队尾指针的单链表","children":[{"type":"list_item","depth":6,"payload":{"lines":[719,720]},"content":"头指针指向队头结点","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[720,721]},"content":"尾指针指向队尾结点（单链表的最后一个结点）","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[722,723]},"content":"不带头结点链式队列","children":[{"type":"list_item","depth":6,"payload":{"lines":[724,725]},"content":"队空： linkQueue.frontNULL且linkQueue.rearNULL","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[725,726]},"content":"出队： 先判断队列是否为空，非空队列则取出队头元素，从链表中闪出去，队头指针Q.front指向下一个结点，如果出队的结此为尾结点，出队后队空，需要将Q.front和Q.rear都置为NULL","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[726,727]},"content":"入队： 建立一个新的结点，将新的结点插入到链表的尾部，修改队尾指针Q.rear指向新插入的结点。如果原队列为空，需要将队首指针也指向该结点","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[727,728]},"content":"【入队、出队操作，都需要考虑队空的情况下的特殊处理，不带头结点的队列导致队空队首和队尾指针都为NULL，麻烦】","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[729,730]},"content":"带头结点的链式队列","children":[{"type":"list_item","depth":6,"payload":{"lines":[731,732]},"content":"【复杂的入队、出队操作就统一起来】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[732,733]},"content":"队空：Q.front==Q.rear,都指向头结点，一般数据域可以为空","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[733,734]},"content":"出队：判断队列是否为空，队列非空则在队首移动指针，将队首指针指向下一个元素。如果队列中就一个元素，则出队后将成为空队，Q.rear==Q.front,最后释放元素内存空间。","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[734,735]},"content":"入队：将元素插入队尾，移动队尾指针，即便为空队列入队，由于队列带有头结点，此时就很好的避免操作队首指针了。","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[735,736]},"content":"子主题 5","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[737,738]},"content":"特别注意","children":[{"type":"list_item","depth":6,"payload":{"lines":[739,740]},"content":"用单链表表示的链式队列非常适合频繁出队、入队、元素变化大的场景","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[740,741]},"content":"不存在队满情况，也不会出现溢出情况；","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[741,742]},"content":"链式队列不会出现存储分配不合理、“溢出”的情况，内存动态分配","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[743,744]},"content":"基本操作【带头结点】","children":[{"type":"list_item","depth":6,"payload":{"lines":[745,746]},"content":"队列初始化","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[746,747]},"content":"判断队空：Q.front==Q.rear","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[747,748]},"content":"入队【重要】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[748,749]},"content":"出队【重要】","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[750,751]},"content":"双端队列","children":[{"type":"list_item","depth":5,"payload":{"lines":[752,753]},"content":"允许在两端都可以进行入队和出队操作的队列，元素的逻辑结构仍然是线性结构","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[753,754]},"content":"双端队列的两端分别称为前端和后端，两端都可以入队和出队","children":[{"type":"list_item","depth":6,"payload":{"lines":[755,756]},"content":"进队：前端进的元素排列在队列中后端进的元素的前面，后端进的元素排列在队列前端进的元素后面;","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[756,757]},"content":"出队：无论是前端还是后端出队，先出的的元素排列在后出的元素的前面","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[758,759]},"content":"输入受限的双端队列：允许在一端进行插入和删除操作，但在另外一端只允许进行删除的双端队列","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[759,760]},"content":"输出受限的双端队列：允许在一端进行插入和删除曹组，但在另外一端只允许进行插入的双端队列","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[761,762]},"content":"如果限定双端队列从某个断点插入的元素只能从该端点删除，那么此时的双端队列就演变为两个栈底相邻的栈","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[763,764]},"content":"补充","children":[{"type":"list_item","depth":5,"payload":{"lines":[765,766]},"content":"最适合用来链队的链表是：带队首指针和队尾指针的非循环单链表","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[766,767]},"content":"栈和队列的逻辑结构都是线性表，存储结构可能是顺序的（顺序栈、顺序队列），也可能是链式的（链栈、链队）","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[767,768]},"content":"不论是顺序存储还是链式存储，栈和队列都只能进行顺序存取（本质是线性表）。数组是可以做到随机存取（本质是顺序表）","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[768,769]},"content":"队列先进先出的特性：先进队列的元素先出队列，后进队列的元素后出队列","children":[]}]}]}]},{"type":"heading","depth":2,"payload":{"lines":[770,771]},"content":"应用","children":[{"type":"list_item","depth":3,"payload":{"lines":[772,773]},"content":"【栈】括号匹配","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[773,774]},"content":"【栈】表达式求值","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[774,775]},"content":"【栈】递归算法","children":[{"type":"list_item","depth":4,"payload":{"lines":[776,777]},"content":"定义： 如果在一个函数、过程或数据结构的定义中又应用了自身，那么这个函数、过程或者数据结构称为递归定义的，简称递归。","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[777,778]},"content":"递归通常把一个大型的复杂问题，层层转化为一个与原问题相似的规模较小的问题来求解","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[778,779]},"content":"斐波拉切数列算法优化","children":[{"type":"list_item","depth":5,"payload":{"lines":[780,781]},"content":"使用非递归实现","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[781,782]},"content":"使用空间换效率，例如：数组","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[782,783]},"content":"使用缓存，存放数据","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[784,786]},"content":"必须注意递归模型不能是循环定义，
\n需要满足两个条件","children":[{"type":"list_item","depth":5,"payload":{"lines":[787,788]},"content":"递归表达式（递归体）","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[788,789]},"content":"边界条件（递归出口），即：算法结束条件","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[790,791]},"content":"特点","children":[{"type":"list_item","depth":5,"payload":{"lines":[792,793]},"content":"很大程度上减少了程序的代码量","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[793,794]},"content":"算法效率不高【重要特点】","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[794,795]},"content":"调用次数过多容易造成栈溢出","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[796,797]},"content":"【队列】层次遍历","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[797,798]},"content":"【队列】计算机系统","children":[{"type":"list_item","depth":4,"payload":{"lines":[799,800]},"content":"解决主机和外部设备之间速度不匹配的问题","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[800,801]},"content":"解决由多用户引起的资源竞争问题","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[802,803]},"content":"特殊矩阵的压缩存储","children":[{"type":"list_item","depth":3,"payload":{"lines":[804,805]},"content":"在计算机图形学、工程计算中占有举足轻重的地位。","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[805,806]},"content":"数组定义：由n(n≥1)个相同类型的数据元素构成的有限序列。","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[806,807]},"content":"重要概念","children":[{"type":"list_item","depth":4,"payload":{"lines":[808,809]},"content":"【压缩存储】多个值相同的元素只分配一个存储空间，对零元素不分配存储空间---->节省存储空间。","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[809,810]},"content":"【特殊矩阵】具有很多相同矩阵元素或零元素，并且这些相同矩阵元素或零元素的分布有一定规律性的矩阵。","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[810,811]},"content":"【稀疏矩阵】矩阵元素个数s相对于矩阵中非零元素的个数t来说非常多、差距非常大，即s>>t的矩阵可以叫稀疏矩阵","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[812,813]},"content":"常见的特殊矩阵","children":[{"type":"list_item","depth":4,"payload":{"lines":[814,815]},"content":"对称矩阵","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[815,816]},"content":"上、下三角矩阵","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[816,817]},"content":"对角矩阵（带状矩阵）","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[817,818]},"content":"......","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[819,820]},"content":"注意","children":[{"type":"list_item","depth":4,"payload":{"lines":[821,822]},"content":"常规方法来存储稀疏矩阵，会想当浪费存储空间，所以稀疏矩阵只需要存储非零元素","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[822,823]},"content":"通常非零元素的分布是没有规律的，除了存储非零元素外，还需要存储元素所在位置的行和列","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[823,824]},"content":"寻相互存储三元组 <行标，列表，值>","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[824,825]},"content":"三元组的结点存储了行标(row)、列表(col)、值(value)三种信息，是主要用来存储稀疏矩阵的一种数据结构","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[826,827]},"content":"数组和线性表的关系","children":[{"type":"list_item","depth":4,"payload":{"lines":[828,829]},"content":"数组是线性表的推广","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[829,830]},"content":"数组一旦被定义，维数和维界就不再改变","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[830,831]},"content":"除了结构的初始化和销毁外，数组只会有存取元素和修改元素的操作","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[832,833]},"content":"数组的存储结构","children":[{"type":"list_item","depth":4,"payload":{"lines":[834,835]},"content":"按行优先","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[835,836]},"content":"按列优先","children":[]}]}]}]},{"type":"heading","depth":1,"payload":{"lines":[837,838]},"content":"树与二叉树","children":[{"type":"heading","depth":2,"payload":{"lines":[839,840]},"content":"树","children":[{"type":"list_item","depth":3,"payload":{"lines":[841,842]},"content":"定义","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[842,843]},"content":"术语","children":[{"type":"list_item","depth":4,"payload":{"lines":[844,845]},"content":"结点","children":[{"type":"list_item","depth":5,"payload":{"lines":[846,847]},"content":"祖先结点","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[847,848]},"content":"父子结点","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[848,849]},"content":"兄弟结点","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[849,850]},"content":"孩子结点","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[850,851]},"content":"子孙结点","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[851,852]},"content":"分支结点","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[852,853]},"content":"叶子结点（终端结点）","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[854,855]},"content":"度","children":[{"type":"list_item","depth":5,"payload":{"lines":[856,857]},"content":"结点的度","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[857,858]},"content":"树的度","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[859,860]},"content":"结点的深度、高度、层次","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[860,861]},"content":"有序树和无序树","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[861,862]},"content":"路径和路径长度","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[862,863]},"content":"森林","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[864,865]},"content":"性质","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[866,867]},"content":"二叉树","children":[{"type":"list_item","depth":3,"payload":{"lines":[868,869]},"content":"定义和特性","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[869,870]},"content":"存储结构","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[870,871]},"content":"二叉树遍历","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[871,872]},"content":"线索二叉树","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[873,874]},"content":"树和森林","children":[{"type":"list_item","depth":3,"payload":{"lines":[875,876]},"content":"存储结构","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[876,877]},"content":"树、森林与二叉树转换","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[877,878]},"content":"遍历","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[878,879]},"content":"并查集应用","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[880,881]},"content":"应用","children":[{"type":"list_item","depth":3,"payload":{"lines":[882,883]},"content":"二叉排序树","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[883,884]},"content":"平衡二叉树","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[884,885]},"content":"哈夫曼树","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[885,886]},"content":"哈夫曼编码","children":[]}]}]},{"type":"heading","depth":1,"payload":{"lines":[887,888]},"content":"图论","children":[{"type":"heading","depth":2,"payload":{"lines":[889,890]},"content":"定义","children":[]},{"type":"heading","depth":2,"payload":{"lines":[891,892]},"content":"基本操作","children":[{"type":"list_item","depth":3,"payload":{"lines":[893,894]},"content":"Adjacent(G,x,y)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[894,895]},"content":"Neighbors(G,x)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[895,896]},"content":"InsertVertex(G,x)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[896,897]},"content":"DeleteVertex(G,x)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[897,898]},"content":"AddEdge(G,x,y)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[898,899]},"content":"RemoveEdge(G,x,y)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[899,900]},"content":"FirstNeighbor(G,x)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[900,901]},"content":"NextNeighbor(G,x,y)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[901,902]},"content":"Get_edge_value(G,x,y)","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[902,903]},"content":"Set_edge_value(G,x,y,v)","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[904,905]},"content":"存储及操作","children":[{"type":"list_item","depth":3,"payload":{"lines":[906,907]},"content":"邻接矩阵法","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[907,908]},"content":"邻接链表法","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[908,909]},"content":"十字链表","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[909,910]},"content":"邻接多重表","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[911,912]},"content":"图的遍历","children":[{"type":"list_item","depth":3,"payload":{"lines":[913,914]},"content":"广度优先搜索（BFS）","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[914,915]},"content":"深度优先搜索（DFS）","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[915,916]},"content":"连通性","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[917,918]},"content":"图的应用","children":[{"type":"list_item","depth":3,"payload":{"lines":[919,920]},"content":"最小生成树（MST）","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[920,921]},"content":"最短路径","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[921,922]},"content":"拓扑排序","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[922,923]},"content":"关键路劲","children":[]}]}]},{"type":"heading","depth":1,"payload":{"lines":[924,925]},"content":"查找","children":[{"type":"heading","depth":2,"payload":{"lines":[926,927]},"content":"基本概念","children":[{"type":"list_item","depth":3,"payload":{"lines":[928,929]},"content":"查找：在数据集合中寻找满足某种条件的数据元素的过程","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[929,930]},"content":"查找表（查找结构）：用于查找的数据集合","children":[{"type":"list_item","depth":4,"payload":{"lines":[931,932]},"content":"数据元素（记录）的类型相同","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[932,933]},"content":"可以是一个数组或者链表等数据类型","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[933,934]},"content":"常见操作","children":[{"type":"list_item","depth":5,"payload":{"lines":[935,936]},"content":"查询某个特定元素是否存在","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[936,937]},"content":"检索满足条件的特定元素的各种属性","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[937,938]},"content":"数据元素插入","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[938,939]},"content":"数据元素删除","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[940,941]},"content":"静态查找表：不需要动态地修改查找表，与动态查找表对应","children":[{"type":"list_item","depth":4,"payload":{"lines":[942,943]},"content":"顺序查找","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[943,944]},"content":"折半查找","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[944,945]},"content":"散列查找","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[945,946]},"content":"....","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[947,948]},"content":"动态查找表：需要动态地插入或者删除的查找表","children":[{"type":"list_item","depth":4,"payload":{"lines":[949,950]},"content":"二叉排序树的查找","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[950,951]},"content":"散列查找","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[951,952]},"content":"....","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[953,954]},"content":"关键字：数据元素中唯一标识该元素的某个数据项的值","children":[{"type":"list_item","depth":4,"payload":{"lines":[955,956]},"content":"使用关键字查找，查找结果应该是【唯一的】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[956,957]},"content":"可以类比集合中不重复的key","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[957,958]},"content":"是不是想起了数据库的主键的概念？？？？","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[959,960]},"content":"平均查找长度：所有查找过程中进行关键字的比较次数的平均值","children":[{"type":"list_item","depth":4,"payload":{"lines":[961,962]},"content":"查找长度：一次查找需要比较的关键字次数","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[962,963]},"content":"【是衡量查找算法效率的最主要的指标】","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[964,965]},"content":"顺序查找（线性查找）","children":[{"type":"list_item","depth":3,"payload":{"lines":[966,967]},"content":"主要用于在线性表中进行查找","children":[{"type":"list_item","depth":4,"payload":{"lines":[968,969]},"content":"一般的【无序线性表】的顺序查找","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[969,970]},"content":"按关键字【有序的顺序表】的顺序查找","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[970,971]},"content":"Tips：顺序表是指顺序存储的线性表，前面的有序才强调元素有序，顺序强调的是存储方式","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[972,973]},"content":"基于一般线性表的顺序查找","children":[{"type":"list_item","depth":4,"payload":{"lines":[974,975]},"content":"最直观的查找方式","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[975,976]},"content":"基本思想：从线性表的一端开始，逐个查询条件和关键字进行比对即可","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[976,977]},"content":"【重要】：哨兵的引入，可以避免很多不必要的判断语句，提高程序的效率","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[977,978]},"content":"平均查找长度","children":[{"type":"list_item","depth":5,"payload":{"lines":[979,980]},"content":"查找成功","children":[{"type":"list_item","depth":6,"payload":{"lines":[981,982]},"content":"第i个元素需要进行(n-i+1)次关键字比较","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[982,983]},"content":"概率相等的情况下：(n+1)/2","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[984,985]},"content":"查找失败【没有找到元素】","children":[{"type":"list_item","depth":6,"payload":{"lines":[986,987]},"content":"各关键字比较次数：(n+1)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[987,988]},"content":"平均查找长度：(n+1)","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[989,990]},"content":"综合分析","children":[{"type":"list_item","depth":5,"payload":{"lines":[991,992]},"content":"【缺点】：n较大时，平均查找长度较大，效率低","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[992,993]},"content":"【优点】：对数据元素的存储没有要求，顺序存储和链式存储都可行。对数据元素的有序性也没有要求","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[993,994]},"content":"【注意】：线性的链表只能进行顺序查找","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[995,996]},"content":"通常情况下，查找表中记录的查找概率并不相等","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[997,998]},"content":"基于有序表的顺序查找","children":[{"type":"list_item","depth":4,"payload":{"lines":[999,1000]},"content":"预先已经知道表是按照关键字有序的，基于【二叉判定树】来查找，不用全部遍历----->【降低顺序查找失败的平均查找长度】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1000,1001]},"content":"平均查找长度","children":[{"type":"list_item","depth":5,"payload":{"lines":[1002,1003]},"content":"查找成功","children":[{"type":"list_item","depth":6,"payload":{"lines":[1004,1005]},"content":"和一般线性表的顺序查找一样","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1005,1006]},"content":"概率相等的情况下：(n+1)/2","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1007,1008]},"content":"查找失败","children":[{"type":"list_item","depth":6,"payload":{"lines":[1009,1010]},"content":"到达是失败结点所查找的长度=失败结点父结点所在的层数【建议画画二叉判定树】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1010,1011]},"content":"查找概率相等时，平均查找长度:n/2 + n/(n+1)","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[1012,1013]},"content":"【注意】：有序表的顺序查找中的线性表可以是链式存储结构的","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1014,1015]},"content":"折半查找（二分查找）","children":[{"type":"list_item","depth":3,"payload":{"lines":[1016,1017]},"content":"【注意】仅仅适用于有序的顺序表","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1017,1018]},"content":"基本思想：首先与表中间位置元素的关键字比较，相等则查找成功，不相等则向左|向右继续与该部分中间元素比较......","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1018,1019]},"content":"核心思路：左右双指针，互相往中间靠拢，可以用二叉判定树来辅助思考","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1019,1020]},"content":"平均查找长度【计算非常重要】","children":[{"type":"list_item","depth":4,"payload":{"lines":[1021,1022]},"content":"查找成功","children":[{"type":"list_item","depth":5,"payload":{"lines":[1023,1024]},"content":"折半查找法查到给定值的比较次数最多不会超过【判定树】的高度","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1024,1025]},"content":"相等概率下，平均查找长度约等于log2(n+1) -1 ,【建议结合二叉树高度计算来理解】","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1026,1027]},"content":"查找失败直接看例题.....","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1028,1029]},"content":"综合分析","children":[{"type":"list_item","depth":4,"payload":{"lines":[1030,1031]},"content":"折半查找的时间复杂度为O(log2n), 平均情况下笔顺序查找O(n)的效率高","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1031,1032]},"content":"折半查找需要方便地定位查找区域---->存储结构必须具有【随机存取】的特性","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1032,1033]},"content":"【注意】仅仅适用于有序的顺序表，不适用链式存储结构，要求表按关键字有序排列","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1034,1035]},"content":"分块查找（索引顺序查找）","children":[{"type":"list_item","depth":3,"payload":{"lines":[1036,1037]},"content":"具备顺序查找和折半查找的优点，既有动态结构，又能适用于快速查找","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1037,1038]},"content":"是不是有点【希尔排序】和【直接插入排序、折半插入排序】的发展效果？？？？？","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1038,1039]},"content":"基本思想：查找表分成若干个子块","children":[{"type":"list_item","depth":4,"payload":{"lines":[1040,1041]},"content":"块内元素可以无序，【块之间必须有序】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1041,1042]},"content":"前一块的最大关键字永远小于后一块的最小关键字","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1042,1043]},"content":"【重要】：建立索引表，包含每个分块额最大关键字和第一个元素的地址（起始角标）","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1043,1044]},"content":"索引表按关键字有序排列","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1045,1046]},"content":"查找方式","children":[{"type":"list_item","depth":4,"payload":{"lines":[1047,1048]},"content":"索引表：顺序查找或者折半查找","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1048,1049]},"content":"块内：顺序查找<----- 块内可以无序","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1050,1051]},"content":"【直接看书】平均查找长度=索引查找平均长度+块内查找的平均长度","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[1052,1053]},"content":"【直接看书|视频，这部分我很迷糊】B树和B+树","children":[{"type":"list_item","depth":3,"payload":{"lines":[1054,1055]},"content":"B树（多路平衡查找树）","children":[{"type":"list_item","depth":4,"payload":{"lines":[1056,1057]},"content":"基础概念","children":[{"type":"list_item","depth":5,"payload":{"lines":[1058,1059]},"content":"阶：所有结点的孩子结点数的最大值","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1059,1060]},"content":"m阶B树（可能为空树）满足","children":[{"type":"list_item","depth":6,"payload":{"lines":[1061,1062]},"content":"树中每个结点至多有m棵子树（即至多包含m-1个关键字）","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1062,1063]},"content":"如果根结点不是终端结点，至少有两棵子树","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1063,1064]},"content":"所有的叶结点都出现在同一个层次上，不带任何信息","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1064,1065]},"content":"....","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1066,1067]},"content":"B树是所有结点的平衡因子均为0的多路查找树","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1068,1069]},"content":"基本操作","children":[{"type":"list_item","depth":5,"payload":{"lines":[1070,1071]},"content":"高度","children":[{"type":"list_item","depth":6,"payload":{"lines":[1072,1073]},"content":"B树的大部分操作需要的磁盘存取次数和B树的高度成正比","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1073,1074]},"content":"B树的高度不包括最后的不带任何信息的叶结点所处的那一层【有的参考书，也包含这部分】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1074,1075]},"content":"【重要】如果每个结点重点额关键字个数达到最少，则容纳同样多关键字的B树的高度可以达到最大","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1075,1076]},"content":"....","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1077,1078]},"content":"查找","children":[{"type":"list_item","depth":6,"payload":{"lines":[1079,1080]},"content":"步骤","children":[{"type":"list_item","depth":7,"payload":{"lines":[1081,1082]},"content":"在B树中找结点【磁盘中进行】","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1082,1083]},"content":"在结点内找关键字【内存中进行】----> 采用【顺序查找法】或【折半查找法】","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1083,1084]},"content":"【Tips】B树常存储在磁盘上，在磁盘上找到目标节点后，将结点中的信息读入到内存","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[1085,1086]},"content":"当查找到叶子结点，对应的指针为空指针，即树中没有对应的关键字","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1087,1088]},"content":"插入","children":[{"type":"list_item","depth":6,"payload":{"lines":[1089,1090]},"content":"插入操作比查找操作复杂多","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1090,1091]},"content":"步骤","children":[{"type":"list_item","depth":7,"payload":{"lines":[1092,1093]},"content":"定位","children":[{"type":"list_item","depth":8,"payload":{"lines":[1094,1095]},"content":"B树查找算法--->最底层中某个非叶结点","children":[]},{"type":"list_item","depth":8,"payload":{"lines":[1095,1096]},"content":"【重要】B树的插入关键字一定是插入到最底层的某个非叶结点内","children":[]}]},{"type":"list_item","depth":7,"payload":{"lines":[1097,1098]},"content":"插入","children":[{"type":"list_item","depth":8,"payload":{"lines":[1099,1100]},"content":"插入结点关键字个数小于m----> 直接插入","children":[]},{"type":"list_item","depth":8,"payload":{"lines":[1100,1101]},"content":"插入后检查插入结点内关键字个数，【大于m-1必须进行分裂】","children":[]}]},{"type":"list_item","depth":7,"payload":{"lines":[1102,1103]},"content":"【直接看书】】注意分裂的方法","children":[]}]}]},{"type":"list_item","depth":5,"payload":{"lines":[1104,1105]},"content":"删除（删除的关键字在终端结点）","children":[{"type":"list_item","depth":6,"payload":{"lines":[1106,1107]},"content":"直接删除关键字","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1107,1108]},"content":"兄弟够借","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1108,1109]},"content":"兄弟不够借","children":[]}]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[1110,1111]},"content":"B+树的概念","children":[{"type":"list_item","depth":4,"payload":{"lines":[1112,1113]},"content":"B+树是根据数据库的需要需要的一中B树的变形树","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1113,1114]},"content":"m阶的B+树需要满足的条件","children":[{"type":"list_item","depth":5,"payload":{"lines":[1115,1116]},"content":"每个分支结点最多有m棵子树（子结点）","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1116,1117]},"content":"结点的字树个数与关键字相等","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1117,1118]},"content":"非叶、根结点至少有两棵子树，其他分支结点至少有m/2(向上取整)棵子树","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1118,1119]},"content":"所有叶结点包含全部关键字及指向相应记录的指针","children":[{"type":"list_item","depth":6,"payload":{"lines":[1120,1121]},"content":"叶结点按关键字大小排列","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1121,1122]},"content":"相邻结点按大小顺序相互链接起来","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1123,1124]},"content":"【反复理解】所有的分支结点（理解为索引的索引）中仅仅包含它的各个子结点（下一级的索引快）中关键字的最大值和指向其子结点的指针","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1124,1125]},"content":"....","children":[]}]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1126,1127]},"content":"散列（Hash）表","children":[{"type":"list_item","depth":3,"payload":{"lines":[1128,1129]},"content":"基本概念","children":[{"type":"list_item","depth":4,"payload":{"lines":[1130,1131]},"content":"散列函数：一个把查找表中的关键字映射成该关键字对应的地址（数组下标、索引、内存地址等）的函数","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1131,1132]},"content":"散列冲突：散列函数把两个或者多个不同关键字映射到同一个地址上，【冲突总是不可避免的】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1132,1133]},"content":"同义词：发生散列冲突（碰撞）的不同关键字","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1133,1134]},"content":"散列表：根据关键字直接访问的数据结构，是关键字和存储地址之间的一种直接映射关系","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1134,1135]},"content":"理想情况下，散列表中查找时间复杂度为O(1)，与元素个数无关","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1135,1136]},"content":"基于【比较】的查找算法，查找效率取决于比较的次数","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1136,1137]},"content":"以上可以结合哈希加密、布隆过滤器等工作中的编程概念去比对学习....","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1138,1139]},"content":"散列函数","children":[{"type":"list_item","depth":4,"payload":{"lines":[1140,1141]},"content":"构造散列函数，需要注意","children":[{"type":"list_item","depth":5,"payload":{"lines":[1142,1143]},"content":"散列函数的定义域【必须】要包含全部需要存储的关键字，值域的范围则依赖于散列表的大小或地址范围","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1143,1144]},"content":"散列函数计算出来的地址应该能【等概率、均匀的】分布在整个存储空间，尽可能减少散列冲突---> 【压测】","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1144,1145]},"content":"散列函数应该尽量简单，能够在较短时间内就计算出任一关键字对应的散列地址","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1146,1147]},"content":"常用散列函数","children":[{"type":"list_item","depth":5,"payload":{"lines":[1148,1149]},"content":"直接定址法","children":[{"type":"list_item","depth":6,"payload":{"lines":[1150,1151]},"content":"直接去关键字的某个【线性函数值】为散列函数","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1151,1152]},"content":"优点","children":[{"type":"list_item","depth":7,"payload":{"lines":[1153,1154]},"content":"计算简单","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1154,1155]},"content":"【不会产生冲突】","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1155,1156]},"content":"适合关键字的分布【基本连续】的情况","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[1157,1158]},"content":"缺点：关键字分布不连续时，空位较多，将造成存储空间的浪费","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1159,1160]},"content":"除留余数法","children":[{"type":"list_item","depth":6,"payload":{"lines":[1161,1162]},"content":"最简单、最常用的散列方法","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1162,1163]},"content":"关键在于【选择被除数P】，等概率进行映射，尽可能减少冲突的可能性","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1164,1165]},"content":"数字分析法","children":[{"type":"list_item","depth":6,"payload":{"lines":[1166,1167]},"content":"适用于已知的关键字集合","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1167,1168]},"content":"如果更换了关键字，就需要重新构造新的散列函数","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1169,1170]},"content":"平方取中法","children":[{"type":"list_item","depth":6,"payload":{"lines":[1171,1172]},"content":"取关键字的平方值的中间几位来作为散列地址","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1172,1173]},"content":"适用于关键字的每一位取值都不够均匀或小于散列地址所需要的位数","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1174,1175]},"content":"折叠法","children":[{"type":"list_item","depth":6,"payload":{"lines":[1176,1177]},"content":"将关键字分割成位数相同的几部分，取这几部分的叠加作为散列地址","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1177,1178]},"content":"关键字位数很多，每一位上数字分布大致均匀时，可以采用折叠法得到散列地址","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1179,1180]},"content":".....","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1181,1182]},"content":"不同的情况，不同的散列函数会发挥不同的性能，无法笼统的说那种散列函数最好。散列函数的目标都是为了将产生冲突的可能性尽可能地降低","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1183,1184]},"content":"处理冲突","children":[{"type":"list_item","depth":4,"payload":{"lines":[1185,1186]},"content":"【任何设计出来的散列函数都不可能绝对地避免冲突】，必须考虑在发生冲突时如何进行处理","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1186,1187]},"content":"处理方法","children":[{"type":"list_item","depth":5,"payload":{"lines":[1188,1189]},"content":"开放定址法","children":[{"type":"list_item","depth":6,"payload":{"lines":[1190,1191]},"content":"概念：可以存放新表项的空闲地址，既向它的同义词表项开放，也向它的非同义词表项开放","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1191,1192]},"content":"增量取值方法","children":[{"type":"list_item","depth":7,"payload":{"lines":[1193,1194]},"content":"线性探测法","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1194,1195]},"content":"平方探测法","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1195,1196]},"content":"再散列法（双散列法）","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1196,1197]},"content":"伪随机序列法","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[1198,1199]},"content":"注意事项","children":[{"type":"list_item","depth":7,"payload":{"lines":[1200,1201]},"content":"不能随便【物理删除】表中已有元素，删除将会截断具有相同散列地址元素的查找地址，牵涉元素广","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1201,1202]},"content":"删除元素需要【单独做标记】，采用【逻辑删除】","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1202,1203]},"content":"逻辑删除会导致散列表表面上看上满的，实际上很多位置都是没有被利用的，【需要定期维护，将删除标记的\b元素物理删除】","children":[]}]}]},{"type":"list_item","depth":5,"payload":{"lines":[1204,1205]},"content":"拉链（链接）法","children":[{"type":"list_item","depth":6,"payload":{"lines":[1206,1207]},"content":"概念：为避免非同义词发生冲突，可以把所有的同义词存储在一个线性链表中【由散列地址唯一标识】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1207,1208]},"content":"【重要】适用于经常进行插入和删除的情况","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1209,1210]},"content":"拉链法处理冲突时不存在聚集现象，用线性探测法处理冲突时容易产生聚集现象","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[1211,1212]},"content":"性能分析","children":[{"type":"list_item","depth":4,"payload":{"lines":[1213,1214]},"content":"装填因子：一个表的装满程度 =（表中的记录数）/ （散列表的长度）","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1214,1215]},"content":"查找效率取决于","children":[{"type":"list_item","depth":5,"payload":{"lines":[1216,1217]},"content":"散列函数","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1217,1218]},"content":"处理冲突的方法","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1218,1219]},"content":"【重要】装填因子","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1220,1221]},"content":"散列表的平均查找长度依赖于【散列表的填装因子】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1221,1222]},"content":"填装因子越大，表示装填的越“满”，发生冲突的可能性就越大","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1222,1223]},"content":"散列冲突导致散列表在查找过程中也是需要进行比较的。【查找效率仍然用平均查找长度来度量】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1223,1224]},"content":"冲突的产生概率与装填因子（表中记录数和表长）的大小成正比","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1225,1226]},"content":"模式匹配（字符串）","children":[{"type":"list_item","depth":3,"payload":{"lines":[1227,1228]},"content":"简单模式匹配","children":[{"type":"list_item","depth":4,"payload":{"lines":[1229,1230]},"content":"概念：第一个字符串（模式串）在第二串（主串）中的位置","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1230,1231]},"content":"基本过程：从主串指定字符开始（一般第一个）和模式串的第一个字符逐个比较....","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1231,1232]},"content":"时间复杂度：O(n*m)，n、m分别为主串和模式串的长度","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1233,1234]},"content":"【难点，直接看代码理解】KMP算法","children":[{"type":"list_item","depth":4,"payload":{"lines":[1235,1236]},"content":"【重要】是对简单模式匹配的改造，时间复杂度在O(n+m)的数量集上","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1236,1237]},"content":"【建议手动模拟】基本过程","children":[{"type":"list_item","depth":5,"payload":{"lines":[1238,1239]},"content":"整个匹配过程，没有进行指针回溯","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1239,1240]},"content":"每趟比较过程让子串向后滑动到一个合适位置， 让这个位置上的字符和主串中的那个字符比较","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1240,1241]},"content":"【重要】next数组的求解实际是对某个位置找到最长的公共前缀","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[1242,1243]},"content":"总结比较","children":[{"type":"list_item","depth":4,"payload":{"lines":[1244,1245]},"content":"简单模式匹配时间复杂度：O(n*m)","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1245,1246]},"content":"KMP算法的时间复杂度为O(n+m)","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1246,1247]},"content":"一般情况下，简单模式匹配的实际执行时间可以近似到O(n+m)","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1247,1248]},"content":"【重要】KMP算法的重要特点是主串指针不回溯","children":[]}]}]}]},{"type":"heading","depth":1,"payload":{"lines":[1249,1250]},"content":"排序","children":[{"type":"heading","depth":2,"payload":{"lines":[1251,1252]},"content":"基本概念和定义","children":[{"type":"list_item","depth":3,"payload":{"lines":[1253,1254]},"content":"排序：重新排列表中的元素，让表中的元素能够满足按照关键字递增或者递减的过程","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1254,1255]},"content":"算法的稳定性【非常重要】","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1255,1256]},"content":"排序算法是否具有稳定性并不能衡量一个算法的优劣【重要】","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1256,1257]},"content":"内部排序：在排序期间元素全部存放在内存中的排序","children":[{"type":"list_item","depth":4,"payload":{"lines":[1258,1259]},"content":"关键字比较","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1259,1260]},"content":"移动元素","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1260,1261]},"content":"不是所有的内部排序算法都是基于比较操作的，例如：基数排序属于内部排序算法，但不是基于比较实现的","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1262,1263]},"content":"外部排序：在排序期间元素无法全部同时存放在内存中，必须在排序的过程中根据要求不断地在内、外存之间移动的排序。","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[1264,1265]},"content":"插入排序","children":[{"type":"list_item","depth":3,"payload":{"lines":[1266,1267]},"content":"基本思想：每次将一个待排序的记录，按关键字大小插入到前面已经排序好的子序列中，直到全部记录插入完成","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1267,1268]},"content":"直接插入排序","children":[{"type":"list_item","depth":4,"payload":{"lines":[1269,1270]},"content":"最简单、最直观的插入排序算法","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1270,1271]},"content":"性能分析","children":[{"type":"list_item","depth":5,"payload":{"lines":[1272,1273]},"content":"空间效率：仅仅使用到了常数个辅助单元，空间复杂度为O(1)","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1273,1274]},"content":"时间效率：排序过程中，需要向左侧有序子表中逐个插入元素，操作n-1次,每次操作都分为关键字比较和元素移动这两部分的次数非常依赖于待排序表的初始状态【重要】","children":[{"type":"list_item","depth":6,"payload":{"lines":[1275,1276]},"content":"最好的情况：元素已经有序，每个元素之需要比较一次，不用移动元素，O(n)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1276,1277]},"content":"最坏的情况：元素逆序，比较多次，移动多次，O(n^2)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1277,1279]},"content":"平均情况：总的比较次数和总的移动次数均约等于为(n^2)/4
\n​","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1280,1281]},"content":"稳定性: 【稳定】的排序算法","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1281,1282]},"content":"适用性","children":[{"type":"list_item","depth":6,"payload":{"lines":[1283,1284]},"content":"顺序存储的线性表","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1284,1285]},"content":"链式存储的线性表","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1285,1286]},"content":"大部分排序算法都仅仅适用于顺序存储的线性表【重要】","children":[]}]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[1287,1288]},"content":"折半插入排序","children":[{"type":"list_item","depth":4,"payload":{"lines":[1289,1290]},"content":"简述","children":[{"type":"list_item","depth":5,"payload":{"lines":[1291,1292]},"content":"直接插入：边比较边移动","children":[{"type":"list_item","depth":6,"payload":{"lines":[1293,1294]},"content":"确定插入位置","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1294,1295]},"content":"腾出空间，元素复制到插入位置","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1296,1297]},"content":"折半插入：先比较再统一移动","children":[{"type":"list_item","depth":6,"payload":{"lines":[1298,1299]},"content":"确定好待插入的位置后，再统一地向后移动元素","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[1300,1301]},"content":"性能分析","children":[{"type":"list_item","depth":5,"payload":{"lines":[1302,1303]},"content":"折半插入排序的比较次数与待排序表的初始状态无关，仅仅取决于表中的元素个数n","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1303,1304]},"content":"移动元素的次数相比直接插入排序没有任何的改变","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1304,1305]},"content":"直接插入排序和折半插入排序的比较次数一样，依赖于排序表的初始状态","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1305,1306]},"content":"时间复杂度：O(n^2)","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1306,1307]},"content":"稳定性：【稳定】的排序算法","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[1308,1309]},"content":"希尔排序（缩小增量排序）","children":[{"type":"list_item","depth":4,"payload":{"lines":[1310,1311]},"content":"基本思想：将待排序表分割成为若干个L[i,i+d,i+2d,....,i+kd]的子表，分别进行直接插入排序,当整个表元素“基本有序”的时候，再对全体记录进行一次直接插入排序","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1311,1312]},"content":"基本实现步骤","children":[{"type":"list_item","depth":5,"payload":{"lines":[1313,1314]},"content":"第一步：取一个小于n的步长d1 ，把待排序的表分成d1个组，所有距离为d1的倍数的记录放在同一个组中，对各组进行直接插入排序","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1314,1315]},"content":"第二步：取第二个步长d2 < d1，重复第一步","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1316,1317]},"content":"主要操作","children":[{"type":"list_item","depth":5,"payload":{"lines":[1318,1319]},"content":"确认步长，分组","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1319,1320]},"content":"对分组元素进行直接插入排序","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1321,1322]},"content":"性能分析","children":[{"type":"list_item","depth":5,"payload":{"lines":[1323,1324]},"content":"空间效率：仅仅使用到了常数个辅助单元，O(1)","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1324,1325]},"content":"时间效率","children":[{"type":"list_item","depth":6,"payload":{"lines":[1326,1327]},"content":"直接插入排序","children":[{"type":"list_item","depth":7,"payload":{"lines":[1328,1329]},"content":"是顺序的，时间复杂度最最小，O(n)","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1329,1330]},"content":"是逆序的，时间复杂度最大，O(n^2)","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1330,1331]},"content":"是局部有序的，即部分顺序、部分逆序，此时的时间复杂度介于两者之间，O(n)~O(n^2)","children":[]}]},{"type":"list_item","depth":6,"payload":{"lines":[1332,1333]},"content":"取决于增量序列函数","children":[{"type":"list_item","depth":7,"payload":{"lines":[1334,1335]},"content":"优于折半插入排序","children":[]},{"type":"list_item","depth":7,"payload":{"lines":[1335,1336]},"content":"最坏情况为O(n^2)","children":[]}]}]},{"type":"list_item","depth":5,"payload":{"lines":[1337,1338]},"content":"稳定性：【不稳定】，存在相同值元素分在不同的组进行直接插入排序","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1338,1339]},"content":"适用性：仅仅适用于顺序存储的线性表，虽然采用过程中有采用直接插入排序，但增量序列不为1的时候，需要随机存取，链式存储的时候无法满足","children":[]}]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1340,1341]},"content":"交换排序","children":[{"type":"list_item","depth":3,"payload":{"lines":[1342,1343]},"content":"冒泡排序","children":[{"type":"list_item","depth":4,"payload":{"lines":[1344,1345]},"content":"算法简单、思路直接、十分常用但考查少","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1345,1346]},"content":"两元素交换方案","children":[{"type":"list_item","depth":5,"payload":{"lines":[1347,1348]},"content":"临时变量法","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1348,1349]},"content":"加减法","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1350,1351]},"content":"空间效率","children":[{"type":"list_item","depth":5,"payload":{"lines":[1352,1353]},"content":"仅使用了常数个辅助单元","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1353,1354]},"content":"空间复杂度为O(1)","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1355,1356]},"content":"时间效率","children":[{"type":"list_item","depth":5,"payload":{"lines":[1357,1358]},"content":"最好情况（顺序）","children":[{"type":"list_item","depth":6,"payload":{"lines":[1359,1360]},"content":"比较次数：n-1","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1360,1361]},"content":"移动次数：0","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1361,1362]},"content":"时间复杂度为：O(n)","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1363,1364]},"content":"最坏情况（逆序）","children":[{"type":"list_item","depth":6,"payload":{"lines":[1365,1366]},"content":"比较次数：每趟比较(n-i)次","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1366,1367]},"content":"移动次数：每趟移动3次","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1367,1368]},"content":"时间复杂度为：O(n^2)","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1369,1370]},"content":"时间复杂度为：O(n^2)","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1371,1372]},"content":"稳定性：【稳定】","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1373,1374]},"content":"快速排序","children":[{"type":"list_item","depth":4,"payload":{"lines":[1375,1376]},"content":"基于递归、理解困难、分而治之、关键基准pivot划分","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1376,1377]},"content":"空间效率","children":[{"type":"list_item","depth":5,"payload":{"lines":[1378,1379]},"content":"基于递归实现，需要借助递归工作栈来保存每一次递归调用的必要信息","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1379,1380]},"content":"最坏情况：进行n-1次递归，O(n)","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1380,1381]},"content":"最好情况: log2(n+1) 向上取整","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1381,1382]},"content":"平均情况： O((n+1)以2为底的对数)","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1383,1384]},"content":"时间效率","children":[{"type":"list_item","depth":5,"payload":{"lines":[1385,1386]},"content":"运行时间与划分操作Partition()函数【不对称相关】","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1386,1387]},"content":"最坏情况","children":[{"type":"list_item","depth":6,"payload":{"lines":[1388,1389]},"content":"数组长度为n","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1389,1390]},"content":"左侧快排的数组长度为n-1,有n-1个元素【初始排序表基本有序】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1390,1391]},"content":"右侧快排的数组长度为0，有0个元素【初始排序表基本逆序】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1391,1392]},"content":"时间复杂度为：O(n^2）","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1393,1394]},"content":"效率优化","children":[{"type":"list_item","depth":6,"payload":{"lines":[1395,1396]},"content":"递归过程中划分得到的子序列规模较小时候，不再递归调用快速排序 ----->改用直接插入排序【时间复杂度最好O(n),性能好】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1396,1397]},"content":"尽量选择能将数据中分的基准值元素","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1397,1398]},"content":"随机从当前表中选取基准值元素，几乎避免最坏情况的发生","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[1399,1400]},"content":"稳定性：【不稳定】，存在值相同的元素，位置与最终位置不一致情况","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1400,1401]},"content":"重要：【是所有内部算法中平均新能最优的排序算法】","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1402,1403]},"content":"选择排序（TBD）","children":[{"type":"list_item","depth":3,"payload":{"lines":[1404,1405]},"content":"简单选择排序","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1405,1406]},"content":"堆排序","children":[]}]},{"type":"heading","depth":2,"payload":{"lines":[1407,1408]},"content":"归并排序（TBD）","children":[]},{"type":"heading","depth":2,"payload":{"lines":[1409,1410]},"content":"基数排序","children":[{"type":"list_item","depth":3,"payload":{"lines":[1411,1412]},"content":"很特别的排序算法，【不是基于比较进行排序的】","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1412,1413]},"content":"基本步骤【趟数取决于元素的最大位数】","children":[{"type":"list_item","depth":4,"payload":{"lines":[1414,1415]},"content":"分配：依次考察线性表元素，放入队列中","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1415,1416]},"content":"收集：各队列中结点一次首尾相接，组成新的线性表","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1417,1418]},"content":"分类","children":[{"type":"list_item","depth":4,"payload":{"lines":[1419,1420]},"content":"最高位优先排序【MSD】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1420,1421]},"content":"最低位优先排序【LSD】","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1422,1423]},"content":"性能分析","children":[{"type":"list_item","depth":4,"payload":{"lines":[1424,1425]},"content":"空间效率：","children":[{"type":"list_item","depth":5,"payload":{"lines":[1426,1427]},"content":"一趟排序需要r个队列的辅助存储空间，后续排序这些队列将会复用","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1427,1428]},"content":"空间复杂度为：O(n)","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1429,1430]},"content":"时间效率","children":[{"type":"list_item","depth":5,"payload":{"lines":[1431,1432]},"content":"进行d趟分配和收集操作","children":[{"type":"list_item","depth":6,"payload":{"lines":[1433,1434]},"content":"一趟分配需要O(n)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1434,1435]},"content":"一趟收集需要O(r)","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1436,1437]},"content":"平均情况：时间复杂度为O(d*(n+r))","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1437,1438]},"content":"【重要】算法的时间效率与初始排序表状态无关，依赖于分配和收集操作","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1439,1440]},"content":"稳定性：【稳定】<----- 按位排序必须稳定","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1441,1442]},"content":"内部排序","children":[{"type":"list_item","depth":3,"payload":{"lines":[1443,1444]},"content":"各算法性能比较","children":[{"type":"list_item","depth":4,"payload":{"lines":[1445,1446]},"content":"从时间复杂度来看","children":[{"type":"list_item","depth":5,"payload":{"lines":[1447,1448]},"content":"平均情况O(n^2)","children":[{"type":"list_item","depth":6,"payload":{"lines":[1449,1450]},"content":"直接插入排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1450,1451]},"content":"简单选择排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1451,1452]},"content":"冒泡排序","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1453,1454]},"content":"最好情况O(n)【顺序情况】","children":[{"type":"list_item","depth":6,"payload":{"lines":[1455,1456]},"content":"直接插入排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1456,1457]},"content":"冒泡排序","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1458,1459]},"content":"O(nlog2n)","children":[{"type":"list_item","depth":6,"payload":{"lines":[1460,1461]},"content":"归并排序与初始序列的排序列无关，所有情况下时间复杂度都是O(nlog2n)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1461,1462]},"content":"堆排序利用数据结构堆，线性时间完成建堆，在O(nlog2n)内完成排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1462,1463]},"content":"快排平均性能可以达到O(nlog2n)【性能常常优于其他排序算法】","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1464,1465]},"content":"基于分治法的思想","children":[{"type":"list_item","depth":6,"payload":{"lines":[1466,1467]},"content":"快速排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1467,1468]},"content":"归并排序","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1469,1470]},"content":"简单选择排序与序列的初始值状态无关","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1470,1471]},"content":"希尔排序是插入排序的拓展，在大规模排序中可以达到很高的效率n^1.3~2","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1472,1473]},"content":"从空间复杂度来看","children":[{"type":"list_item","depth":5,"payload":{"lines":[1474,1475]},"content":"借助常数个辅助空间","children":[{"type":"list_item","depth":6,"payload":{"lines":[1476,1477]},"content":"简单选择排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1477,1478]},"content":"插入排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1478,1479]},"content":"冒泡排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1479,1480]},"content":"希尔排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1480,1481]},"content":"堆排序","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1482,1483]},"content":"快速排序在空间上只适用一个小的辅助栈，实现【递归】","children":[{"type":"list_item","depth":6,"payload":{"lines":[1484,1485]},"content":"平均情况：O(log2n)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1485,1486]},"content":"最坏情况：O(n)","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1487,1488]},"content":"二路归并排序需要较多的辅助空间，为O(n)，可以采取时间换空间的思路来减少辅助空间【不建议，导致算法复杂】","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1489,1490]},"content":"从稳定性来看","children":[{"type":"list_item","depth":5,"payload":{"lines":[1491,1492]},"content":"稳定的","children":[{"type":"list_item","depth":6,"payload":{"lines":[1493,1494]},"content":"插入排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1494,1495]},"content":"冒泡排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1495,1496]},"content":"归并排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1496,1497]},"content":"基数排序","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1498,1499]},"content":"不稳定","children":[{"type":"list_item","depth":6,"payload":{"lines":[1500,1501]},"content":"简单选择排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1501,1502]},"content":"快速排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1502,1503]},"content":"希尔排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1503,1504]},"content":"堆排序","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[1505,1506]},"content":"从过程特征来看","children":[{"type":"list_item","depth":5,"payload":{"lines":[1507,1508]},"content":"冒泡排序和堆排序每次循环都能拿到当前的最大值或最小值","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1508,1509]},"content":"快速排序每次循环都能确定一个元素到最终位置上","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1509,1510]},"content":"冒泡排序每一趟冒泡也能确定一个元素到最终位置上","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[1511,1512]},"content":"算法运用","children":[{"type":"list_item","depth":4,"payload":{"lines":[1513,1514]},"content":"排序方法选取需要考虑的因素","children":[{"type":"list_item","depth":5,"payload":{"lines":[1515,1516]},"content":"待排序的元素数目n","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1516,1517]},"content":"元素本身信息量大小","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1517,1518]},"content":"关键字的结构和分布情况","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1518,1519]},"content":"稳定性的要求","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1519,1520]},"content":"语言工具、存储结构、辅助空间大小","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1521,1522]},"content":"排序算法小结","children":[{"type":"list_item","depth":5,"payload":{"lines":[1523,1524]},"content":"n很小时选择","children":[{"type":"list_item","depth":6,"payload":{"lines":[1525,1526]},"content":"直接插入排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1526,1527]},"content":"简单插入排序","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1528,1529]},"content":"关键字基本【有序】时选择","children":[{"type":"list_item","depth":6,"payload":{"lines":[1530,1531]},"content":"直接插入排序","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1531,1532]},"content":"冒泡排序","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1533,1534]},"content":"n较大时选择O(nlog2n)的排序","children":[{"type":"list_item","depth":6,"payload":{"lines":[1535,1536]},"content":"快速排序【不稳定】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1536,1537]},"content":"堆排序【不稳定】","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1537,1538]},"content":"归并排序【稳定】","children":[]}]},{"type":"list_item","depth":5,"payload":{"lines":[1539,1540]},"content":"n很大且关键字位较少、可分解，建议选择【基数排序】","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1540,1541]},"content":"信息量较大、元素较多，存储结构可以采用【链表】，减少不必要的时间去元素移动","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1542,1543]},"content":"快速排序被认为是基于比较的内部排序中最好的排序方法","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1543,1544]},"content":"基于比较的排序算法中，每次比较两个关键字之后，只有两种情况（大于|小于）----> 二叉树， 时间复杂度至少为O(nlog2n)","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1545,1546]},"content":"外部排序","children":[{"type":"list_item","depth":3,"payload":{"lines":[1547,1548]},"content":"基本概念","children":[{"type":"list_item","depth":4,"payload":{"lines":[1549,1550]},"content":"内部排序：排序方法在内存中进行的排序","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1550,1551]},"content":"外部排序：排序过程中需要多次进行内存、外存交换，对外存文件中的记录进行排序后【仍然存放在外存原有文件中】的排序","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1551,1552]},"content":"外部排序原因：对大文件进行排序，内存控件有限，文件中信息量庞大，无法将整个文件拷贝进内存中进行排序，需要多次调入内存进行排序","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1553,1554]},"content":"外部排序方法","children":[{"type":"list_item","depth":4,"payload":{"lines":[1555,1556]},"content":"分类【依据外存设备的不同】","children":[{"type":"list_item","depth":5,"payload":{"lines":[1557,1558]},"content":"磁盘文件排序","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1558,1559]},"content":"磁带文件排序","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1560,1561]},"content":"分布方式","children":[{"type":"list_item","depth":5,"payload":{"lines":[1562,1563]},"content":"磁盘是直接存取设备","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1563,1564]},"content":"磁带是顺序存取设备","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1565,1566]},"content":"文件通常是【按块存储】在磁盘上，操作系统也是【按块读取】磁盘上的信息","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1566,1567]},"content":"外部排序中时间代价主要考虑【访问磁盘的次数】，即I/O次数","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1567,1568]},"content":"【通常采用归并排序方法】","children":[]}]}]},{"type":"heading","depth":2,"payload":{"lines":[1569,1570]},"content":"补充总结和复习","children":[{"type":"list_item","depth":3,"payload":{"lines":[1571,1572]},"content":"元素个数不是很大（n<1000）","children":[{"type":"list_item","depth":4,"payload":{"lines":[1573,1574]},"content":"直接插入排序【稳定】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1574,1575]},"content":"冒泡排序【稳定】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1575,1576]},"content":"简单选择排序【不稳定】","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1576,1577]},"content":"空间复杂度都为O(1)，只需要一个辅助元素","children":[]},{"type":"list_item","depth":4,"payload":{"lines":[1577,1578]},"content":"平均时间复杂度都为O(n^2)","children":[]}]},{"type":"list_item","depth":3,"payload":{"lines":[1579,1580]},"content":"中等规模的元素，希尔排序【不稳定】是非常好的选择，比直接插入排序要好（n越大越明显），不占用额外内存空间，减少直接排序次数","children":[]},{"type":"list_item","depth":3,"payload":{"lines":[1580,1581]},"content":"元素个数很多（n很大）","children":[{"type":"list_item","depth":4,"payload":{"lines":[1582,1583]},"content":"快速排序【不稳定】","children":[{"type":"list_item","depth":5,"payload":{"lines":[1584,1585]},"content":"最通用、高效的内部排序算法","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1585,1586]},"content":"平均时间复杂度为O(nlog2n)","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1586,1587]},"content":"一般空间复杂度为O(log2n)","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1587,1588]},"content":"最快情况，性能退化【元素基本有序时】","children":[{"type":"list_item","depth":6,"payload":{"lines":[1589,1590]},"content":"时间复杂度提高到O(n^2)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1590,1591]},"content":"空间复杂度提高到O(n)","children":[]},{"type":"list_item","depth":6,"payload":{"lines":[1591,1592]},"content":"解决方案： 三者(low,mid,high)取中，获取枢纽值【注意严版采用的是low,high】","children":[]}]}]},{"type":"list_item","depth":4,"payload":{"lines":[1593,1594]},"content":"堆排序【不稳定】","children":[{"type":"list_item","depth":5,"payload":{"lines":[1595,1596]},"content":"高效的内部排序算法","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1596,1597]},"content":"时间复杂度为O(nlog2n)","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1597,1598]},"content":"没啥最坏情况，基本不需要额外的存储空间","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1599,1600]},"content":"归并排序【稳定】","children":[{"type":"list_item","depth":5,"payload":{"lines":[1601,1602]},"content":"性能与初始化元素序列无关","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1602,1603]},"content":"时间复杂度总为O(nlog2n)","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1603,1604]},"content":"【明显缺点】：需要O(n)的额外存储空间","children":[]}]},{"type":"list_item","depth":4,"payload":{"lines":[1605,1606]},"content":"基数排序【稳定】","children":[{"type":"list_item","depth":5,"payload":{"lines":[1607,1608]},"content":"特殊的排序算法","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1608,1609]},"content":"除了对元素序列的关键字比较，更对关键字的不同位也进行处理和比较","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1609,1610]},"content":"具有线性增长的时间复杂度O(d*(n+r))，适用性比较低、应用场景相对少","children":[]},{"type":"list_item","depth":5,"payload":{"lines":[1610,1611]},"content":"需要额外的存储空间，一般用队列来实现桶","children":[]}]}]},{"type":"list_item","depth":3,"payload":{"lines":[1612,1613]},"content":"【重要】不同的排序算法缓和使用，往往能够对算法进行不错的改进，获得更好的性能","children":[]}]}]}]},null) diff --git a/docs/.vuepress/public/mark-map/os-map.html b/docs/.vuepress/public/mark-map/os-map.html index 1e4e743..80bc2dd 100644 --- a/docs/.vuepress/public/mark-map/os-map.html +++ b/docs/.vuepress/public/mark-map/os-map.html @@ -16,11 +16,11 @@ height: 100vh; } - + - + })(() => window.markmap,null,{"type":"heading","depth":0,"payload":{"lines":[1,2]},"content":"操作系统","children":[{"type":"fence","depth":1,"content":"
root(操作系统)\n  (系统概述)\n  (进程管理)\n  (进程管理)\n  (文件管理)\n  (输入、输出管理)\n
\n","children":[],"payload":{"lines":[3,11]}},{"type":"heading","depth":1,"payload":{"lines":[14,15]},"content":"引论","children":[]},{"type":"heading","depth":1,"payload":{"lines":[16,17]},"content":"进程管理","children":[]},{"type":"heading","depth":1,"payload":{"lines":[18,19]},"content":"内存管理","children":[]},{"type":"heading","depth":1,"payload":{"lines":[20,21]},"content":"一些总结","children":[]},{"type":"heading","depth":1,"payload":{"lines":[22,23]},"content":"I/O管理","children":[]},{"type":"heading","depth":1,"payload":{"lines":[24,25]},"content":"文件管理","children":[]}]},null) diff --git a/docs/manuscripts/ds/查找/1.基本概念.md b/docs/manuscripts/ds/查找/1.基本概念.md index d96401e..8523bc7 100644 --- a/docs/manuscripts/ds/查找/1.基本概念.md +++ b/docs/manuscripts/ds/查找/1.基本概念.md @@ -5,4 +5,28 @@ permalink: /manuscripts/ds/search-algorithm/base-concept.html # 基本概念 -努力赶稿中，等等我呀... +查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找 + +## 查找 + +在数据集合中寻找满足某种条件的数据元素的过程就是查找，查找的结果有两种： + +- 查找成功，找到目标 +- 查找失败，没有找到目标 + +## 查找表 + +查找表也可以称为查找结构，用于查找的数据集合就是查找表。由同一类型的数据元素（记录组成），常见的就是数组、链表等数据结构. + +对查找表可以做的操作有： + +- 查询某个特定元素是否在查找表中 +- 检索满足条件的某特特定元素的数据元素的各种属性 +- 在查找表中插入数据元素 +- 从查找表中删除某个数据元素 + +## 静态查找表 + +## 关键字 + +## 平均查找长度 diff --git a/nginx.conf b/nginx.conf index 6eb8641..8f1bb62 100644 --- a/nginx.conf +++ b/nginx.conf @@ -30,14 +30,16 @@ http { root /usr/share/nginx/html; index index.html index.htm; -# # 确保能够处理前端路由，并在找不到对应文件或目录时返回 index.html 文件，让前端应用接管路由处理。 -# # 这对于使用前端框架（如 Vue.js、React、Angular 等）开发的单页应用非常有用 -# # 如果vue-router使用的是history模式，需要设置这个 -# try_files $uri $uri/ /index.html; + # 确保能够处理前端路由，并在找不到对应文件或目录时返回 index.html 文件，让前端应用接管路由处理。 + # 这对于使用前端框架（如 Vue.js、React、Angular 等）开发的单页应用非常有用 + # 如果vue-router使用的是history模式，需要设置这个 + # try_files $uri $uri/ /index.html; } ## 错误页面 error_page 404 /404.html; error_page 500 502 503 504 /50x.html; + + ## 服务端异常跳转页面 location = /50x.html { root /usr/share/nginx/html; } diff --git a/scripts/bundle b/scripts/bundle index bfb949b..c7dbbd7 100755 --- a/scripts/bundle +++ b/scripts/bundle @@ -163,7 +163,9 @@ async function getScriptCommand() { return scriptCommand } - +/** + * 执行构建命令 + */ ;(async () => { const scriptCommand = await getScriptCommand() await execShell(scriptCommand) diff --git a/scripts/deploy b/scripts/deploy index 096547d..055ed1f 100755 --- a/scripts/deploy +++ b/scripts/deploy @@ -80,8 +80,9 @@ function getDeployCommand() { return deployCommand } - -// 执行 +/** + * 执行部署相关命令 + */ ;(async () => { const deployCommand = getDeployCommand() // console.log(deployCommand) diff --git a/scripts/docker b/scripts/docker index d54adb2..b3505bb 100755 --- a/scripts/docker +++ b/scripts/docker @@ -10,7 +10,6 @@ const { execShell } = require('./.exec') const scriptName = process.argv[2] - /** * 网络基础信息 * - 网络名称 @@ -170,7 +169,6 @@ function getCommand() { } } - // 执行 ;(async() => { const command = getCommand(scriptName)