数据结构（王晓东版代码）

Monster2022

已于 2024-08-22 10:40:30 修改

阅读量1k

点赞数 9

文章标签：数据结构算法

于 2024-08-13 08:30:25 首次发布

本文链接：https://blog.csdn.net/weixin_55288675/article/details/127289807

版权

文章目录

前言
第1章绪论
第2章线性表
第3章栈与队列
第5章树
第6章图
第7章查找
第8章排序

前言

一、答题规范

时间复杂度O()只算级别，所以O(2n+100)肯定是错的，要改成O(n)

基本上从左到右，从小到大

结构体内属性不能直接写，记得xxx->xx，就算打草稿画图也要这样，避免抄过去的时候出错。

算法设计：其它空写0，树的写NULL（按王晓东的来）

二、考点

考代码：23章的线性表插入删除查找、出栈入栈、出队入队。老高说算法设计现在两题都是程序填空（但大海没这么说）

考概念、画图：56章

56章很少考代码

三、大海7押3应用题

第5章遍历二叉树

第5章树与二叉树的相互转换

第5章哈夫曼树

第6章邻接矩阵和邻接表

第6章最小生成树

第7章哈希表

第8章排序

第1章绪论

算法是由若干条指令组成的有穷序列

算法的5个性质：输入、输出、有穷性、确定性、可行性

5个性质中哪个非必要：输入

算法复杂度的度量依据是：运行该算法所需要的计算机资源的多少

数据元素是数据的基本单位

数据项是最小数据单位

二元组S=(D,R)

D数据，R关系

<a1,a2>表示a1→a2，(a1,a2)表示a1—a2

（考过大题）可能会考给出树写二元组，或者给出二元组画树：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lnCPN5Up-1665576954380)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221009125046400.png)]

D={1,2,3,4,5,6,7,8}
R={(1,2),(1,3),(1,4),(2,5),(2,6),(4,7),(4,8)}

集合：集合内元素无关联，所以树不是集合

第2章线性表

一、顺序存储

顺序存储结构的优点：方便查找，随机存取

typedef struct alist *List;
typedef struct alist {
    int n;
    int maxsize;
    ListItem table;
}Alist;

void ListInsert(int k,ListItem x,List L)
{
    int i;
    if(k<0||k>L->n) Error("out of bounds");
    if(L->n==L->maxsize) Error("out of memory");
    for(i=L->n-1;i>=k;i--) L->table[i+1]=L->table[i];
    L->table[k]=x;
    L->n++;
}

ListItem ListDelete(int k,List L)
{
    int i; ListItem x;
    if(k<1||k>L->n) Error("out of bounds");
    x=L->table[k-1];
    for(i=k;i<L->n;i++) L->table[i-1]=L->table[i];
    L->n--;
    return x;
}

插入一个新元素需要移动元素的平均次数为：n/2

删除一个新元素需要移动元素的平均次数为：(n-1)/2

二、链式存储

链式存储结构的缺点：需要更多存储空间，查找不方便

判断链表是否为空：head->next==NULL

1. 单链表

typedef struct node *link;
typedef struct node {ListItem element,link next;}Node;

// 找序号查找
ListItem ListRetrieve(int k,List L)
{
    int i;
    link p;
    if(k<1) Error("out of bounds");
    p=L->first;i=1;
    while(i<k&&p) {p=p->next;i++;}
    return p->element;
}

// 找值查找
int ListLocate(ListItem x,List L)
{
    int i=1;
    link p;
    p=L->first;
    while(p&&p->element!=x) {p=p->next;i++;}
    return p?i:0;
}

void ListInsert(int k,ListItem x,List L)
{
    link p,y;
    int i;
    if(k<0) Error("out of bounds");
    p=L->first;
    for(i=1;i<k&&p;i++) p=p->next;
    y=malloc(sizeof *y);
    y->element=x;
    if(k) {y->next=p->next;p->next=y;}
    else {y->next=L->first;L->first=y;}
}

ListItem ListDelete(int k,List L)
{
    link p,q;
    ListItem x;
    int i;
    if(k<1||!L->first) Error("out of bounds");
    p=L->first;
    if(k==1) L->first=p->next;
    else
    {
        q=L->first;
        for(i=1;i<k-1&&q;i++) q=q->next;
        p=q->next;
        q->next=p->next;
    }
    x=p->element;free(p);
    return x;
}

2. 双链表

在双向链表中间插入一个结点，需要修改左右两个方向的指针。

typedef struct node *link;
typedef struct node {ListItem element;link left,right;}Node;

typedef struct dlist *List;
typedef struct dlist {
    int n;
    link header;
}Dlist;

void ListInsert(int k,ListItem x,List L)
{
    link p,y;
    int i;
    if(k<0||k>L->n) Error("out of bounds");
    p=L->header->right;
    for(i=1;i<k;i++) p=p->right;
    y=malloc(sizeof *y);
    y->element=x;
    y->left=p;
    y->right=p->right;
    p->right->left=y;
    p->right=y;
    L->n++;
}

ListItem ListDelete(int k,List L)
{
    link p;
    ListItem x;
    int i;
    if(k<1||k>L->n) Error("out of bounds");
    p=L->header->right;
    for(i=1;i<k;i++) p=p->right;
    p->left->right=p->right;
    p->right->left=p->left;
    x=p->element;
    free(p);
    L->n--;
    return x;
}

第3章栈与队列

一、栈

栈称为后进先出表，简称LIFO表

栈，又叫堆栈

1. 顺序存储

typedef struct astack *Stack;
typedef struct astack {
    int top, maxtop; // 栈顶位置，栈顶位置的最大值
    StackItem data;
}Astack;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mKqTBfIl-1665576954382)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221009150105818.png)]

s->top==-1时栈为空；s->top==MAXLEN-1时栈满
栈空时删除元素，栈将“下溢”；栈满时插入元素，栈将“上溢”

// 进栈
void Push(StackItem x,Stack S)
{
    if(S->top>=maxtop) Error("Stack is full");
    else S->data[++S->top]=x;
}

// 出栈
StackItem Pop(Stack S)
{
    if(S->top>=S->maxtop) Error("Stack is empty");
    else return S->data[S->top--];
}

2. 链式存储

typedef struct snode *slink;
typedef struct snode {StackItem element;slink next;}StackNode;

typedef struct lstack *Stack;
typedef struct lstack {
    slink top;
}Lstack;

// 进栈
void Push(StackItem x,Stack S)
{
    slink p;
    p=malloc(sizeof *p)
    p->element=x;
    p->next=S->top;
    S->top=p;
}

// 出栈
StackItem Pop(Stack S)
{
    slink p;StackItem x;
    if(S->top==0) Error("Stack si empty");
    x=S->top->element;
    p->S->top;
    S->top=p->next;
    free(p);
    return x;
}

二、队列

队列又称为先进先出表，简称FIFO表

允许插入的一段称为队尾，允许删除的一端称为队首

1. 顺序存储

1）非循环队列-非王晓东

#define MAXLEN 10
typedef int elementtype;
typedef struct
{
    elementtype element[MAXLEN];
    int front,rear;
}SeQueue;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZqffDdRm-1665576954382)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221009155811973.png)]

队列为空(无论顺序链式循环队列都是这样)：q->front==q->rear

队列为满：q->rear==MAXLEN-1

入队：q->rear=q->rear+1

出队：q->front=q->front+1

// 入队
int Enqueue_sq(SeQueue *q, elementtype x)
{
    if(q->rear==MAXLEN-1)
        return(0);
    q->rear++;
    q->element[q->rear]=x;
    return(1);
}

// 出队
int Delqueue_sq(SeQueue *q, elementtype *x)
{
    if(q->front==q->rear)
        return(0);
    else
    {
        q->front++;
        *x=q->element[q->front];
        return(1);
    }
}

2）循环队列

循环队列为满：(q->rear+1)%MAXLEN==q->front

入队：q->rear=(q->rear+1)%MAXLEN

出队：q->front=(q->front+1)%MAXLEN

【背】队列内元素数量计算公式：(r-f+M)%M

* 循环队列满时，队列中实际上还有一个空闲单元，以防止空队与满队的标志发生冲突

typedef struct aque *Queue;
typedef struct aque{
    int maxsize;
    int front;
    int rear;
    QItem queue;//循环数组
}Aqueue;

// 入队
void EnterQueue(QItem x,Queue Q)
{
    if((Q->rear+1)%Q->maxsize==Q->front) Error("Queue is full");
    Q->rear=(Q->rear+1)%Q->maxsize;
    Q->queue[Q->rear]=x;
}

// 出队
QItem DeleteQueue(Queue Q)
{
    if(Q->front==Q->rear) Error("Queue is empty");
    Q->front=(Q->front+1)%Q->maxsize;
    return Q->queue[Q->front];
}

2. 链式存储

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TUwz3dfV-1665576954383)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221009173512706.png)]

typedef struct qnode *qlink;
struct qnode {QItem element;qlink next;}Qnode;

typedef struct lque *Queue;
typedef struct lque {
    qlink front;
    qlink rear;
}Lqueue;

// 入队
void EnterQueue(QItem x,Queue Q)
{
    qlink p;
    p=malloc(sizeof *p)
    p->element=x;
    p->next=0;
    if(Q->front) Q->rear->next=p;
    else Q->front=p;
    Q->rear=p;
}

// 出队
QItem DeleteQueue(Queue Q)
{
    qlink p;QItem x;
    if(Q->front==0) Error("Queue is empty");
    x=Q->front->element;
    p=Q->front;
    Q->front=Q->front->next;
    free(p);
    return x;
}

第5章树

数据的逻辑结构分为哪两种：线性结构、非线性结构

数据的逻辑结构分为哪三种：线性结构、树形结构、图形结构

一、树

1. 概念

节点的度：有几个孩子

树的度：度最大的结点的度

叶子结点/终端结点：度为0的结点

真祖先：从该结点出发一直网上延申到根结点，中途经过的所有结点都是它的真祖先

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wxJ9V1ud-1665576954384)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010090432784.png)]

E的真祖先是{A,C}

结点的层次：默认根在第一层

树的深度/高度：默认从0开始算。书中结点的最大层次数

2. 存储结构（大题）

1）顺序存储

双亲表示法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iMARsxVd-1665576954385)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010091743585.png)]

2）链式存储

孩子-兄弟链表表示法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jrdQgFt7-1665576954385)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010092245556.png)]

二、二叉树

二叉树的子树有左右之分，次序不能任意颠倒。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DVfzRaL6-1665576954386)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010093521399.png)]

1. 二叉树的性质

性质1

在二叉树的第i层上至多有2^i-1个结点（i≥1）默认层数i从1开始算

性质2

深度为k的二叉树至多有2^k+1-1个结点（k≥0）默认深度k从0开始算

性质3

对任何一棵二叉树T，如果其终端结点数为n₀，度为2的结点数为n₂，则n₀=n₂+1

性质4

具有n个结点的完全二叉树的深度为⌊log₂n⌋。深度默认从0开始

满二叉树

下图这个不是满二叉树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pXXtewYB-1665576954387)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010095217811.png)]

完全二叉树

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HxbZBwDJ-1665576954387)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010095402882.png)]

性质5

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-egEYiYzC-1665576954388)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010100839273.png)]

2. 存储结构（大题）

1）顺序存储

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z4QK8vL9-1665576954388)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010102311552.png)]

2）链式存储

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4cfSOrKb-1665576954389)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010102507369.png)]

考的不是画图，考的是：给出左图，问用链式存储会有几个空指针（答案是7），为节约时间考试时不用画出右图

3. 二叉树的遍历

1）DLR先序遍历，LDR中序遍历，LRD后序遍历（大题）

// 中序遍历-非重点（重点是给树写遍历和给遍历写树，代码大概率不考）LDF(node *root){    if(root!=NULL)    {        LDR(root->lchild);        printf("%d", root->data);        LDR(root->rchild);    }    return(0);}

自己调用自己的数据结构叫做递归

2）层次遍历

二叉树的层次遍历需要队列来辅助存储

4. 线索二叉树

空左孩子指针指向前驱，空右孩子指针指向后继

背（填空题）：

ltag=0：lchild指向该结点的左孩子

ltag=1：lchild指向该结点的前驱

rtag=0：rchild指向该结点的右孩子

rtag=1：rchild指向该结点的后继

5. 二叉排序树/二叉搜索树（大题）

左<根≤右

给值：12、5、17、3、5、14、20、9

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xVnsRJWR-1665576954390)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010112509132.png)]

优点：插入方便、查找方便、删除方便

三、树、森林与二叉树之间的转换（大题）

1. 树与二叉树转换法：左孩子右兄弟

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3YDPHTji-1665576954390)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010113252881.png)]

2. 森林与二叉树转换

四、哈夫曼树（大题）

哈夫曼树又称最优二叉树，是树的带权路径长度最短的树

树的带权路径长度：树中所有叶子结点的带权路径长度之和

例：已知权值W={5,6,2,9,7}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-idDJKJN5-1665576954391)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010141453080.png)]

选择题：根据10个权值生成的哈夫曼树，总共几个结点？19个

n₀=10，二叉树性质3得n₂=n₀-1=9

哈夫曼编码：是前缀编码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G7trLnGW-1665576954391)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010185136368.png)]

题中需要自己算权值时：电文中字符出现几次权值就是几

第6章图

可能会考给出集合画图，或给图写集合：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f0yUP7hv-1665576954392)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010144718990.png)]

边只能画直线

V表示顶点，E表示边

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EXgAQrf0-1665576954393)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010145206031.png)]

有向图的边称为弧

一、图的基本术语

1. 完全图（重点）

边的数最大化的图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gg8MWu1p-1665576954393)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010145803873.png)]

n个顶点的无向完全图，有***(n-1)n/2***条边

n个顶点的有向完全图，有***(n-1)n***条边

2. 度、入度和出度（大题）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eHiYJYVO-1665576954394)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010151601378.png)]

3. 其它术语

连通图（对无向图而言，任意两顶点都是连通的）和强连通图（对有向图而言）
连通分量和强连通分量
权和网：带权图称为网

再其它可忽略：子图、路径、简单路径、回路和简单回路、邻接点和相关边

二、存储结构（大题）

1. 邻接矩阵

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QPBW6teM-1665576954394)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010162108956.png)]

无向图的邻接矩阵关于对角线是对称的

有向图只算出度。行为出度、列为入度。度为出度加入度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WLn9myzb-1665576954395)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010162857754.png)]

2. 邻接表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-902MpKHM-1665576954395)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010163931744.png)]

如果题目不是V₀、V₁而直接是0、1这样，表左边的序号就不用写了（考试一般都是1、2、3、4、5这样子）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ttufxBWF-1665576954396)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010170549768.png)]

有向图只算出度

三、图的遍历

1. 深度优先搜索DFS

图的深度优先搜索类似于树的先序遍历，需要栈来辅助存储

以V₀为起点做深度优先搜索：V0，V1，V3，V7，V4，V2，V5，V6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z4X8yI5I-1665576954396)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010180905331.png)]

2. 广度优先搜索BFS

图的广度优先搜索类似于树的层次遍历，需要队列来辅助存储

以V₀为起点做广度优先搜索：V0，V1，V2，V3，V4，V5，V6，V7

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V66U1Zvx-1665576954397)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010181413334.png)]

* 该图V4完必须跟V5，因为V1遍历完遍历V2。参考队列

四、最小生成树（大题）

1. 普里姆算法（Prim）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-txPB31lM-1665576954397)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010183311551.png)]

2. 克鲁斯卡尔算法（Kruskal）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GW9bjitN-1665576954398)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010183342018.png)]

五、最短路径：迪杰斯特拉算法（大题）

e.g.1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lwRjIMrR-1665576954398)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221011170704952.png)]

e.g.2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zeMKZltj-1665576954399)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010192217798.png)]

求从V₀到各终点的最短路径

答题（不要在答题卡上画表）：

min_path[0,1]=(0,2)+(2,3)+(3,1)=10+15+20=45min_path[0,2]=(0,2)=10min_path[0,3]=(0,2)+(2,3)=10+15=25min_path[0,4]=(0,4)=45

六、关键路径

带权路径长度最长的路径称为关键路径。

可能会考找出关键路径（可能不止一条）

第7章查找

一、顺序查找

从后往前一个个找

时间复杂度为O(n)

二、二分查找

前提：序列顺序且有序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RRp9N81o-1665576954401)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010201502191.png)]

切半时有两个值选第一个：如图中low21和high37，mid选21

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H1LJgv3r-1665576954402)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010201844718.png)]

low>high时查找失败

考试给一个序列，问要查找几次才能找到。

三、分块查找

n个元素，分几个块比较好？ $\sqrt{n}$ 个

四、散列/哈希查找

对于不同的键值可能得到相同的散列地址，即K₁≠K₂而H(K₁)=H(K₂)，这种现象称为冲突。具有相同函数值的键值称为该散列函数的同义词。

散列查找次数和表长无直接关系，和表的填满程度/填满因子α有关

填满因子α=记录数/表长

构建散列函数：除留余数法（大题）

H(k)=k%p

p取小于等于表长的最大素数

解决冲突的办法——线性探查法：往右边一个个找有没有位置，右边都没有就跳到最左然后再往右一个个找

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-afs2poUv-1665576954402)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010205051102.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ge1uDEmf-1665576954403)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221010205055564.png)]

第8章排序

一、插入排序

初始关键字：49 38 65 97 76 13 27

答题：

第一遍：38 49 65 97 76 13 27第二遍：38 49 65 97 76 13 27第三遍：38 49 65 97 76 13 27第四遍：38 49 65 76 97 13 27第五遍：13 38 49 65 76 97 27第六遍：13 27 38 49 65 76 97

参考图片：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eeAetXi3-1665576954404)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221011125824173.png)]

二、冒泡排序

考试是从后往前两两比较！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2deu3yp1-1665576954404)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221011140245105.png)]

三、快速排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MMXaW45I-1665576954405)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221011140215021.png)]

四、简单选择排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y4HmDVkq-1665576954405)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221011130816635.png)]

五、堆排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jSmgXEh2-1665576954406)(D:\Users\玄离\Pictures\Typora\老高-数据结构\image-20221011133118974.png)]

步骤：将大顶堆的根拿下来，写最后。把最后一个结点放到根上，按顺序抄下来写前面。然后重建大顶堆

答案：

第一遍：36 67 56 37 42 11 27 78
第二遍：27 42 56 37 36 11 67 78
第三遍：11 42 27 37 36 56 67 78
第四遍：36 37 27 11 42 56 67 78
第五遍：11 36 27 37 42 56 67 78
第六遍：27 11 36 37 42 56 67 78
第七遍：11 27 36 37 42 56 67 78

六、总结

对一种基本有序的序列，用哪种排序最快：直接插入排序

排序方法	时间复杂度	空间复杂度	稳定性
插入排序	O(n²)	O(1)	稳定
冒泡排序	O(n²)	O(1)	稳定
快速排序	O(nlog₂n)	O(log₂n)	不稳定
直接选择排序	O(n²)	O(1)	不稳定
堆排序	O(nlog₂n)	O(1)	不稳定
归并排序	O(nlog₂n)	O(n)	稳定