java数据结构课程设计_数据结构课程设计迷宫算法实现_java.pdf

最新推荐文章于 2023-05-10 16:36:29 发布
最新推荐文章于 2023-05-10 16:36:29 发布
阅读量222 收藏
点赞数
文章标签： java数据结构课程设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34707242/article/details/114463733
版权

数据结构课程设计迷宫算法实现_java

数据结构课程设计

走迷宫

学号：200908204136

姓名：熊军

6 16

日期： 月 日

一、题目说明

.分别用以下算法实现。并设计图形用户界面提供迷宫大小、入口及出口位置和初始状

态等，演示走迷宫的过程和结果。

1.递归算法。

2.使用栈作为辅助结构。

3.使用队列作为辅助结构。

二、总体设计方案以及细节设计

为实现上述程序功能，主要使用的JAVA AWT 和JAVA SWING 包

import java.awt.*;

import javax.swing.*;

import hartech.ui.*;

3. 本程序包含四个模块：

1) 主程序模块：

package mg;

import java.awt.*;

import javax.swing.*;

/**

*

Title: maze Global class

*

*

Description:

*

*

Date: 2006-08-31

*/

public class Main {

// _reset 变量用于reset 时用

static int rows 12, cols 14;

static int speed_reset 50, speed speed_reset;

static JToggleButton [][] buttons;

static Walking walking;

static boolean [][] brick, brick_reset {

{ true, true, true, true, true, false, true, true, true,

true,

true, true, true, true, },

{ true, false, false, false, true, false, true, true, true,

true,

false, false, false, true, },

{true, false, true, false,true, false, false, false, false,

true,

true, false, true, true, },

{ true, false, true, false, true, false, true, true, true,

false,

true, false, true, false, },

{ true, true, true, false, false, false, true, false, true,

false,

true, false, true, true, },

{ true, false, true, true, true, true, true, false, true,

false,

true, false, false, true, },

{ true, false, true, true, true, true, true, false, true,

false,

true, false, true, true, },

{ true, false, false, false, false, false, true, true, true,

false,

true, false, true, false, },

{ true, false, true, true, true, false, false, false, false,

false,

l00f
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构课程设计报告】路径规划系统（Java实现）
爱喝牛奶的甜玉米
07-22 821
第二章 路径规划系统 路径规划系统存储结构设计采用有向图的邻接矩阵存储结构，其业务活动包括：路径信息的添加、以邻接矩阵方式显示路径信息、最短路径的两种规划方式（1.Dijkstra 2.Floyd）等，需对指定内容进行分析设计利用计算机加以实现。......
java课设迷宫游戏_Java编写迷宫小游戏
weixin_35056962的博客
02-01 1277
缘起：去年(大三上学期)比较喜欢写小游戏，于是想试着写个迷宫试一下。程序效果：按下空格显示路径：思考过程：迷宫由一个一个格子组成，要求从入口到出口只有一条路径.想了一下各种数据结构，似乎树是比较合适的，从根节点到每一个子节点都只有一条路径。假设入口是根节点，出口是树中某个子节点，那么，从根节点到该子节点的路径肯定是唯一的。所以如果能构造一棵树把所有的格子都覆盖到，也就能够做出一个迷宫了。另外还要求...
java数据结构课程设计_java数据结构课程设计
weixin_33603681的博客
02-21 1184
华东交大理工学院课程设计(论文)任务书电信分院2009 电子商务专业一班一、课程设计(论文)题目走迷宫二、课程设计(论文)工作自 2011 年6月20 日起至 2011 年6月30 日止。三、课程设计(论文) 地点: 机房四、课程设计(论文)内容要求：1．本课程设计的目的(1)熟练掌握数据结构的基本算法，提高算法设计与分析能力(2)基本掌握面向对象设计基本思路和方法；(3)利用所学的基...
数据结构课设教学计划编制问题Java
qq_60456338的博客
12-25 1805
解决方法：通过对AOV网邻接表的遍历，将入度为0的元素入栈，当栈不为空时，就出栈，并将出栈的元素存放到链表当中，不断重复这样的操作，直到遍历完毕，接着将链表当中课程的名字和学分分别存放到两个动态的数组，在通过for循环遍历，满足每学期的课程的学分之和不超过其上限，当剩下的课程和剩下的学期数相等时就结束循环。每个专业开设的课程都是确定的，而且课程在开设时间的安排必须满足先修关系。网的节点，满足课程之间的先修关系，利用图的拓扑排序来进行学期之间的课程排序安排，并按照每学期的课程学分和学习负担来输出。
基于JAVA的迷宫游戏设计与实现
weixin_52551448的博客
05-10 1265
程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓。游戏的任务是使用键盘上的方向键操纵老鼠在规定的时间内走到粮仓处。
数据结构课程设计迷宫算法的实现-JAVA.doc
11-29
数据结构课程设计迷宫算法的实现-JAVA.doc
migongwenti.rar_数据结构课程设计_课程设计_迷宫问题
09-14
数据结构课程设计_迷宫问题 会有所帮助得
迷宫问题算法及数据结构课程设计报告.doc
11-29
迷宫问题算法及数据结构课程设计报告.doc
数据结构课程设计迷宫算法的实现_JAVA.doc
06-20
数据结构课程设计迷宫算法的实现_JAVA.doc
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
java数据结构课程设计
01-20
大二学数据结构的课设（java版） 做得很简单 见笑了 包括背包问题的求解，、内部排序算法的性能分析、停车厂模拟管理程序的设计与实现。
数据结构课程设计
12-12
数据结构课程设计，是用java程序写的代码，希望对做课程设计的有一个很好的参考价值！
java数据结构课程设计java代码
07-29
界面使用swing做的，也利用的一些文件来存储数据，希望对大家能够有所帮助
数据结构（Java）迷宫实现
11-29
数据结构（Java）实践作业迷宫参考书本使用栈结构实现的
数据结构课程设计报告java+哈夫曼树
01-22
java课程设计关于哈夫曼树编码译码,输入一串字符串,将其根据字符出现的频率建哈夫曼树并根据树进行译码。 此word的代码完全拷贝在eclipse可直接运行,此文档仅供参考,希望各位能做出自己的修改成适合自己的文档。
Java数据结构课程设计（fntp开源）
FNTP_
01-17 3172
java数据结构课程设计（哈夫曼树压缩实现） 开源作者：fntp QQ358566760欢迎读者与笔者交流沟通 使用java数据结构与算法，来实现哈夫曼树压缩文本数据，如何实现呢？ 哈夫曼树简单介绍： 在计算机数据处理中，哈夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用...
【数据结构课设】扫雷 （java实现）
m0_67463447的博客
05-21 5302
目录 一、问题描述 二、逻辑结构设计 三、存储结构设计 三、主要操作设计 四、技术难点与解决方法 五、实现与展示 六、详细代码 七、游戏内图片 一、问题描述 设计实现经典扫雷游戏，要求如下： (1) 分初级、中级和高级三个级别，扫雷英雄榜存储每个级别的最好成绩，即挖出所有地雷 且用时最少者。 (2) 选择级别后出现相对应级别的扫雷区域，用户使用鼠标左键单击雷区中任一方块便启动 计时器。 (3) 单击方块，若所揭方块下有雷，则 Game Over；若所揭方块下无雷，
数据结构课程设计 - 二叉树系统实现java
qq_40635117的博客
04-22 1412
数据结构课程设计 - 二叉树系统实现java 问题描述 从键盘读入一组数据，建立二叉排序树并对其进行查找、遍历、格式化输出操作。设数据元素关键字序列为{11,33,44,55,58,79,88}。 需求分析 1.按照用户的需求，构建二叉排序树。 2.对二叉排序树进行遍历输出操作。 3.对二叉排序树进行查找，包括成功和不成功两种情况，并给出查找长度。 4.对二叉排序树进行插入操作。 5.对二叉排序树进行删除操作。 1、主界面设计 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img
java 迷宫游戏_Java小项目之迷宫游戏的实现方法
weixin_42509803的博客
02-20 1211
项目要求：一个网格迷宫由n行n列的单元格组成，每个大院个要么是空地(用0表示)，要么是障碍物(用1表示)，你的任务是找一条从起点到终点的移动序列，其中只能上下左右移动到相邻单元格。任何时候都不能在有障碍物的单元格中，也不能走到迷宫之外，起点为左上角和终点右下角。项目功能：解决迷宫路径查找问题，寻找一条从左上角迷宫入口到右下角迷宫出口的一条有效路径，0代表可走，1代表能走，找到请输出最终的迷宫和路径...
java+数据结构课程设计
最新发布
12-12
Java + 数据结构课程设计可以包含以下内容： 1. 数据结构的基本操作：包括栈、队列、链表、树、图等数据结构的基本操作，如插入、删除、查找等。 2. 数据压缩与解压缩：可以使用哈夫曼编码等算法实现数据的压缩和解压缩。 3. 24点扑克牌游戏：可以使用栈和递归等数据结构和算法实现24点扑克牌游戏的计算和判断。 4. 16枚硬币的反面问题：可以使用递归和分治等算法实现16枚硬币的反面问题的求解。 5. 线性表、树、图的操作和演示：可以实现线性表、树、图等数据结构的基本操作，并通过图形化界面演示它们的操作过程。 6. 农夫过河：可以使用广度优先搜索等算法实现农夫过河问题的求解。 7. 迷宫问题：可以使用深度优先搜索等算法实现迷宫问题的求解。 以下是一个Java + 数据结构课程设计的例子： 设计一个简单的图形化界面程序，实现以下功能： 1. 实现一个栈和队列的基本操作，包括入栈、出栈、入队、出队等。 2. 实现一个哈夫曼编码的压缩和解压缩功能。 3. 实现24点扑克牌游戏的计算和判断功能。 4. 实现16枚硬币的反面问题的求解功能。 5. 实现线性表、树、图等数据结构的基本操作，并通过图形化界面演示它们的操作过程。 6. 实现农夫过河问题和迷宫问题的求解功能。 ```java // 栈的实现 class Stack { private int[] data; private int top; public Stack(int size) { data = new int[size]; top = -1; } public void push(int value) { if (top == data.length - 1) { System.out.println("Stack is full!"); return; } data[++top] = value; } public int pop() { if (top == -1) { System.out.println("Stack is empty!"); return -1; } return data[top--]; } public boolean isEmpty() { return top == -1; } } // 队列的实现 class Queue { private int[] data; private int front; private int rear; public Queue(int size) { data = new int[size]; front = rear = -1; } public void enqueue(int value) { if (rear == data.length - 1) { System.out.println("Queue is full!"); return; } data[++rear] = value; } public int dequeue() { if (front == rear) { System.out.println("Queue is empty!"); return -1; } return data[++front]; } public boolean isEmpty() { return front == rear; } } // 哈夫曼编码的实现 class Huffman { private static class Node implements Comparable<Node> { int value; Node left; Node right; public Node(int value) { this.value = value; } public Node(int value, Node left, Node right) { this.value = value; this.left = left; this.right = right; } public boolean isLeaf() { return left == null && right == null; } @Override public int compareTo(Node o) { return value - o.value; } } public static void compress(String input, String output) throws IOException { // 统计字符出现的次数 int[] freq = new int[256]; for (int i = 0; i < input.length(); i++) { freq[input.charAt(i)]++; } // 构建哈夫曼树 PriorityQueue<Node> pq = new PriorityQueue<>(); for (int i = 0; i < freq.length; i++) { if (freq[i] > 0) { pq.offer(new Node(freq[i], null, null)); } } while (pq.size() > 1) { Node left = pq.poll(); Node right = pq.poll(); pq.offer(new Node(left.value + right.value, left, right)); } Node root = pq.poll(); // 生成哈夫曼编码表 String[] codes = new String[256]; generateCodes(root, "", codes); // 写入压缩文件 try (BitOutputStream out = new BitOutputStream(new FileOutputStream(output))) { // 写入字符出现的次数 for (int i = 0; i < freq.length; i++) { out.writeInt(freq[i]); } // 写入压缩后的数据 for (int i = 0; i < input.length(); i++) { String code = codes[input.charAt(i)]; for (int j = 0; j < code.length(); j++) { out.writeBit(code.charAt(j) - '0'); } } } } public static void decompress(String input, String output) throws IOException { // 读取字符出现的次数 int[] freq = new int[256]; try (BitInputStream in = new BitInputStream(new FileInputStream(input))) { for (int i = 0; i < freq.length; i++) { freq[i] = in.readInt(); } // 构建哈夫曼树 PriorityQueue<Node> pq = new PriorityQueue<>(); for (int i = 0; i < freq.length; i++) { if (freq[i] > 0) { pq.offer(new Node(freq[i], null, null)); } } while (pq.size() > 1) { Node left = pq.poll(); Node right = pq.poll(); pq.offer(new Node(left.value + right.value, left, right)); } Node root = pq.poll(); // 解压缩数据 try (BitOutputStream out = new BitOutputStream(new FileOutputStream(output))) { Node node = root; while (true) { int bit = in.readBit(); if (bit == -1) { break; } if (bit == 0) { node = node.left; } else { node = node.right; } if (node.isLeaf()) { out.write(node.value); node = root; } } } } } private static void generateCodes(Node node, String code, String[] codes) { if (node.isLeaf()) { codes[node.value] = code; return; } generateCodes(node.left, code + "0", codes); generateCodes(node.right, code + "1", codes); } } // 24点扑克牌游戏的实现 class Poker { private static final int TARGET = 24; private static final double EPSILON = 1e-6; public static boolean is24(double[] nums) { if (nums.length == 1) { return Math.abs(nums[0] - TARGET) < EPSILON; } for (int i = 0; i < nums.length; i++) { for (int j = i + 1; j < nums.length; j++) { double[] next = new double[nums.length - 1]; for (int k = 0, l = 0; k < nums.length; k++) { if (k != i && k != j) { next[l++] = nums[k]; } } next[next.length - 1] = nums[i] + nums[j]; if (is24(next)) { return true; } next[next.length - 1] = nums[i] - nums[j]; if (is24(next)) { return true; } next[next.length - 1] = nums[j] - nums[i]; if (is24(next)) { return true; } next[next.length - 1] = nums[i] * nums[j]; if (is24(next)) { return true; } if (nums[j] != 0) { next[next.length - 1] = nums[i] / nums[j]; if (is24(next)) { return true; } } if (nums[i] != 0) { next[next.length - 1] = nums[j] / nums[i]; if (is24(next)) { return true; } } } } return false; } } // 16枚硬币的反面问题的实现 class Coins { private static final int N = 16; private static final int[] COINS = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}; public static void findSolution() { int[] state = new int[N]; for (int i = 0; i < N; i++) { state[i] = 1; } int count = 0; while (true) { count++; int sum = 0; for (int i = 0; i < N; i++) { if (state[i] == -1) { sum += COINS[i]; } } if (sum == 24) { System.out.print("Solution " + count + ": "); for (int i = 0; i < N; i++) { System.out.print(state[i] == -1 ? "H" : "T"); } System.out.println(); } int i = N - 1; while (i >= 0 && state[i] == 1) { state[i] = -1; i--; } if (i < 0) { break; } state[i] = 1; } } } // 农夫过河问题的实现 class Farmer { private static final int MAX_WEIGHT = 10; public static void findSolution() { Queue queue = new Queue(100); queue.enqueue(new State(0, 0, 0, 0)); while (!queue.isEmpty()) { State state = queue.dequeue(); if (state.isFinalState()) { System.out.println(state); break; } for (State next : state.getNextStates()) { if (next.isValidState()) { queue.enqueue(next); } } } } private static class State { int farmer; int wolf; int goat; int cabbage; public State(int farmer, int wolf, int goat, int cabbage) { this.farmer = farmer; this.wolf = wolf; this.goat = goat; this.cabbage = cabbage; } public boolean isFinalState() { return farmer == 1 && wolf == 1 && goat == 1 && cabbage == 1; } public boolean isValidState() { if (wolf == goat && farmer != wolf) { return false; } if (goat == cabbage && farmer != goat) { return false; } return true; } public List<State> getNextStates() { List<State> nextStates = new ArrayList<>(); if (farmer == 0) { nextStates.add(new State(1, wolf, goat, cabbage)); } else { nextStates.add(new State(0, wolf, goat, cabbage)); } if (farmer == wolf) { if (farmer == 0) { nextStates.add(new State(1, 1, goat, cabbage)); } else { nextStates.add(new State(0, 0, goat, cabbage)); } } if (farmer == goat) { if (farmer == 0) { nextStates.add(new State(1, wolf, 1, cabbage)); } else { nextStates.add(new State(0, wolf, 0, cabbage)); } } if (farmer == cabbage) { if (farmer == 0) { nextStates.add(new State(1, wolf, goat, 1)); } else { nextStates.add(new State(0, wolf, goat, 0)); } } return nextStates; } @Override public String toString() { return "State{" + "farmer=" + farmer + ", wolf=" + wolf + ", goat=" + goat + ", cabbage=" + cabbage + '}'; } } } // 迷宫问题的实现 class Maze { private static final int[][] DIRECTIONS = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}}; public static void findSolution(int[][] maze, int startX, int startY, int endX, int endY) { Queue queue = new Queue(100); queue.enqueue(new Point(startX, startY)); while (!queue.isEmpty()) { Point point = queue.dequeue(); if (point.x == endX && point.y == endY) { System.out.println("Solution found!"); return; } for (int[] dir : DIRECTIONS) { int x = point.x + dir[0]; int y = point.y + dir[1]; if (x >= 0 && x < maze.length && y >= 0 && y < maze[0].length

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值