数据结构-看图版

最新推荐文章于 2024-08-15 23:11:27 发布

Monster2022

最新推荐文章于 2024-08-15 23:11:27 发布

阅读量730

点赞数 7

文章标签：数据结构算法链表

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

版权

文章目录

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

前言

一、答题规范

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

NODE *head;
head = malloc(sizeof(NODE));
// 不要写成head = (NODE*)malloc(sizeof(NODE));

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

二、考点

考代码：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

可能会考给出树写二元组，或者给出二元组画树：

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章线性表

一、顺序存储

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

#define MAXLEN 100
typedef int Elemtype

typedef struct {
    Elemtype List[MAXLEN];
    int length;
}SqList;

int insertsqlist(int i, ListItem x, SqList *sql)
{
    int j;
    if((i<1)||(i>sql->len))
        return(0);
    else
    {
        for(j=sql->len;j>=i;j--)
            sql->s[j+1]=sql->s[j];
        sql->s[i]=x;
        sql->len++;
        return(1);
    }
}

int delsqlist(int i,SqList *sql)
{
    int j;
    if((i<1)||(i>sql->len))
        return(0);
    else
    {
        for(j=i+1;j<=sql->len;j++)
            sql->s[j-1]=sql->s[j];
        sql->len--;
        return(1);
    }
}

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

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

二、链式存储

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

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

1. 单链表

typedef struct node
{
    int data;
    struct node *next;
}NODE;

// 按值查找
NODE *locate(NODE *head, int x)
{
    NODE *p;
    p=head->next;
    while((p!=NULL)&&(p->data!=x))
        p=p->next;
    return(p);
}

// 按序号查找
NODE *find(NODE *head, int i)
{
    int j=1;
    NODE *p;
    p=head->next;
    while((p!=NULL)&&(j<i))
    {
        p=p->next;
        j++;
    }
    return(p);
}

void insert(NODE *p, int x)
{
    NODE *q;
    q=malloc(sizeof(NODE));
    q->data=x;
    q-next=p->next;
    p->next=q;
}

void delete(NODE *head, int x)
{
    NODE *p,*q;
    q=head;
    p=q->next;
    while((p!=NULL)&&(p->data!=x))
    {
        q=p;
        p=p->next;
    }
    if(p==NULL)
        printf("%d not found.\n",x);
    else
    {
        q->next=p->next;
        free(p);
    }
}

2. 双链表

双链表的插入删除是重点，算法设计会考到

void insert(DUPNODE *p, DUPNODE *q)
{
    q->prior=p;
    q->next=p->next;
    p->next->prior=q;
    p->next=q;
}

void delete(DUPNODE *p)
{
    p->prior->next=p->next;
    p->next->prior=p->prior;
    free(p);
}

第3章栈与队列

一、栈

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

栈，又叫堆栈

1. 顺序存储

#define MAXLEN 10
typedef int elementtype;
typedef struct
{
    elementtype element[MAXLEN];
    int top;
}SqStack;

在这里插入图片描述

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

// 进栈
int Push_sq(SqStack *s,elementtype x)
{
    if(s->top==MAXLEN-1)
        return(0);
    s->top++;
    s->element[s->top]=x;
    return(1);
}

// 出栈
int Pop_sq(SqStack *s, elementtype *x)
{
    if(s->top==-1)
        return(0);
    *x=s->element[s->top];
    s->top--;
    return(1);
}

2. 链式存储

typedef struct node
{
    int data;
    struct node *next;
}NODE;

// 进栈
NODE *pushstack(NODE *top,int x)
{
    NODE *p;
    p=malloc(sizeof(NODE));
    p->data=x;
    p->next=top;
    top=p;
    return(top);
}

// 出栈
NODE *popstack(NODE *top, int *p)
{
    NODE *q;
    if(top!=NULL)
    {
        q=top;
        *p=top->data;
        top=top->next;
        free(q);
    }
    return(top);
}

二、队列

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

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

1. 顺序存储

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

在这里插入图片描述

队列为空(无论顺序链式循环队列都是这样)：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);
    }
}

循环队列

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

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

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

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

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

// 入队
int EnCqueue(CQueue *cq, elementtype x)
{
    if((fq->rear+1)%MAXLEN==cq->front)
        return(0);
    else
    {
        cq->rear=(cq->rear+1)%MAXLEN;
        cq->element[cq->rear]=x;
        return(1);
    }
}

// 出队
int DelCqueue(CQueue *cq, elementtype *x)
{
    if(cq->rear==cp->front)
        return(0);
    else
    {
        cq->front=(cq->front+1)%MAXLEN;
        *x=cq->element[cq->front];
        return(1);
    }
}

2. 链式存储

在这里插入图片描述

typedef struct node
{
    int data;
    struct node *next;
}NODE;

// 入队
NODE *pushqueue(NODE *rear,int x)
{
    NODE *p;
    p=malloc(sizeof(NODE));
    p->data=x;
    p->next=NULL;
    rear->next=p;
    rear=p;
    return(rear);
}

// 出队
NODE *popqueue(NODE *front, NODE *rear, int *x)
{
    NODE *p;
    if(front!=rear)
    {
        p=front->next;
        front->next=p->next;
        if(p->next==NULL) // 表示原链队列中只有一个元素
            rear=front;
        *x=p->data;
        free(p);
        return(rear);
    }
}

第5章树

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

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

一、树

1. 概念

节点的度：有几个孩子

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

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

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

E的真祖先是{A,C}

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

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

2. 存储结构（大题）

1）顺序存储

在这里插入图片描述

2）链式存储

孩子-兄弟链表表示法

在这里插入图片描述

二、二叉树

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

在这里插入图片描述

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开始

满二叉树

下图这个不是满二叉树

完全二叉树

性质5

在这里插入图片描述

2. 存储结构（大题）

1）顺序存储

在这里插入图片描述

2）链式存储

在这里插入图片描述

考的不是画图，考的是：给出左图，问用链式存储会有几个空指针（答案是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

在这里插入图片描述

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

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

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

在这里插入图片描述

2. 森林与二叉树转换

四、哈夫曼树（大题）

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

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

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

在这里插入图片描述

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

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

哈夫曼编码：是前缀编码

在这里插入图片描述

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

第6章图

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

在这里插入图片描述

边只能画直线

V表示顶点，E表示边

在这里插入图片描述

有向图的边称为弧

一、图的基本术语

1. 完全图（重点）

边的数最大化的图

在这里插入图片描述

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

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

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

在这里插入图片描述

3. 其它术语

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

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

二、存储结构（大题）

1. 邻接矩阵

在这里插入图片描述

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

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

在这里插入图片描述

2. 邻接表

在这里插入图片描述

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

在这里插入图片描述

有向图只算出度

三、图的遍历

1. 深度优先搜索DFS

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

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

在这里插入图片描述

2. 广度优先搜索BFS

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

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

在这里插入图片描述

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

四、最小生成树（大题）

1. 普里姆算法（Prim）

在这里插入图片描述

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

在这里插入图片描述

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

e.g.1

在这里插入图片描述

e.g.2

在这里插入图片描述

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

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

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

六、关键路径

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

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

第7章查找

一、顺序查找

从后往前一个个找

时间复杂度为O(n)

二、二分查找

前提：序列顺序且有序

在这里插入图片描述

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

在这里插入图片描述

low>high时查找失败

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

三、分块查找

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

四、散列/哈希查找

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

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

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

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

H(k)=k%p

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

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

在这里插入图片描述

第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

参考图片：

在这里插入图片描述

二、冒泡排序

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

在这里插入图片描述

三、快速排序

在这里插入图片描述

四、简单选择排序

在这里插入图片描述

五、堆排序

在这里插入图片描述

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

答案：

第一遍：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)	稳定