厦大小学期C语言程序设计实践（四）

最新推荐文章于 2022-08-08 18:50:46 发布
最新推荐文章于 2022-08-08 18:50:46 发布
阅读量659 收藏
点赞数 1
分类专栏： C语言实践 文章标签： C语言实践 厦大
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulizhi1996/article/details/79106569
版权

所有实践项目的源程序可到我的Github上下载：https://github.com/liulizhi1996/C-Programming-Practice-in-short-semester


以下实验二选一。

1、使用队列实现迷宫算法，找到最短路径。

main.cpp 

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

#define MAX_SIZE 30

using namespace std;

class Point
{
public:
    int x;
    int y;

public:
    Point()
    { }

    Point(int a, int b)
    {
        x = a, y = b;
    }

    bool operator <(const Point &pos) const
    {
        if (x < pos.x)
            return true;
        else if (x == pos.x)
        {
            if (y < pos.y)
                return true;
        }
        return false;
    }

    bool operator ==(const Point &pos) const
    {
        return x == pos.x && y == pos.y;
    }

    bool operator !=(const Point &pos) const
    {
        return x != pos.x || y != pos.y;
    }
};

int maze[MAX_SIZE][MAX_SIZE] = { 0 };
queue<Point> open_table;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};

void print_path(map<Point, Point> come_from, int N)
{
    Point pos = Point(N, N);
    stack<Point> path;

    while (pos != Point(1, 1))
    {
        path.push(pos);
        pos = come_from[pos];
    }

    cout << "(1, 1)";
    while (!path.empty())
    {
        pos = path.top();
        cout << "->(" << pos.x << ", " << pos.y << ")";
        path.pop();
    }
    cout << endl;
}

void solve_maze(int N)
{
    map<Point, Point> come_from;

    open_table.push(Point(1, 1));

    while (!open_table.empty())
    {
        Point pos = open_table.front();
        open_table.pop();
        maze[pos.x][pos.y] = -1;

        if (pos.x == N && pos.y == N)
        {
            printf("Path: ");
            print_path(come_from, N);
            return;
        }

        for (int i = 0; i < 4; ++i)
        {
            Point new_pos = Point(pos.x+dx[i], pos.y+dy[i]);
            if (new_pos.x < 1 || new_pos.x > N || new_pos.y < 1 || new_pos.y > N || maze[new_pos.x][new_pos.y] != 0)
                continue;
            open_table.push(new_pos);
            come_from[new_pos] = pos;
        }
    }

    cout << "No path!" << endl;
}

int main()
{
    int N;

    cout << "Please enter the size of maze: ";
    cin >> N;

    cout << "Please enter the maze: " << endl;
    for (int i = 1; i <= N; ++i)
    {
        for (int j = 1; j <= N; ++j)
        {
            cin >> maze[i][j];
        }
    }
    for (int i = 0; i <= N+1; ++i)
    {
        maze[0][i] = maze[N+1][i] = maze[i][0] = maze[i][N+1] = 1;
    }

    solve_maze(N);

    return 0;
}
测试数据： 

Test 1:
8
0 0 1 0 0 0 1 0
0 0 1 0 0 0 1 0
0 0 0 0 1 1 0 0
0 1 1 1 0 0 0 0
0 0 0 1 0 0 0 0
0 1 0 0 0 1 0 0
0 1 1 1 0 1 1 0
1 0 0 0 0 0 0 0

Test 2:
2
1 1
1 1

Test 3:
5
0 1 1 1 1
0 0 0 1 1
1 1 1 1 0
0 0 0 0 1
1 1 0 1 0

Test 4:
3
0 0 1
0 1 1
0 0 1

Test 5:
10
0 0 1 0 0 0 0 1 0 1
1 0 1 0 1 1 0 1 1 0
1 0 0 0 1 1 0 0 0 1
0 1 0 1 1 0 0 1 1 1
0 1 0 0 1 1 0 1 0 0
1 0 1 0 1 1 0 0 1 0
0 1 1 0 0 0 1 0 1 1
0 1 0 1 1 0 0 0 0 0
0 1 1 0 0 1 1 1 1 0
1 0 1 0 1 1 0 0 1 0

Test 6:
8
0 0 1 1 1 0 1 0
1 0 0 1 1 1 0 1
1 1 0 0 0 0 0 1
1 1 0 1 1 1 0 1
1 1 0 1 1 1 0 1
1 1 0 0 0 0 0 1
1 1 1 1 1 1 0 1
1 1 0 0 0 0 0 0

2、实现顺序队列和链队列的所有基本操作，InitQueue(&Q)；DestroyQueue(&Q)；ClearQueue(&Q)；QueueEmpty(Q)；QueueLength(Q)；GetHead(Q, &e); EnQueue(&Q, e)；DeQueue(&Q,&e)；QueueTraverse(Q, visit())。

1）顺序队列（循环队列）

queue.h

#ifndef QUEUE_H
#define QUEUE_H

#define MAX_SIZE 5

struct SqQueue
{
    int *data;
    int front;
    int rear;
};

void InitQueue(struct SqQueue *Q);
void DestroyQueue(struct SqQueue *Q);
void ClearQueue(struct SqQueue *Q);
int QueueEmpty(struct SqQueue Q);
int QueueLength(struct SqQueue Q);
int GetHead(struct SqQueue Q, int *e);
int EnQueue(struct SqQueue *Q, int e);
int DeQueue(struct SqQueue *Q, int *e);
void QueueTraverse(struct SqQueue Q);

#endif //QUEUE_H
queue.cpp 
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

void InitQueue(struct SqQueue *Q)
{
    Q->data = (int *)malloc(sizeof(int) * MAX_SIZE);
    Q->front = Q->rear = 0;
}

void DestroyQueue(struct SqQueue *Q)
{
    free(Q->data);
    Q->front = Q->rear = 0;
}

void ClearQueue(struct SqQueue *Q)
{
    Q->front = Q->rear = 0;
}

int QueueEmpty(struct SqQueue Q)
{
    if (Q.front == Q.rear)
        return 1;
    else
        return 0;
}

int QueueLength(struct SqQueue Q)
{
    return (Q.rear - Q.front + MAX_SIZE) % MAX_SIZE;
}

int GetHead(struct SqQueue Q, int *e)
{
    if (!QueueEmpty(Q))
    {
        *e = Q.data[Q.front];
        return 1;
    }
    else
        return 0;
}

int EnQueue(struct SqQueue *Q, int e)
{
    if ((Q->rear + 1) % MAX_SIZE == Q->front)
        return 0;
    else
    {
        Q->data[Q->rear] = e;
        Q->rear = (Q->rear + 1) % MAX_SIZE;
        return 1;
    }
}

int DeQueue(struct SqQueue *Q, int *e)
{
    if (QueueEmpty(*Q))
        return 0;
    else
    {
        *e = Q->data[Q->front];
        Q->front = (Q->front + 1) % MAX_SIZE;
        return 1;
    }
}

void QueueTraverse(struct SqQueue Q)
{
    for (int i = Q.front; i != Q.rear; i = (i + 1) % MAX_SIZE)
    {
        printf("%d ", Q.data[i]);
    }
    printf("\n");
}

main.cpp

#include <stdio.h>
#include "queue.h"

int main()
{
    struct SqQueue Q;
    int e;

    InitQueue(&Q);
    printf("QueueEmpty: %d\n", QueueEmpty(Q));

    printf("EnQueue 3.\n");
    if (!EnQueue(&Q, 3))
        printf("    EnQueue 3. Error!\n");
    printf("EnQueue 5.\n");
    if (!EnQueue(&Q, 5))
        printf("    EnQueue 5. Error!\n");
    printf("EnQueue 2.\n");
    if (!EnQueue(&Q, 2))
        printf("    EnQueue 2. Error!\n");

    printf("Length: %d\n", QueueLength(Q));
    printf("QueueEmpty: %d\n", QueueEmpty(Q));

    DeQueue(&Q, &e);
    printf("DeQueue %d.\n", e);
    GetHead(Q, &e);
    printf("GetHead: %d.\n", e);

    printf("EnQueue 9.\n");
    if (!EnQueue(&Q, 9))
        printf("    EnQueue 9. Error!\n");
    printf("EnQueue 4.\n");
    if (!EnQueue(&Q, 4))
        printf("    EnQueue 4. Error!\n");
    printf("EnQueue 7.\n");
    if (!EnQueue(&Q, 7))
        printf("    EnQueue 7. Error!\n");

    printf("QueueTraverse: ");
    QueueTraverse(Q);

    printf("ClearQueue\n");
    ClearQueue(&Q);
    if (!DeQueue(&Q, &e))
        printf("    DeQueue Error.\n");

    printf("EnQueue 11.\n");
    if (!EnQueue(&Q, 11))
        printf("    EnQueue 11. Error!\n");
    printf("EnQueue 14.\n");
    if (!EnQueue(&Q, 14))
        printf("    EnQueue 14. Error!\n");
    printf("EnQueue 17.\n");
    if (!EnQueue(&Q, 17))
        printf("    EnQueue 17. Error!\n");
    printf("QueueTraverse: ");
    QueueTraverse(Q);

    DestroyQueue(&Q);

    return 0;
}
2）链式队列

queue.h

#ifndef QUEUE_H
#define QUEUE_H

struct QueueNode
{
    int data;
    struct QueueNode *next;
};

struct LinkQueue
{
    struct QueueNode *front;
    struct QueueNode *rear;
};

void InitQueue(struct LinkQueue *Q);
void DestroyQueue(struct LinkQueue *Q);
void ClearQueue(struct LinkQueue *Q);
int QueueEmpty(struct LinkQueue Q);
int QueueLength(struct LinkQueue Q);
int GetHead(struct LinkQueue Q, int *e);
void EnQueue(struct LinkQueue *Q, int e);
int DeQueue(struct LinkQueue *Q, int *e);
void QueueTraverse(struct LinkQueue Q);

#endif //QUEUE_H
queue.cpp 
#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

void InitQueue(struct LinkQueue *Q)
{
    Q->front = (struct QueueNode *)malloc(sizeof(struct QueueNode));
    Q->front->next = NULL;
    Q->rear = Q->front;
}

void DestroyQueue(struct LinkQueue *Q)
{
    struct QueueNode *p = Q->front, *q;

    while (p)
    {
        q = p->next;
        free(p);
        p = q;
    }

    Q->front = Q->rear = NULL;
}

void ClearQueue(struct LinkQueue *Q)
{
    struct QueueNode *p = Q->front->next, *q;

    while (p)
    {
        q = p->next;
        free(p);
        p = q;
    }

    Q->rear = Q->front;
}

int QueueEmpty(struct LinkQueue Q)
{
    if (Q.front == Q.rear)
        return 1;
    else
        return 0;
}

int QueueLength(struct LinkQueue Q)
{
    struct QueueNode *p = Q.front->next;
    int len = 0;

    while (p)
    {
        ++len;
        p = p->next;
    }

    return len;
}

int GetHead(struct LinkQueue Q, int *e)
{
    if (!QueueEmpty(Q))
    {
        *e = Q.front->next->data;
        return 1;
    }
    else
        return 0;
}

void EnQueue(struct LinkQueue *Q, int e)
{
    struct QueueNode *p = (struct QueueNode *)malloc(sizeof(struct QueueNode));
    p->data = e;
    p->next = NULL;
    Q->rear->next = p;
    Q->rear = p;
}

int DeQueue(struct LinkQueue *Q, int *e)
{
    if (!QueueEmpty(*Q))
    {
        struct QueueNode *p = Q->front->next;
        Q->front->next = p->next;
        if (!p->next)
            Q->rear = Q->front;
        *e = p->data;
        free(p);
        return 1;
    }
    else
        return 0;
}

void QueueTraverse(struct LinkQueue Q)
{
    if (!QueueEmpty(Q))
    {
        struct QueueNode *p = Q.front->next;

        while (p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
    }
    printf("\n");
}
main.cpp 
#include <stdio.h>
#include "queue.h"

int main()
{
    struct LinkQueue Q;
    int e;

    InitQueue(&Q);
    printf("QueueEmpty: %d\n", QueueEmpty(Q));

    printf("EnQueue 3.\n");
    EnQueue(&Q, 3);
    printf("EnQueue 5.\n");
    EnQueue(&Q, 5);
    printf("EnQueue 2.\n");
    EnQueue(&Q, 2);

    printf("Length: %d\n", QueueLength(Q));
    printf("QueueEmpty: %d\n", QueueEmpty(Q));

    DeQueue(&Q, &e);
    printf("DeQueue %d.\n", e);
    GetHead(Q, &e);
    printf("GetHead: %d.\n", e);

    printf("EnQueue 9.\n");
    EnQueue(&Q, 9);
    printf("EnQueue 4.\n");
    EnQueue(&Q, 4);
    printf("EnQueue 7.\n");
    EnQueue(&Q, 7);

    printf("QueueTraverse: ");
    QueueTraverse(Q);

    printf("ClearQueue\n");
    ClearQueue(&Q);
    if (!DeQueue(&Q, &e))
        printf("    DeQueue Error.\n");

    printf("EnQueue 11.\n");
    EnQueue(&Q, 11);
    printf("EnQueue 14.\n");
    EnQueue(&Q, 14);
    printf("EnQueue 17.\n");
    EnQueue(&Q, 17);
    printf("QueueTraverse: ");
    QueueTraverse(Q);

    DestroyQueue(&Q);

    return 0;
}

liulizhi1996
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言程序设计第四版ppt课件.ppt
11-12
C语言程序设计第四版ppt课件 本资源主要介绍C语言程序设计的基本概念、语法和特点，并对C语言的发展历史、特点和基本概念进行了详细的讲解。 C语言发展历史 C语言的发展历史可以追溯到1972年， Ken.Thompson和...
【C语言程序设计】大学第一学期C语言程序设计模拟考试题答案.docx
12-13
本资源摘要信息适合大学第一学期C语言程序设计的学生和教师使用，可以作为教学和备考的参考资料。 知识点摘要: 1. 变量和数据类型：变量的定义和使用、基本数据类型、复杂数据类型等。 2. 运算符和表达式：算术...
厦大小学期C语言程序设计实践（五）
荔枝的FM
01-19 952
所有实践项目的源程序可到我的Github上下载：https://github.com/liulizhi1996/C-Programming-Practice-in-short-semester•      使用动态链表完成一个简单的商品库存信息管理系统。•      商品信息包括如下字段：商品号、商品名称、商品库存•      函数create：接收用户输入的商品号和商品名称的信息，建立链表；库存
厦大小学期C语言程序设计实践（一）
荔枝的FM
01-19 1521
所有实践项目的源程序可到我的Github上下载：https://github.com/liulizhi1996/C-Programming-Practice-in-short-semester任务1：英雄出世炎热的夏天午后，小明正在百无聊赖地写c语言程序。忽然，电脑屏幕一阵抖动，浮现下面18×18个看似杂乱无章的数字：  32,  32,  32, 32,  32,  32, 32,  32, 
厦大小学期C语言程序设计实践（二）
荔枝的FM
01-19 773
所有实践项目的源程序可到我的Github上下载：https://github.com/liulizhi1996/C-Programming-Practice-in-short-semester任务一：颠倒的世界小明最近突然喜欢倒着写字，写出来的句子全是颠倒的，也就是把一句话里的字符全都逆序写，譬如“I Love This Game！”，他就偏偏要写成“!emaG sihT evoL I”弄的小华同
2021-2022年小学期 程序设计开发实践 随堂笔记
筱柒LittleSeven
08-08 693
2021-2022小学期 程序设计开发实践随堂笔记。作者：筱柒_Littleseven
厦大C语言上机 1363 简单的数列求和
荔枝的FM
01-08 1033
1363.简单的数列求和 时间限制: 1000 MS          内存限制: 65536 K          提交数: 711 (0 users)          通过数: 308 (293 users) 问题描述 再来，有通项公式 求前n项和Sn 输入格式 输入n 输出格式 输出前n项和Sn(保留4位小数)
[C语言程序设计(第四版)].谭浩强.高清_C语言程序设计第四版_
10-02
《C语言程序设计（第四版）》是谭浩强教授的经典著作，对于初学者来说，是一本极佳的入门教材。这本书深入浅出地讲解了C语言的基础知识和编程技巧，帮助读者掌握这一强大而灵活的编程语言。下面将详细阐述书中涉及的...
谭浩强C语言程序设计第五版详细答案
11-10
《谭浩强C语言程序设计第五版》是学习C语言的经典教材，旨在帮助初学者掌握C语言编程的基础知识。本书不仅适用于大一学生，也适合自学者。在本章中，我们将深入探讨C语言程序设计的基本概念和核心知识点。 1.1 程序...
C语言程序设计-火车订票系统
06-04
任务要求: 创建一个火车票管理系统，功能包括： （1）录入班次信息(信息用文件保存),可不定时地增加班次数据 （2）浏览班次信息,可显示出所有班次当前状总(如果当前系统时间超过了某班 次的发车时间,则...附有源程序。
厦大C语言上机 1360 算日期
荔枝的FM
01-08 1134
1360.算日期 时间限制: 1000 MS          内存限制: 65536 K          提交数: 647 (0 users)          通过数: 286 (279 users) 问题描述     自从收了小明这个徒弟之后，小强的生活就没平静过，小明发扬勤奋好问的精神，总是缠着小强问这问那的。这天，小强在去食堂的路上不小心看见小明迎面走来，正打
厦大小学期C语言程序设计实践（三）
荔枝的FM
01-19 1311
所有实践项目的源程序可到我的Github上下载：https://github.com/liulizhi1996/C-Programming-Practice-in-short-semester问题描述：以一个n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍，设计一个程序,对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。对于本问题需用栈实现“穷举求解”算法，即：从入口出发，顺
C语言学习笔记——队列
m0_46814663的博客
11-01 2601
队列 队列（queue）简称队 ，它也是 一种 操作受限的线性表 ，其限制为仅允许在表的一端进行插入操作，而在表的另一端进行删除操作。 把进行插入的一端成为队的队尾（rear），把进行删除的一端称为队头或队首（front）。 向队列中插入新元素称为进队或入队（enqueue），新元素进队后就成为新的队尾元素；从队列中删除元素称为出队或离队（dequeue），元素出队后 ， 其直接后继元素就成为队首元素。 //队列抽象数据类型的定义如下： ADT Queue { 数据对象： D = {a(i)|1&
厦大C语言上机 1362 再做分段函数
荔枝的FM
01-08 1089
1362.再做分段函数 时间限制: 1000 MS          内存限制: 65536 K          提交数: 801 (0 users)          通过数: 303 (288 users) 问题描述 这次小明给自己找了一个分段函数的题： 输入格式     第一行输入一个n，代表有n个测试数据，接下来的n行，每行输入变量x的值
第五周-C语言 简单数列的求和
代码屋-CODE HOUSE
09-23 5981
 张威  2016.9.29   数列求和 #include #include int main() { int N=1,sum=0.i; scanf("%d",&N); if(N>0) { for (i=1;i<=2*N-1;) { N=N+2 sum=sum
厦大C语言上机 1361 分数约简
荔枝的FM
01-08 1973
1361.分数约简 时间限制: 1000 MS          内存限制: 65536 K          提交数: 1300 (0 users)          通过数: 299 (283 users) 问题描述 自从小明拜小强为师后，自知和师傅之间有着无法逾越的差距！不过他并不气馁，他决定通过的努力一点一点缩短与师傅之间的距离！这不才刚学完循环结构，他就迫不及待
2024巴黎奥运会中国队奖牌数据
最新发布
08-17
2024巴黎奥运会中国队奖牌数据
DBO-LightGBM蜣螂优化算法优化LightGBM分类预测，优化前后对比（Matlab完整源码和数据）
08-17
1.Matlab实现DBO-LightGBM蜣螂优化算法优化LightGBM分类预测,优化前后对比，Matlab调用Python的LightGBM库（完整源码和数据）。 2.输出对比图、混淆矩阵图、预测准确率，运行环境Matlab2023及以上，配置Python的LightGBM库。兼容测试链接：https://ww2.mathworks.cn/support/requirements/python-compatibility.html 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：机器学习之心，博客专家认证，机器学习领域创作者，2023博客之星TOP50，主做机器学习和深度学习时序、回归、分类、聚类和降维等程序设计和案例分析，文章底部有博主联系方式。从事Matlab、Python算法仿真工作8年，更多仿真源码、数据集定制私信。
C语言程序设计实践指南
"该资源是一本关于高级语言程序设计的实验指导...这本书是学习和实践C语言程序设计的理想指南，不仅提供了理论知识，还强调了实践操作和问题解决能力的培养。对于初学者和有一定经验的程序员来说，都是一个宝贵的资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值