37.图练习（王道第6章综合练习）

已于 2023-10-21 00:32:30 修改
阅读量148 收藏
点赞数
分类专栏： 数据结构 文章标签： 算法 数据结构 图论 c语言 开发语言
于 2023-10-18 16:42:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54708219/article/details/133887506
版权

图的存储结构，可以有邻接表表示和矩阵表示两种。我们实现邻接表表示（矩阵表示用一个二维数组就可以）：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define maxvex 5
#define ElemType char
 
//边表结点
typedef struct edgenode{
	int adjvex;  //下标
	int weight;  //权值，可有可没有      
	struct edgenode *next;
}EdgeNode;

//顶点结点
typedef struct node{
	int data;
	EdgeNode *first;  //边表头指针
}VertexNode,AdjList[maxvex];

//二次封装
typedef struct {
	AdjList adjlist;
	int numetex, numedge;
}GraAdjList;
 
//创建邻接表
void CreateAlGraph(GraAdjList &g,int x)
{  //i=0创建有向图，i=1创建无向图
	int m, n;
	EdgeNode *e = NULL;
	EdgeNode *q = NULL;
    printf("请输入顶点数和边数（无向图端点相同只需录入一条边）:");
	scanf("%d %d", &g.numetex, &g.numedge);
    printf("请输入顶点的信息：");
	
	//获取顶点的信息
	for (int i = 0;i < g.numetex;i++)
	{
        scanf("%d", &g.adjlist[i].data);
        g.adjlist[i].first = NULL;
	}
	//建立边表，链表采用头插法
	for (int k = 0; k < g.numedge; k++)
	{
        printf("请输入边（Vi,Vj）的顶点下标：");
        scanf("%d %d", &m, &n);
        //链表结点
		if(x == 0){
			e = (EdgeNode *)malloc(sizeof(EdgeNode));
			e->adjvex = n;
			e->next = NULL;
			//头插法建链
			if (g.adjlist[m].first == NULL)
				q = g.adjlist[m].first = e;
			else
				q = q->next = e;
		}
		else{
			e = (EdgeNode *)malloc(sizeof(EdgeNode));
			e->adjvex = n;
			e->next = NULL;
			if (g.adjlist[m].first == NULL)
				q = g.adjlist[m].first = e;
			else
				q = q->next = e;
			//对无向图，一个边要在两个结点都增加
			e = (EdgeNode *)malloc(sizeof(EdgeNode));
			e->adjvex = m;
			e->next = NULL;
			if (g.adjlist[n].first == NULL)
				q = g.adjlist[n].first = e;
			else
				q = q->next = e;
		}
	}
}
void print(const GraAdjList &g){
	EdgeNode *p;
	for (int k = 0;k < g.numetex;k++){
		printf("顶点%d: ", k);
		for (p = g.adjlist[k].first; p;p = p->next)
            if (p != NULL)
                printf("%d ", p->adjvex);
        printf("\n");
    }
}

int main(){
	GraAdjList gralist;
	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
	print(gralist);
	Graphtomartix(gralist);
}

输出：

请输入顶点数和边数（无向图端点相同只需录入一条边）:3 1
请输入顶点的信息：0 1 2
请输入边（Vi,Vj）的顶点下标：0 1
顶点0: 1 
顶点1: 0 
顶点2:

然后我们再实现图的广度优先遍历（BFS）：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define maxvex 10
#define MAXSIZE 10
 
//边表结点
typedef struct edgenode{
	int adjvex;  //下标
	int weight;  //权值，可有可没有      
	struct edgenode *next;
}EdgeNode;

//顶点结点
typedef struct node{
	int data;
	EdgeNode *first;  //边表头指针
}VertexNode,AdjList[maxvex];

//二次封装
typedef struct {
	AdjList adjlist;
	int numetex, numedge;
}GraAdjList;
 
//创建邻接表
void CreateAlGraph(GraAdjList &g,int x)
{  //i=0创建有向图，i=1创建无向图
	int m, n;
	EdgeNode *e = NULL;
	EdgeNode *q = NULL;
    printf("请输入顶点数和边数（无向图端点相同只需录入一条边）:");
	scanf("%d %d", &g.numetex, &g.numedge);
	//获取顶点的信息
	for (int i = 0;i < g.numetex;i++){
		g.adjlist[i].data = i;
		g.adjlist[i].first = NULL;
	}
	//建立边表，链表采用头插法
	for (int k = 0; k < g.numedge; k++){
        printf("请输入边（Vi,Vj）的顶点下标：");
        scanf("%d %d", &m, &n);
        //链表结点
		if(x == 0){
			e = (EdgeNode *)malloc(sizeof(EdgeNode));
			e->adjvex = n;
			e->next = NULL;
			//头插法建链
			if (g.adjlist[m].first == NULL)
				q = g.adjlist[m].first = e;
			else
				q = q->next = e;
		}
		else{
			e = (EdgeNode *)malloc(sizeof(EdgeNode));
			e->adjvex = n;
			e->next = NULL;
			q = g.adjlist[m].first;
			g.adjlist[m].first = e;
			g.adjlist[m].first->next = q;
			//对无向图，一个边要在两个结点都增加
			e = (EdgeNode *)malloc(sizeof(EdgeNode));
			e->adjvex = m;
			e->next = NULL;
			q = g.adjlist[n].first;
			g.adjlist[n].first = e;
			g.adjlist[n].first->next = q;
		}
	}
}

typedef struct Queue{
	int data[MAXSIZE];
    int front, rear;  //头尾指针，队头指针指向第一个元素，队尾指针指向队尾元素的下一个元素
    int tag;
}Queue;
 
//初始化
int InitQueue(Queue &a){
    a.front = 0;
    a.rear = 0;
    a.tag = 0;  //初始队列是空
    return 1;
} 
//判断栈和队列是否为空
bool IsQueueEmpty(Queue q){
    if(q.tag == 0 && q.front==q.rear)
        return true;
    else
        return false;
}
//插入
int InsertQueue(Queue &a, int x){
    if(a.front == a.rear && a.tag == 1){
        printf("当前队列已满！");
        return 0;
    }
    else{
        a.data[a.rear] = x;
        a.tag = 1;  //插入队列tag置1
        a.rear = (a.rear + 1) % MAXSIZE;
        return 1;
    }  
}
//删除
int DeleteQueue(Queue &a){
	int x;
	if(a.front == a.rear && a.tag == 0){
        printf("当前队列已空！");
    }
    else{
        x = a.data[a.front];
        a.tag = 0;  //删除队列tag置0
        a.front = (a.front + 1) % MAXSIZE;  //front指针+1
        return x;
    }  
}

void print(const GraAdjList &g){
	EdgeNode *p;
	for (int k = 0;k < g.numetex;k++){
		printf("顶点%d: ", k);
		for (p = g.adjlist[k].first; p;p = p->next){
            if (p != NULL)
                printf("%d ", p->adjvex);
		}
        printf("\n");
    }
}

//根据邻接表转换成矩阵
void Graphtomartix(GraAdjList &g){
	EdgeNode *p;
	int a[g.numetex][g.numetex];
	//置零
	for (int i = 0; i < g.numetex;i++){
		for (int j = 0; j < g.numetex;j++)
			a[i][j] = 0;
	}
	//赋值
	for (int i = 0; i < g.numetex; i++){
		for (p = g.adjlist[i].first; p; p = p->next){
			a[i][p->adjvex] = 1;
		}
	}
	//打印
	for (int i = 0; i < g.numetex;i++){
		for (int j = 0; j < g.numetex;j++)
			printf("%d ", a[i][j]);
		printf("\n");
	}
}

void BFSTraverse(GraAdjList g,int v){  //v代表广度优先从哪开始
	bool visited[g.numetex];
	Queue q;
	EdgeNode *p;
	for (int i = 0; i < g.numetex;i++)
		visited[i] = false;
	InitQueue(q);
	printf("%d", v);  //输出访问结点
	visited[v] = true;
	InsertQueue(q, v);  //进队
	while (!IsQueueEmpty(q)){
		int x = DeleteQueue(q);
		for (p = g.adjlist[x].first; p != NULL;p=p->next){
			if(visited[p->adjvex]==false){
				printf("%d", p->adjvex);
				visited[p->adjvex] = true;
				InsertQueue(q, p->adjvex);
			}
		}
	}

	for (int i = 0; i < g.numetex;i++){  //检查连通分量
		if(visited[i] == false){
			printf("%d", i);  //输出访问结点
			visited[i] = true;
			InsertQueue(q, i);  //进队
			while (!IsQueueEmpty(q)){
				int x = DeleteQueue(q);
				for (p = g.adjlist[x].first; p != NULL;p=p->next){
					if(visited[p->adjvex]==false){
						printf("%d", p->adjvex);
						visited[p->adjvex] = true;
						InsertQueue(q, p->adjvex);
					}
				}
			}
		}
	}
}

int main(){
	GraAdjList gralist;
	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
	print(gralist);
	printf("图所对应的邻接矩阵是：");
	Graphtomartix(gralist);
	printf("图的广度优先遍历序列是：");
	BFSTraverse(gralist, 0);
}

输出：

请输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
请输入边（Vi,Vj）的顶点下标：0 1
请输入边（Vi,Vj）的顶点下标：0 2
请输入边（Vi,Vj）的顶点下标：1 3
请输入边（Vi,Vj）的顶点下标：1 4
请输入边（Vi,Vj）的顶点下标：2 5
请输入边（Vi,Vj）的顶点下标：2 6
请输入边（Vi,Vj）的顶点下标：4 7
顶点0: 2 1
顶点1: 4 3 0
顶点2: 6 5 0
顶点3: 1
顶点4: 7 1
顶点5: 2
顶点6: 2
顶点7: 4
0 1 1 0 0 0 0 0
1 0 0 1 1 0 0 0
1 0 0 0 0 1 1 0
0 1 0 0 0 0 0 0
0 1 0 0 0 0 0 1
0 0 1 0 0 0 0 0
0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0
图的广度优先遍历序列是：02165437

请输入顶点数和边数（无向图端点相同只需录入一条边）:5 4
请输入边（Vi,Vj）的顶点下标：0 1
请输入边（Vi,Vj）的顶点下标：0 2
请输入边（Vi,Vj）的顶点下标：1 2
请输入边（Vi,Vj）的顶点下标：3 4
顶点0: 2 1
顶点1: 2 0
顶点2: 1 0
顶点3: 4
顶点4: 3
0 1 1 0 0
1 0 1 0 0
1 1 0 0 0
0 0 0 0 1
0 0 0 1 0
图的广度优先遍历序列是：02134

//此示例要把main最后一行改成BFSTraverse(gralist, 2)，表示从2开始广度优先遍历
请输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
请输入边（Vi,Vj）的顶点下标：0 1
请输入边（Vi,Vj）的顶点下标：0 2
请输入边（Vi,Vj）的顶点下标：1 3 
请输入边（Vi,Vj）的顶点下标：1 4
请输入边（Vi,Vj）的顶点下标：2 5
请输入边（Vi,Vj）的顶点下标：2 6
请输入边（Vi,Vj）的顶点下标：4 7
顶点0: 2 1
顶点1: 4 3 0
顶点2: 6 5 0
顶点3: 1
顶点4: 7 1
顶点5: 2
顶点6: 2
顶点7: 4
0 1 1 0 0 0 0 0
1 0 0 1 1 0 0 0
1 0 0 0 0 1 1 0
0 1 0 0 0 0 0 0
0 1 0 0 0 0 0 1
0 0 1 0 0 0 0 0
0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0
图的广度优先遍历序列是：26501437

然后我们看深度优先遍历算法：

bool visited[8]; //bool visited[g.numetex]，此处修改为图的顶点数
void DFS(GraAdjList g,int v){
	EdgeNode *p;
	printf("%d", v);
	visited[v] = true;
	for (p = g.adjlist[v].first; p != NULL;p = p->next){
		if(!visited[p->adjvex])
			DFS(g, p->adjvex);
	}
}
void DFSTraverse(GraAdjList g){  //v代表深度优先从哪开始
	for (int i = 0; i < 8;i++)  //赋初值，这里也要修改为图的顶点数
		visited[i] = false;
	for (int i = 0; i < 8;i++){  //赋初值，这里也要修改为图的顶点数
		if(!visited[i])
			DFS(g, i);
	}
}

int main(){
	GraAdjList gralist;
	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
	print(gralist);
	printf("图所对应的邻接矩阵是：\n");
	Graphtomartix(gralist);
	printf("图的深度优先遍历序列是：");
	DFSTraverse(gralist);
}

输出：

请输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
请输入边（Vi,Vj）的顶点下标：0 1
请输入边（Vi,Vj）的顶点下标：0 2
请输入边（Vi,Vj）的顶点下标：1 3
请输入边（Vi,Vj）的顶点下标：1 4
请输入边（Vi,Vj）的顶点下标：2 5
请输入边（Vi,Vj）的顶点下标：2 6
请输入边（Vi,Vj）的顶点下标：4 7
顶点0: 2 1
顶点1: 4 3 0
顶点2: 6 5 0
顶点3: 1
顶点4: 7 1
顶点5: 2
顶点6: 2
顶点7: 4
图所对应的邻接矩阵是：
0 1 1 0 0 0 0 0
1 0 0 1 1 0 0 0
1 0 0 0 0 1 1 0
0 1 0 0 0 0 0 0
0 1 0 0 0 0 0 1
0 0 1 0 0 0 0 0
0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0
图的深度优先遍历序列是：02651473

试题1（王道6.2.6节综合题4）：

写出从图的邻接表表示转换成邻接矩阵表示的算法。

和前面的练习题相比，此题几乎就是白给。。。

//根据邻接表转换成矩阵
void Graphtomartix(GraAdjList &g){
	EdgeNode *p;
	int a[g.numetex][g.numetex];
	//置零
	for (int i = 0; i < g.numetex;i++){
		for (int j = 0; j < g.numetex;j++)
			a[i][j] = 0;
	}
	//赋值
	for (int i = 0; i < g.numetex; i++){
		for (p = g.adjlist[i].first; p; p = p->next){
			a[i][p->adjvex] = 1;
		}
	}
	//打印
	for (int i = 0; i < g.numetex;i++){
		for (int j = 0; j < g.numetex;j++)
			printf("%d ", a[i][j]);
		printf("\n");
	}
}

输出：

请输入顶点数和边数（无向图端点相同只需录入一条边）:3 1
请输入顶点的信息：0 1 2
请输入边（Vi,Vj）的顶点下标：0 1
顶点0: 1
顶点1: 0
顶点2:
0 1 0
1 0 0
0 0 0

试题2（王道6.3.4节综合题2）：

设计算法判断一个无向图G是否是一棵树。

图成为树的标准：n个顶点，n-1条边，而我们建立的图的数据结构种numetex, numedge刚好对应这两个参数，所以此题等于白给。。。

//此算法判断图是不是一棵树
bool ifTree(GraAdjList g){
	if(g.numetex-g.numedge==1)
		return true;
	else
		return false;
}

试题3（王道6.3.4节综合题3）：

写出图的深度优先搜索DFS算法的非递归算法（图采用邻接表形式）。

非递归算法，把递归转化成非递归那就上栈被：

bool visited[8]; //bool visited[g.numetex]，此处修改为图的顶点数

void DFS(GraAdjList g,Sqstack S,int v){
	int x;
	EdgeNode *p;
	InsertSqstack(S, v);
	while(!IsStackEmpty(S)){
		x = DeleteSqstack(S);
		printf("%d", x);
		visited[x] = true;
		for(p = g.adjlist[x].first; p != NULL;p = p->next){
			if(visited[p->adjvex]==false){
				InsertSqstack(S, p->adjvex);
				visited[p->adjvex] = true;
			}	
		}
	}	
}
void DFSTraverse(GraAdjList g,Sqstack S){  //v代表深度优先从哪开始
	for (int i = 0; i < 8;i++)  //赋初值，这里也要修改为图的顶点数
		visited[i] = false;
	for (int i = 0; i < 8;i++){  //赋初值，这里也要修改为图的顶点数
		if(!visited[i])
			DFS(g, S, i);
	}
}

int main(){
	GraAdjList gralist;
	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
	print(gralist);
	printf("图所对应的邻接矩阵是：\n");
	Graphtomartix(gralist);
	Sqstack S;
	InitStack(S);
	printf("图的深度优先遍历序列是：");
	DFSTraverse(gralist, S);
}

输出：

请输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
请输入边（Vi,Vj）的顶点下标：0 1
请输入边（Vi,Vj）的顶点下标：0 2
请输入边（Vi,Vj）的顶点下标：1 3
请输入边（Vi,Vj）的顶点下标：1 4
请输入边（Vi,Vj）的顶点下标：2 5
请输入边（Vi,Vj）的顶点下标：2 6
请输入边（Vi,Vj）的顶点下标：4 7
顶点0: 2 1
顶点1: 4 3 0
顶点2: 6 5 0
顶点3: 1
顶点4: 7 1
顶点5: 2
顶点6: 2
顶点7: 4
图所对应的邻接矩阵是：
0 1 1 0 0 0 0 0
1 0 0 1 1 0 0 0
1 0 0 0 0 1 1 0
0 1 0 0 0 0 0 0
0 1 0 0 0 0 0 1
0 0 1 0 0 0 0 0
0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0
图的深度优先遍历序列是：01347256

试题4（王道6.3.4节综合题4）：

分别采用广度优先遍历和深度优先遍历算法判断以邻接表方式存储的有向图中是否存在由顶点i到顶点j的路径（i与j不相等）。

此题实际上就是检查两个结点是否在一个连通分量里，把前面的for循环删掉然后加判断visited[j]语句即可。

试题5（王道6.3.4节综合题5）：

假设图用邻接表表示，设计算法输出从顶点i到顶点j的所有简单路径。

此题的算法不是很好想。除了要记录每个顶点是否被访问（visited数组），还要建立path数组记录当前搜索路径。函数实现的思路是：

  1. 将当前顶点u添加到搜索路径中，并将visited[u]标记为true，表示已经访问过。
  2. 如果u等于v，说明找到了一条路径，打印路径上的顶点。
  3. 遍历顶点u的邻接点，如果邻接点w未被访问过，则递归调用FindPath函数，将w作为新的起始顶点。
  4. 重置visited[u]为false，表示当前顶点u的搜索路径已经结束。

需要注意的是，函数调用前需要将visited数组初始化为false，path数组初始化为空。另外，函数调用时初始的d值应为-1。

bool visited[4]; //bool visited[g.numetex]，此处修改为图的顶点数
int path[8];

void FindPath(GraAdjList g,int u,int v,int path[],int d){
	int w;
	int i;
	EdgeNode *p;
	d = d + 1;  //搜索路径长度+1,初始为-1
	path[d] = u;  //搜索路径第d步上是u
	visited[u] = true;
	if(u == v){
		printf("找到一条路径如下：");
		for (int i = 0; i <= d;i++){
			printf("%d ", path[i]);
		}
		printf("\n");
	}
	p = g.adjlist[u].first;  //p指向u的第一个邻接点
	while(p!=NULL){
		w = p->adjvex;
		if(visited[w]==false){
			FindPath(g, w, v, path, d);
		}
		p = p->next;
	}
	visited[u] = false;  //重置
}

int main(){
	GraAdjList gralist;
	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
	print(gralist);
	printf("图所对应的邻接矩阵是：\n");
	Graphtomartix(gralist);
	FindPath(gralist, 0, 3, path, -1);
}

输出：

请输入顶点数和边数（无向图端点相同只需录入一条边）:4 5
请输入边（Vi,Vj）的顶点下标：0 1
请输入边（Vi,Vj）的顶点下标：0 2
请输入边（Vi,Vj）的顶点下标：1 2
请输入边（Vi,Vj）的顶点下标：1 3
请输入边（Vi,Vj）的顶点下标：2 3
顶点0: 2 1
顶点1: 3 2 0
顶点2: 3 1 0
顶点3: 2 1
图所对应的邻接矩阵是：
0 1 1 0
1 0 1 1
1 1 0 1
0 1 1 0
找到一条路径如下：0 2 3
找到一条路径如下：0 2 1 3
找到一条路径如下：0 1 3
找到一条路径如下：0 1 2 3

试题6（王道6.4.6节第6题）：

试说明利用DFS算法如何实现有向无环图的拓扑排序。

利用递归特性，若拓扑排序序列中，a在b之后，则递归的时候a比b靠前递归结束。利用这一特点，增设time变量，然后对time变量从大到小输出即可：

bool visited[8]; //bool visited[g.numetex]，此处修改为图的顶点数
int finishtime[8];
int time = 0;
void DFS(GraAdjList g,int v){
	EdgeNode *p;
	visited[v] = true;
	for (p = g.adjlist[v].first; p != NULL;p = p->next){
		if(!visited[p->adjvex])
			DFS(g, p->adjvex);
	}
	time = time + 1;
	finishtime[v] = time;
	printf("(%d,%d)", finishtime[v], v);
}
void DFSTraverse(GraAdjList g){  //v代表深度优先从哪开始
	for (int i = 0; i < 8;i++)  //赋初值，这里也要修改为图的顶点数
		visited[i] = false;
	for (int i = 0; i < 8;i++){  
		if(!visited[i])
			DFS(g, i);
	}
}
 
int main(){
	GraAdjList gralist;
	CreateAlGraph(gralist, 0);  //i=0创建有向图，i=1创建无向图
	print(gralist);
	printf("%d", time);
	printf("图所对应的邻接矩阵是：\n");
	Graphtomartix(gralist);
	printf("图的拓扑排序序列是：");
	DFSTraverse(gralist);
}

输出：

输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
请输入边（Vi,Vj）的顶点下标：0 1
请输入边（Vi,Vj）的顶点下标：1 2
请输入边（Vi,Vj）的顶点下标：2 3
请输入边（Vi,Vj）的顶点下标：3 7
请输入边（Vi,Vj）的顶点下标：4 5
请输入边（Vi,Vj）的顶点下标：5 6
请输入边（Vi,Vj）的顶点下标：6 7
顶点0: 1
顶点1: 2
顶点2: 3
顶点3: 7
顶点4: 5
顶点5: 6
顶点6: 7
顶点7:
0图所对应的邻接矩阵是：
0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0
0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 1
0 0 0 0 0 1 0 0
0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0
图的拓扑排序序列是：(1,7)(2,3)(3,2)(4,1)(5,0)(6,6)(7,5)(8,4)

所以可得到拓扑排序序列：45601237

北京地铁1号线
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
王道计组第五章错题.pdf
11-12
《王道计组第五章错题.pdf》的内容主要涵盖了计算机组织与设计中的核心知识点，包括处理器结构、数据表示、指令系统、存储系统等多个方面。以下是对这些错题中涉及的知识点的详细解释： 1. **5.1.39**：这部分可能...
王道机试指南.rar
02-10
《王道机试指南》是一份全面覆盖计算机科学与技术领域的源码集合，特别适合于准备复试阶段的上机考试。这份压缩包包含了丰富的cpp源代码文件，旨在帮助学习者深入理解和掌握编程技能，尤其是C++语言的应用。下面将...
35.树与二叉树练习（1）（王道第5章综合练习）
qq_54708219的博客
10-10 1025
树与二叉树练习（1）（王道第5章综合练习）
36.树与二叉树练习（2）（王道第5章综合练习）
qq_54708219的博客
10-15 179
（3）结点没有左右孩子——找中序遍历前驱结点的左孩子结点，找不到就继续往前直到找到有左孩子结点，或者就是第一个结点（左孩子指针为空）返回NULL。分析：二叉树中（1）叶子结点（2）只有右孩子没有左孩子的结点是原森林的叶子结点。设计算法将二叉树的叶结点按从左到右的顺序连成单链表，连接时使用叶结点的右指针域存放单链表指针。从树转化成二叉树：左孩子向下走相当于深度+1，右孩子向下走相当于访问同深度兄弟结点。（1）结点有右孩子——右孩子就是后序遍历的前驱结点；（2）结点只有左孩子——左孩子是后序遍历的前驱结点；
40.查找练习题（王道2023数据结构第7章）
qq_54708219的博客
10-25 340
在链表被启用前，其值均初始化为零。每当在连表中进行一次Locate(L,x)运算时，令元素值为x的结点中freq域的值增1，并使此链表中结点保持按访问频度非递增的顺序排列，同时最近访问的结点排在频度相同的结点的前面，以便使频繁访问的结点总是靠近表头。试编写符合上述要求的Locate(L,x)运算的算法，该运算为函数过程，返回找到结点的地址，类型为指针型。线性表中各结点检索概率不等时，可用如下策略提高顺序检索的效率：若找到指定的结点，则将该结点与前驱结点（若存在）交换，使得经常被检索的结点尽量位于表的前端。
41.排序练习题（王道2023数据结构第8章综合练习）
qq_54708219的博客
10-31 110
计数排序算法针对表中的每一个记录，遍历待排序的表一遍，统计表中有多少个记录的关键字比该记录的关键字小。设计实现计数排序的算法。【试题再现】编写一个递归算法，在一棵具有n个结点的二叉排序树上查找第k小的元素，并返回该结点的指针。要求算法的平均时间复杂度是，二叉排序树每个结点中除了data,lchild,rchild外，增设一个count成员，保存以该结点为根的子树的结点个数。已知线性表按顺序存储，且每个元素都是不相同的整数类型元素，设计把所有奇数移动到所有偶数前边的算法（要求时间最少，辅助空间最少）。
王道考研2020练习题 第二章 2.2 线性表 C语言实现
h2809871142的博客
08-30 300
#include "stdio.h" #include "windows.h" #include "stdbool.h" #define SqListMaxSize 50 #define ElemType int #define SeqListMaxSize 50 #define OVERFLOW 0 /* 线性表(顺序存储结构) */ typedef struct { ElemType data[SqListMaxSize]; int length; }SqList; /* 线性表(随机存储结构
33.栈，队列练习题（王道2023数据结构第3章综合应用）
qq_54708219的博客
09-27 306
设有两个栈S1，S2都采用顺序栈方式，并共享一个存储区[0...Maxsize-1]，为了尽量利用空间，减少溢出可能，可采用栈顶相向，迎面增长的存储方式，试设计S1，S2的入栈和出栈算法。若希望队列中的元素都能得到利用，需设置一个标志域tag，并以tag为0或1来区分头指针front和尾指针rear相同时的队列状态是空还是满，试编写此结构的入队和出队算法。栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅有 I 和 O 组成的序列，可以操作的序列为合法序列，否则称为非法序列。试题2：（3.1.4节题4）
王道第二章链表相关oj题及之后的练习(详解)
qq_53010164的博客
08-22 343
此篇为参考王道即力扣相关的题目以及自己的思路,只为参考,只是本人的学习思路
C语言王道练习题第六周一题
m0_74343360的博客
01-22 577
一次只能走1个或者2个台阶，所以n个台阶，第n-1前个台阶，是一种方案，第n-2前个台阶是一种方案。如果输入是3,走到第3个台阶的走法总计有3种,1,1,1 和 1,2 和2,1,输出。假如有n个台阶，一次只能上1个台阶或2个台阶，请问走到第n个台阶有几种走法？：当走到第n-2个台阶，再向前走1个台阶，则与第一种方案重复。输入为n，输出为走到第n个台阶有几种走法？第二种为先上2个台阶，再上1个台阶；第三种为先上1个台阶，再上2个台阶。递归问题提炼公式，结束条件。
【王道-第三章-内存管理】
@76135327的博客
08-24 386
第三章内存管理
考试类精品--王道考研机试指南(第二版) 习题代码.zip
02-06
这个压缩包文件"考试类精品--王道考研机试指南(第二版) 习题代码.zip"显然是为了辅助读者更好地理解和实践书中的编程题目，其中包含的子文件"ahao4"可能是书中某一章或某一部分的习题代码。 在考研机试中，考生需要...
考试类精品--王道考研机试指南(第二版)——题目链接.zip
02-06
《王道考研机试指南(第二版)——题目链接》是一部专门为考研计算机科学与技术专业学生准备的资源集合，旨在帮助考生熟悉并掌握机试环节的各类问题。这份压缩包包含了一个名为“ahao4”的文件，很可能是一个文档或者...
王道模拟题及答案
12-27
此外，还有试卷6和试卷4，可能是按照特定主题或难度划分的补充练习。这种有序的习题集设计，有助于考生形成系统的复习计划，逐步加深对数据结构的理解。 总结来说，《王道模拟题及答案》这套资料为备考者提供了丰富...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 913
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 218
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 205
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 602
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
时间复杂度王道练习题
10-07
关于时间复杂度的练习题，可以参考引用中提到的九度OJ网站上的机试题。这些题目从浅入深，从简到难地讲解了机试的相关考点，可以给你提供可靠的练习指导。 在编写迭代程序时，通常使用while循环或for循环。根据引用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北京地铁1号线

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值