C++数据结构（第五次实习）

已于 2022-10-11 18:06:31 修改
阅读量105 收藏 1
点赞数 1
分类专栏： 数据结构+算法 文章标签： 数据结构 算法 c++
于 2022-03-08 09:45:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51287641/article/details/121723701
版权

目录


第五次实习是关于图的操作
但实际实习过程中，还是以解出题目为主要目的。简单记录一下

由于牛客网考试系统答题，不敢截屏，所以用手机将题目描述拍了下来

1.DFS和BFS遍历输出

在这里插入图片描述
看到类名为Tu，我自己都笑了
代码

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

class Tu{
public:
    int *point;
    int **line;
    int n;
public:
    Tu(int m){
        this->n = m;
        point = new int[n];
        line = (int **)new int*[n];
        for(int i = 0;i < n;i++){
            line[i] = new int[n];
        }
    }

    ~Tu(){
        delete point;
        for(int i = 0;i < n;i++){
            delete line[i];
        }
        delete line;
    }

    void create(){
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                cin >> line[i][j];
            }
        }
        for(int i = 0;i < n;i++){
            point[i] = i;
        }
    }

    void dfs(int x){
        stack<int> s;
        int j = x;
        int *tag = new int[n];
        for(int i =0;i < n;i++){
            tag[i] = 0;
        }
        s.push(x);
        tag[x] = 1;
        cout << point[j] << " ";
        while(true){
            for(int i = 0;i < n;i++){
                if(line[j][i] == 1 && tag[i] == 0){
                    tag[i] = 1;
                    s.push(i);
                    cout << point[i] << " ";
                    j = i;
                    break;
                }
                if(i==n-1){
                    if(!s.empty()){
                        j = s.top();
                        s.pop();
                    }
                    else{
                        return;
                    }
                }
            }
        }
    }

    void bfs(int x){
        queue<int> q;
        int j;
        int *tag = new int[n];
        for(int i =0;i < n;i++){
            tag[i] = 0;
        }
        q.push(x);
        tag[x] = 1;
        while(!q.empty()){
            j = q.front();
            q.pop();
            cout << point[j] << " ";
            for(int i = 0;i < n;i++){
                if(line[j][i] == 1 && tag[i] == 0){
                    tag[i] = 1;
                    q.push(i);
                }
            }
        }
    }
};


int main()
{
    int n;
    cin >> n;
    Tu tu(n);
    tu.create();

    cout << "DFS" << endl;
   for(int i = 0;i < n;i++){
       tu.dfs(i);
       cout << endl;
   }
    cout << "WFS" << endl;
    for(int i = 0;i < n;i++){
        tu.bfs(i);
        cout << endl;
    }
    return 0;
}

2.Prim和Kruskal最小生成树

在这里插入图片描述
这里注意一下compare，在这里卡了很久
以及prim从优先级队列取出对头后，如果不符合得放回去

代码

#include <iostream>
#include <queue>

using namespace std;

struct EdgeNode{
    int weight;
    int left;
    int right;
    EdgeNode(int _weight = 0,int _left = 0,int _right = 0){
        weight = _weight;
        left = _left;
        right = _right;
    }
};

struct compare{
    bool operator()(EdgeNode *n1,EdgeNode *n2){
        if(n1->weight == n2->weight){
            return n1->left > n2->left;
        }
        return n1->weight > n2->weight;
    }
};

class MinTree{
private:
    priority_queue<EdgeNode*,vector<EdgeNode*>,compare> q;
    int n;
public:
    MinTree(int m){n = m;}
    ~MinTree(){}

    void init(int **a){
        while(!q.empty()) q.pop();
        for(int i = 0;i < n;i++){
            for(int j = i+1;j < n;j++){
                if(a[i][j] != 0){
                    EdgeNode *tmp = new EdgeNode(a[i][j],i,j);
                    q.push(tmp);
                }
            }
        }
    }

    void kruskal(){
        int *point = new int[n];
        for(int i = 0;i < n;i++){
            point[i] = i;
        }

        int **k = (int **) new int*[n];
        for(int i = 0;i < n;i++){
            k[i] = new int[n];
        }
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                k[i][j] = 0;
            }
        }

        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                cout << k[i][j] << " ";
            }
            cout << endl;
        }
        cout << endl;

        int count = 0;
        EdgeNode *tmp = new EdgeNode();
        int swapNum;
        while(true){
            tmp = q.top();
            q.pop();
            if(point[tmp->left] != point[tmp->right]){
                count++;
                if(point[tmp->left] < point[tmp->right]){
                    swapNum = point[tmp->right];
                    for(int i = 0;i < n;i++){
                        if(point[i] == swapNum){
                            point[i] = point[tmp->left];
                        }
                    }
                }
                else{
                    swapNum = point[tmp->left];
                    for(int i = 0;i <n;i++){
                        if(point[i] == swapNum){
                            point[i] = point[tmp->right];
                        }
                    }
                }

                k[tmp->left][tmp->right] = tmp->weight;
                k[tmp->right][tmp->left] = tmp->weight;
                for(int i = 0;i < n;i++){
                    for(int j = 0;j < n;j++){
                        cout << k[i][j] << " ";
                    }
                    cout << endl;
                }
                if(q.empty() || count == n-1) break;
                else cout << endl;
            }
        }
    }

    void prim(){
        int **p = (int **) new int*[n];
        for(int i = 0;i < n;i++){
            p[i] = new int[n];
        }
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                p[i][j] = 0;
            }
        }
        for(int i = 0;i < n;i++){
            for(int j = 0;j < n;j++){
                cout << p[i][j] << " ";
            }
            cout << endl;
        }
        cout << endl;

        EdgeNode *tmp = new EdgeNode();
        int count = 1;
        int *a = new int[n];
        queue<EdgeNode*> que;
        for(int i = 1;i < n;i++){
            a[i] = 0;
        }
        a[0] = 1;

        while(count < n && !q.empty()){
            tmp = q.top();
            q.pop();
            if(a[tmp->left] != a[tmp->right]){
                count++;
                if(a[tmp->left] == 1) a[tmp->right] = 1;
                else a[tmp->left] = 1;

                p[tmp->left][tmp->right] = tmp->weight;
                p[tmp->right][tmp->left] = tmp->weight;
                for(int i = 0;i < n;i++){
                    for(int j = 0;j < n;j++){
                        cout << p[i][j] << " ";
                    }
                    cout << endl;
                }
                cout << endl;
                while(!que.empty()){
                    q.push(que.front());
                    que.pop();
                }
            }
            else{
                que.push(tmp);
            }
            if(!que.empty() && q.empty()){
                EdgeNode *tmp = new EdgeNode();
                while(!que.empty()){
                    tmp = que.front();
                    q.push(tmp);
                    que.pop();
                }
            }

        }
    }
};


int main()
{
    int n;
    int **a;
    cin >> n;
    a = (int**) new int*[n];
    for(int i = 0;i < n;i++){
        a[i] = new int[n];
    }
    for(int i = 0;i < n;i++){
        for(int j = 0;j < n;j++){
            cin >> a[i][j];
        }
    }

    MinTree *tree = new MinTree(n);
    tree->init(a);
    cout << "Prim:" << endl;
    tree->prim();

    tree->init(a);
    cout << "Kruskal:" << endl;
    tree->kruskal();

    return 0;
}

3.迪杰斯特拉算法求最短路径

在这里插入图片描述
这道题由于每条边的权重都为1，所以选择用队列，用广度优先进行求解，
能过就行

代码

#include <iostream>
#include <queue>
#include <stack>

using namespace std;

struct PointNode{
    int i;
    int j;
    PointNode *farther;
    PointNode(int _i = 0,int _j = 0,PointNode *_farther = NULL){
        i = _i;
        j = _j;
        farther = _farther;
    }
};


class Graph{
private:
    int m,n;
    int **a;
    PointNode *start;
    PointNode *end;
    queue<PointNode*> q;
public:
    Graph(int _m,int _n){
        m = _m;
        n = _n;
        a = (int**) new int*[m];
        for(int i = 0;i < m;i++){
            a[i] = new int[n];
        }
    }
    ~Graph(){
        for(int i = 0;i < m;i++){
            delete a[i];
        }
        delete a;
    }

    void init(){
        for(int i = 0; i < m;i++){
            for(int j = 0;j < n;j++){
                cin >> a[i][j];
                if(a[i][j] == 3){
                    a[i][j] = 0;
                    start = new PointNode(i,j);
                }
                else if(a[i][j]==4){
                    end = new PointNode(i,j);
                }
            }
        }
    }

    void minFind(){
        q.push(start);
        PointNode *current  = new PointNode();
        while(!q.empty()){
            current  = q.front();
            q.pop();
            //cout << current->i << " " << current->j << endl;
            if(current->i == end->i && current->j == end->j) {
                myPrint(current);
                break;
            }
            if(current->i-1 >= 0 && a[current->i-1][current->j]!=0){
                a[current->i-1][current->j] = 0;
                q.push(new PointNode(current->i-1,current->j,current));
            }
            if(current->j+1 <= n-1 && a[current->i][current->j+1]!=0){
                a[current->i][current->j+1] = 0;
                q.push(new PointNode(current->i,current->j+1,current));
            }
            if(current->j-1 >= 0 && a[current->i][current->j-1]!=0){
                a[current->i][current->j-1] = 0;
                q.push(new PointNode(current->i,current->j-1,current));
            }
            if(current->i+1 <= m-1 && a[current->i+1][current->j]!= 0){
                a[current->i+1][current->j] = 0;
                q.push(new PointNode(current->i+1,current->j,current));
            }

        }
    }

    void myPrint(PointNode *n){
        PointNode *current = n;
        stack<PointNode*> s;
        while(current->farther != NULL){
            s.push(current);
            current = current->farther;
        }
        cout << start->i << " " << start->j << endl;
        while(!s.empty()){
            current = s.top();
            s.pop();
            cout << current->i << " " << current->j << endl;
        }
    }
};

int main()
{
    int m,n;
    cin >> m >> n;
    Graph *g = new Graph(m,n);
    g->init();
    g->minFind();
    return 0;
}

4.拓扑排序判断是否有环

在这里插入图片描述

通过farther数组存放入度
child二维数组存放指出的边所对应的顶点

代码

#include <iostream>

using namespace std;

class Graph{
private:
    int n;
    int restNum;
    int *farther;
    int **child;

public:
    Graph(int _n){
        n = _n;
        restNum = n;
        farther = new int[n];
        child = (int**)new int*[n];
        for(int i = 0;i < n;i++){
            child[i] = new int[n];
        }
        for(int i = 0;i < n;i++){
            farther[i] = 0;
            for(int j = 0;j < n;j++){
                child[i][j] = -1;
            }
        }
    }
    ~Graph(){
        delete farther;
        for(int i = 0; i < n;i++){
            delete child[i];
        }
        delete child;
    }

    void init(){
        int a;
        for(int i = 0; i < n;i++){
            for(int j = 0;j < n;j++){
                cin >> a;
                if(a != 0){
                    farther[j]++;
                    child[i][j] = j;
                }
            }
        }
    }

    int farNum(){
        int num = 0;
        for(int i = 0;i < n;i++){
            if(farther[i] == 0) num++;
        }
        return num;
    }

    void TopSort(){
        while(farNum() > 0){
            int k = -1;
            for(int i = 0;i < n;i++){
                if(farther[i] == 0) {
                    k = i;
                    farther[i] = -1;
                    restNum--;
                    break;
                }
            }
            if(k >= 0){
                for(int i = 0; i < n;i++){
                    if(child[k][i]>0){
                        farther[i]--;
                        child[k][i] = -1;
                    }
                }
            }
        }
        if(restNum==0) cout << "NO" << endl;
        else cout << "YES" << endl;
        return;
    }
};

int main()
{
    int n;
    cin >> n;
    Graph *g = new Graph(n);
    g->init();
    g->TopSort();
    return 0;
}

2021.12.4

如果我是海
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++实习生】每天十道面试题打卡
0泡果奶的博客
03-02 306
第五天，冲冲冲！
数据结构（用面向对象方法与c++语言描述）第二版
06-12
"数据结构（用面向对象方法与C++语言描述）第二版" 本资源为《数据结构（用面向对象方法与C++语言描述）第二版》的课程教学大纲，旨在帮助学生学好数据结构的基础知识和基本概念。课程主要介绍了数据结构的基本概念...
prim
ljc_zy的专栏
06-12 512
#include #include #define MAX_VERT_NUM 40#define INTMAX 32767typedef struct ArcNode{  int adjvex;  int cost;  struct ArcNode *nextarc;}ArcNode;typedef struct VNode{ArcNode *firstarc; /*指向第一条依附该顶点的弧的指针
C++算法与数据结构
闻缺陷则喜何志丹
05-23 1169
本文的算法汇总，包括但不限于动态规划、回溯、贪心、分支、图论、组合数学、数量等。
C++ 数据结构 算数表达式求值——栈存储
Arana的博客
04-06 5238
数据结构实习——算术表达式求值 一、实习题目及要求 1、题目：算术表达式求值 2、要求: （1）正确解释表达式； （2）符合四则运算规则： （3）先乘除、后加减； （4）从左到右运算； （5）先括号内，后括号外； （6）输出最后的计算结果。 二、问题描述 1、对一个合法的中缀表达式求值。 2、假设表达式只包含+、-、*、/ 四个双目运算符，并且允许有括号出现，运算符本身不具有二义性。 三、问题分析...
C++及数据结构复习笔记（绪论）
Lao_tan的博客
07-09 737
摘要        该复习文档是本人根据谭浩强老师的《C++程序设计》、邓俊辉的《数据结构（C++语言版）》和CSDN博客上的众多文章总结而成的。感谢博客上各位大佬的总结，使我在复习课本的同时补充了很多其他方面的关键知识，如C++内存管理，STL库等内容，这些补充的内容可以参考笔者的另一篇文档。本文章适合C++初学者的快速复习和应届生的笔试面试准备，书中给出了大量的面试题，以帮助读者快速的掌握C+...
【数据结构与算法】数据结构知识点总结
JosieBook
06-26 1048
数据结构是计算机科学中的一个重要主题，它涉及到如何组织和存储数据，以便于在计算机程序中进行访问和操作。
c++ 数据结构——二叉树的构建及其应用，实现左右子树交换并输出前序递归结果
Arana的博客
04-06 3288
数据结构实习——二叉树及其应用 一、实习题目及要求 1、题目： 二叉树基本算法的实现 2、功能要求： （1）键盘输入二叉树结点前序序列，创建一棵二叉树； （2）实现SwapTree方法，以根结点为参数，交换每个结点的左子树和右子树（提示：前序递归）； （3）实现Find方法，查找值为key的结点，并输出该结点的所有祖先结点。 3、创建要求： （1）要求键盘输入二叉树前序序列（程序5.12） （2...
记录我的第一次面试（C++实习生）
Wangguang_的博客
04-30 2286
记录我的第一次面试（C++实习生） 前两天在BOSS直聘上上传了自己的简历，投递的方向是C++实习生，一天就接到了HR的消息，让我准备一下初面。虽然知道自己有很多的不足，也知道自己大概率会失败，但是我还是想积累一些经验，于是就准备了一下视频面试，面试开始之后，我打开了手机录音，希望可以在面试之后清楚的整理面试官的问题 先跟大家介绍一下我被问到的问题吧，这些问题难度不大，网上也能轻易找到，就直接贴这...
【C++】秋招&实习面经汇总篇
qq_43840665的博客
02-21 2495
本系列是个人整理为了`秋招`和`实习`面试的，整理期间苛求每个知识点，平衡背诵量与深入程度。
数据结构-计算器实验报告
weixin_45908225的博客
07-25 3998
一、实验目的和要求 1. 设计并实现计算器。 要求：在课后作业-03、课后作业-05的作业内容基础上 （1）增加图形交互功能。 （2）增加3个逻辑运算符 &&、||、 ！，并能处理逻辑运算符和算术运算符的混合运算。 （3）增加容错功能，能进行异常处理。 二、实验环境 Qt 5.9 三、实验内容 在课后作业-03、课后作业-05的作业内容基础上 （1）增加图形交互功能。 （2）增加3个逻辑运算符 &&、||、 ！，并能处理逻辑运算符和算术运算符的混合运算。 （3）增加容错功能，
英文字典 中国地质大学数据结构A上机3
01-11
在这个场景中，我们关注的是"中国地质大学数据结构A"课程的第三次上机实习，任务是通过编程实现一个英文字典。哈希表作为一种高效的数据结构，被选为本次实习的重点。 哈希表，也称为散列表，是一种能够实现快速...
数据结构实习全部C++ 指针
04-09
本实习项目旨在深入理解和应用C++指针在数据结构中的运用。 在C++中，指针是一个变量，其值为另一个变量的地址。理解指针的工作原理至关重要，因为它们在创建复杂数据结构如链表、树、图等时起着关键作用。例如，在...
数据结构实习题目.pdf
12-16
【知识点详解】 1. **数据结构**：本题目主要涉及数据结构中的...综上所述，此实习题目主要考察对链表数据结构的理解，大数运算的实现，以及模板类的使用。解决这个问题需要对C++语言、数据结构和算法有深入的掌握。
数据结构C++课程设计题目
12-28
数据结构C++课程设计题目 本课程设计的主要目的是让学生了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力，并提高综合运用所学的理论知识和方法独立分析和解决问题的能力。通过课程设计，学生将...
数据结构第32节 无锁编程
最新发布
hummhumm的专栏
07-17 832
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 787
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1880
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 230
1%29%5D。
汉诺威塔：算法设计实战与C++实现
学生需要运用递归思想，结合数据结构，如堆栈或队列，来设计一个C++程序来模拟至少五层圆盘的移动过程。该程序需要具备良好的界面设计，明确的功能划分，例如用户输入、显示移动步骤和结果等。 在实习过程中，学生...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值