PTApt——2023年软件设计综合实践_7(数据结构)

最新推荐文章于 2024-08-30 21:09:25 发布
最新推荐文章于 2024-08-30 21:09:25 发布
阅读量750 收藏 11
点赞数 10
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65628600/article/details/134699953
版权
本文介绍了在递增整数链表中插入新元素的方法，以及循环队列、另类堆栈、二叉树遍历（包括Inorder,Preorder,Postorder和Levelorder）的实现，还有广度优先遍历(BFS)和深度优先遍历(DFS)在图中的应用，以及Prim算法在解决公路连通问题中的应用。
摘要由CSDN通过智能技术生成

6-1 递增的整数序列链表的插入

本题要求实现一个函数，在递增的整数序列链表（带头结点）中插入一个新整数，并保持该序列的有序性。

答案：    语言选C(gcc)

List Insert(List L, ElementType X) {
    List tmp = (List) malloc(sizeof(List));
    tmp->Data = X;
    List ptr = L;
    // 这样的写法头节点不存储，为0
    while (ptr->Next && ptr->Next->Data<X) {
        ptr = ptr->Next;
    }
    tmp->Next = ptr->Next;
    ptr->Next = tmp;
    return L;
}

6-2 另类循环队列 

如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。

答案：    语言选C(gcc)

bool AddQ(Queue Q, ElementType X) {
    if (Q->Count == Q->MaxSize) {
        printf("Queue Full\n");
        return false;
    }
    Q->Data[(++Q->Count + Q->Front) % Q->MaxSize] = X;
    return true;
}

ElementType DeleteQ(Queue Q) {
    if (Q->Count == 0) {
        printf("Queue Empty\n");
        return ERROR;
    }
    Q->Front = (Q->Front + 1) % Q->MaxSize;
    Q->Count--;
    return Q->Data[Q->Front];
}

6-3 另类堆栈

在栈的顺序存储实现中，另有一种方法是将Top定义为栈顶的上一个位置。请编写程序实现这种定义下堆栈的入栈、出栈操作。如何判断堆栈为空或者满？

答案：    语言选C(gcc)

bool Push(Stack S, ElementType X) {
    if (S->Top == S->MaxSize) {
        printf("Stack Full\n");
        return false;
    }
    S->Data[S->Top] = X;
    S->Top++;
    return true;
}

//Stack Empty
//3 is out
//4 is out
//Stack Full
//0 1 2 5
ElementType Pop(Stack S) {
    if (S->Top == 0) {
        printf("Stack Empty\n");
        return ERROR;
    }
    return S->Data[--(S->Top)];
}

6-4 二叉树的遍历

在一棵树T中两个结点u和v的最近公共祖先(LCA)，是树中以u和v为其后代的深度最大的那个结点。现给定某二叉搜索树(BST)中任意两个结点，要求你找出它们的最近公共祖先。

void InorderTraversal(BinTree BT) {
    if (BT == NULL)
        return;

    InorderTraversal(BT->Left);
    printf(" %c", BT->Data);
    InorderTraversal(BT->Right);
}

void PreorderTraversal(BinTree BT) {
    if (BT == NULL)
        return;
    printf(" %c", BT->Data);
    PreorderTraversal(BT->Left);
    PreorderTraversal(BT->Right);
}

void PostorderTraversal(BinTree BT) {
    if (BT == NULL)
        return;
    PostorderTraversal(BT->Left);
    PostorderTraversal(BT->Right);
    printf(" %c", BT->Data);
}


void LevelorderTraversal(BinTree BT) {
    BinTree a[1000] = {};
    int size = 0;
    a[0] = BT;
    size++;
    while (size != 0) {
        BinTree tmp = a[0];
        for (int i = 1; i < size + 1; i++) {
            a[i - 1] = a[i];
        }
        size--;

        if (tmp == NULL)
            continue;
        else {
            printf(" %c", tmp->Data);

            a[size++] = tmp->Left;

            a[size++] = tmp->Right;
        }
    }

}

6-6 邻接矩阵存储图的深度优先遍历

void DFS(MGraph Graph, Vertex V, void (*Visit)(Vertex)) {



//    printV(Visited, Visit);

    if (Visited[V] == true) {

        return;

    } else {

        Visited[V] = true;

        Visit(V);

        for (int i = 0; i < Graph->Nv; i++) {

            if (i == V)

                continue;

            if (Graph->G[V][i] == INFINITY)

                continue;

            if (Graph->G[V][i] == 1 && Visited[i] != 1)

                DFS(Graph, i, Visit);

        }

    }





}

6-7 邻接表存储图的广度优先遍历

void BFS(LGraph Graph, Vertex S, void (*Visit)(Vertex)) {
    int q[MaxVertexNum+1] = {};
    int size = 0;
    q[size++] = S;
    Visited[S] = true;
    while (size != 0) {
        int tmp = q[0];
        for (int i = 1; i < size+1; i++) {
            q[i - 1] = q[i];
        }
        size--;
        Visit(tmp);
        for (PtrToAdjVNode itr = Graph->G[tmp].FirstEdge; itr != NULL; itr = itr->Next) {
            if (!Visited[itr->AdjV]) {
                q[size++] = itr->AdjV;
                Visited[itr->AdjV] = true;
            }
        }

    }
}

7-1 城市间紧急救援 

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

语言选c++

#include <cstdio>
#include <algorithm>
using namespace std;
int n, m, c1, c2;
int dis[510], weight[510], e[510][510], num[510], w[510], pre[510];
bool visit[510];
const int inf = 99999999;
void printPath(int v) {
    if(v == c1) {
        printf("%d", v);
        return ;
    }
    printPath(pre[v]);
    printf(" %d", v);
}
int main() {
    scanf("%d%d%d%d", &n, &m, &c1, &c2);
    for(int i = 0; i < n; i++)
        scanf("%d", &weight[i]);
    fill(e[0], e[0] + 510 * 510, inf);
    fill(dis, dis + 510, inf);
    int a, b, c;
    for(int i = 0; i < m; i++) {
        scanf("%d%d%d", &a, &b, &c);
        e[a][b] = c;
        e[b][a] = c;
    }
    dis[c1] = 0;
    w[c1] = weight[c1];
    num[c1] = 1;
    for(int i = 0; i < n; i++) {
        int u = -1, minn = inf;
        for(int j = 0; j < n; j++) {
            if(visit[j] == false && dis[j] < minn) {
                u = j;
                minn = dis[j];
            }
        }
        if(u == -1) break;
        visit[u] = true;
        for(int v = 0; v < n; v++) {
            if(visit[v] == false && e[u][v] != inf) {
                if(dis[u] + e[u][v] < dis[v]) {
                    dis[v] = dis[u] + e[u][v];
                    num[v] = num[u];
                    w[v] = w[u] + weight[v];
                    pre[v] = u;
                } else if(dis[u] + e[u][v] == dis[v]) {
                    num[v] = num[v] + num[u];
                    if(w[u] + weight[v] > w[v]) {
                        w[v] = w[u] + weight[v];
                        pre[v] = u;
                    }
                }
            }
        }
    }
    printf("%d %d\n", num[c2], w[c2]);
    printPath(c2);
    return 0;
}

7-2 修理牧场

农夫要修理牧场的一段栅栏，他测量了栅栏，发现需要N块木头，每块木头长度为整数Li​个长度单位，于是他购买了一条很长的、能锯成N块的木头，即该木头的长度是Li​的总和。

但是农夫自己没有锯子，请人锯木的酬金跟这段木头的长度成正比。为简单起见，不妨就设酬金等于所锯木头的长度。例如，要将长度为20的木头锯成长度为8、7和5的三段，第一次锯木头花费20，将木头锯成12和8；第二次锯木头花费12，将长度为12的木头锯成7和5，总花费为32。如果第一次将木头锯成15和5，则第二次锯木头花费15，总花费为35（大于32）。

请编写程序帮助农夫计算将木头锯成N块的最少花费。

语言选c++

#include <iostream>
#include <queue> 
using namespace std;

int main()
{
	priority_queue< int, vector<int>, greater<int> > Q;
	int N, x, a, b, ans = 0;
	cin>>N;
	for(int i = 0;i < N;i++)
	{
		cin>>x;
		Q.push(x);
	}
	for(int i = 0;i < N-1;i++)
	{
		a = Q.top();
		Q.pop();
		b = Q.top();
		Q.pop();
		Q.push(a+b);
		ans += a+b;
	}
	cout<<ans<<endl;
	return 0;
}

7-3 公路村村通

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:

输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。

语言选c++

//Prim算法
#include<iostream>
#include<stdio.h>
#define MAXVEX 1005
#define MAXEDGE 3005
#define IFINITY 65535
 
using namespace std;
int G[MAXVEX][MAXVEX];
int N,M;//城镇数目和候选道路数目
int Prim()
{
    int NumVexes = 0;//初始化加入的节点数
    int MinLength = 0;
    int lowcost[MAXVEX];
    int start = 1;//从城镇1开始
    for(int i = 1;i < MAXVEX;i++)
        lowcost[i] = G[start][i];
 
    lowcost[start] = 0;
    NumVexes = 1;
    int min_cost;
    int k;
    for(int i = 1;i < N;i++)
    {
        min_cost = IFINITY;
        for(int j = 1;j < N+1;j++)
        {
            if(lowcost[j] != 0 && lowcost[j] < min_cost)
            {
                k = j;
                min_cost = lowcost[j];
            }
        }
 
        if(min_cost != IFINITY)
        {
            NumVexes++;
            MinLength += min_cost;
            lowcost[k] = 0;
            for(int j = 1;j < N+1;j++)
            {
                if(lowcost[j] != 0 && G[k][j] < lowcost[j])
                {
                    lowcost[j] = G[k][j];
                }
            }
        }
    }
    if(NumVexes == N)
        return MinLength;
    else
        return -1;
 
}
 
int main()
{
    cin >> N >> M;
    int b,e,w;
    for(int i = 0;i < MAXVEX;i++)
    {
        for(int j = 0;j < MAXVEX;j++)
        {
            G[i][j] = G[j][i] = IFINITY;
        }
    }
    for(int i = 0;i < M;i++)
    {
        cin >> b >> e >> w;
        G[b][e] = G[e][b] = w;
    }
    printf("%d",Prim());
 
    return 0;
}

计算机平台作业答案讲解
关注
  • 10
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PTA 6-2 另类循环队列 (20分)
weixin_43626741的博客
03-25 3122
全部代码 #include <stdio.h> #include <stdlib.h> #include <string.h> #define ERROR -1 typedef int ElementType; typedef enum { addq, delq, end } Operation; //typedef enum { false, true } ...
6-2 循环队列出队入队
m0_61630188的博客
05-16 3536
用一个数组表示循环队列，请编写算法实现循环队列的初始化、入队和出队操作。 输入时：第一行输入队列数据空间容量，第二行依次输入5个待插入元素值，第三行再依次输入5个待插入元素值。 输出时：第一行和最后一行输出循环队列元素值及其下标（元素值（下标）），若中途出现队空或队满，则应给出相应提示。 函数接口定义： void InitQ(SqQueue &Q,int N); void AddQ(SqQueue &Q, int x ); Status DeleteQ(SqQueue &Q,
3-3 另类循环队列 (20分)
rookielsj的博客
11-08 1074
3-3 另类循环队列 (20分) 如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义： bool AddQ( Queue Q, ElementType X ); ElementType DeleteQ( Queue Q ); 其中Queue结构定义如下： typedef int Position; typedef struct QNode *PtrToQNode; struct QNode
另类循环队列 （20 分)
热门推荐
qq_43269093的博客
03-27 1万+
另类循环队列 （20 分) 如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义： bool AddQ( Queue Q, ElementType X ); ElementType DeleteQ( Queue Q ); 其中Queue结构定义如下： typedef int Posi...
6-7 另类循环队列（20 分）
NITjianbagengmu的博客
12-03 8030
6-7 另类循环队列（20 分） 如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义：bool AddQ( Queue Q, ElementType X ); ElementType DeleteQ( Queue Q ); 其中Queue结构定义如下： typedef int
6-4 另类循环队列 (25 分)
weixin_43785097的博客
10-14 1031
如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义： bool AddQ( Queue Q, ElementType X ); ElementType DeleteQ( Queue Q ); 其中***Queue***结构定义如下： typedef int Position; ty...
习题3.12 另类循环队列
weixin_38941715的博客
06-24 1364
bool AddQ(Queue Q, ElementType X) { if (Q->MaxSize == Q->Count) { printf("Queue Full\n"); return false; } Q->Count++; Q->Data[(Q->Front+Q->Count) % (Q->MaxSize)] = X; return 0; } ElementType
浙大版《数据结构》习题3.12 另类循环队列（20 分）
云上明月的博客
09-08 5051
题目： 如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义： bool AddQ( Queue Q, ElementType X ); ElementType DeleteQ( Queue Q ); 其中Queue结构定义如下： typedef int Positi...
6-2 另类堆栈 （15 分)
丁世杰的博客
04-16 5485
在栈的顺序存储实现中，另有一种方法是将Top定义为栈顶的上一个位置。请编写程序实现这种定义下堆栈的入栈、出栈操作。如何判断堆栈为空或者满？ 函数接口定义： bool Push( Stack S, ElementType X ); ElementType Pop( Stack S ); 其中Stack结构定义如下： typedef int Position; typedef struct SNod...
6-3 另类循环队列 （20 分)
丁世杰的博客
04-16 6733
如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义： bool AddQ( Queue Q, ElementType X ); ElementType DeleteQ( Queue Q ); 其中Queue结构定义如下： typedef int Position; typedef ...
6-2 双端队列 （25 分）
南风的博客
10-09 9044
双端队列（deque，即double-ended queue的缩写）是一种具有队列和栈性质的数据结构，即可以（也只能）在线性表的两端进行插入和删除。若以顺序存储方式实现双端队列，请编写例程实现下列操作： Push(X,D)：将元素X插入到双端队列D的头； Pop(D)：删除双端队列D的头元素，并返回； Inject(X,D)：将元素X插入到双端队列D的尾部； Eject(D)：删除双端队列D的尾部...
另类循环队列 （20 分）
PoetVVV的博客
12-01 1722
6-2 另类循环队列 （20 分） 如果用一个循环数组表示队列，并且只设队列头指针Front，不设尾指针Rear，而是另设Count记录队列中元素个数。请编写算法实现队列的入队和出队操作。 函数接口定义： bool AddQ( Queue Q, ElementType X ); ElementType DeleteQ( Queue Q ); 其中Queue结构定义如下： type...
树、二叉树
最新发布
2301_79909332的博客
08-30 167
1、满二叉树：满二叉树是一种特殊的二叉树，其中每个层级的节点数都是最大值，即每个层级都是完全填充的。深度： 从根节点出发到达节点的分支节点个数称为该节点的深度。高度：从叶子节点出发到该节点最大的节点个数称为该节点的高度。树的高度：整个树形结构中高度最高的节点的高度称为树的高度。树的深度：整个树形结构中深度最深的节点的深度称为树的深度。3、二叉树特点：叶子节点、只有左孩子、只有右孩子、左右孩子都有。树的层数 == 树的高度 == 树的深度。3.叶子节点：没有后继的节点。节点的度： 叶子节点度数为0。
【数据结构】—— 树和二叉树
mist的博客
08-26 1576
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构——顺序表
m0_61965705的博客
08-27 404
例如：查找顺序表中的某个元素所在下标，就可以使用ForeachSeqList函数，搭配FindData函数传参对遍历到的数据进行操作。如果要存放字符串类型的，最好写成以下形式。空间可以不连续，访问元素方便。
数据结构—顺序表
qq_43344188的博客
08-27 389
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1253
KMP算法：理解next[]表
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1129
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
Java算法之插入排序（Insertion Sort）
weixin_38959316的博客
08-29 132
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值