2021-06-23

最新推荐文章于 2022-04-20 02:00:18 发布

Stars-Dirial

最新推荐文章于 2022-04-20 02:00:18 发布

阅读量849

点赞数 1

分类专栏：笔记

本文链接：https://blog.csdn.net/weixin_47302048/article/details/118154087

版权

笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

课程论文
数据结构实践

（2019-2020学年第二学期）

题　　目：2048游戏哈夫曼树校园导航的实现
作　　者：迪力亚尔·
所在学院：
专业年级：　　
指导教师：　　
职　　称：

2020 年 7 月 4 日

声明

本人郑重声明，课程论文——《哈夫曼树校园导航 2048游戏的实现》系本人在相关教师指导下独立完成，没有抄袭、剽窃他人成果，由此造成的一切后果由本人负责。

声明人：迪力亚尔
2020年7月2日

摘要
本次课程设计将明确阐明学籍管理系统及哈夫曼树校园导航 2048游戏的实现的意义及他们所提供的功能，此哈夫曼树巧妙地运用了单链表构建了完美的哈夫曼编码，校园导航运用了有向图与无向图构建了完整的校园导航系统。2048运用了循环，随机产生，隐藏光标等函数，使游戏更流畅。本文提供源代码，运行结果及作者完成程序设计过程中的总结及收获。
关键词：2048；哈夫曼编码；校园导航

ABSTRACT
This course design will clearly clarify the significance of the student status management system and Huffman tree campus navigation 2048 game implementation and the functions they provide, this Huffman tree skillfully uses single chain table to construct the perfect Huffman code, campus navigation uses directed graph and undirected graph to construct the complete campus navigation system. 2048 uses loop, random generation, hidden cursor and other functions to make the game more smooth. This article provides the source code, running results and the author completed the process of programming summary and harvest.

Keywords :2048; Huffman Code; Campus Navigation

1 绪论1
1.1 2048的设计意义1
1.2 飞翔的小鸟的意义1
1.3校园导航意义1
1.4章节概述1
2 概要设计2
2.1 系统的设计目标与设计思想2
2.2 系统的功能结构2
2.3 功能分析3
2.4函数调用4
3 系统模块详细设计7
3.1 2048设计详细7
3.2哈夫曼编码模块设计详细15
3.3校园导航设计详细18
4 运行测试21
4.1运行结果21
总结30
参考文献31
致谢32
新疆大学课程论文（设计）、学年论文评分表33

1 绪论
1.1 2048的设计意义
在枯燥乏味，没事儿干，且不想外出在家想要给大脑放放假的时候我们正需要用一种娱乐方式来调节。这时候电脑游戏是我们的首选之一。那么怎样才能又让脑放松又能达到娱乐的目的。2048正是最好的游戏。它通过简单的计算，部署，用方向键输入方向，除了移动方向的第一层不变，其余层方块皆向该方向移动直至边界或撞到其它方块，如果方块数字一样，原移动方块消失，被撞方块值变为原来的两倍，移动的同时在空白方格会随机生成一个2或4。麻雀虽小，但五脏俱全。这游戏关系到很多算法设计，体现了程序设计的完美。
1.2 哈夫曼编码意义
信息快速发展的这时代信息的处理，储存，和利用是事关重要的大问题。这些庞大的信息和数据怎样才能高效利用不被浪费呢？这时候正是利用哈夫曼数的时候。利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。利用哈夫曼树可以的到平均长度最短的编码，研究操作码的优化问题主要是为了缩短指令字的长度，减少程序的总长度以及增加指令所能表示的操作信息和地址信息。
1.3校园导航的意义
随着科学技术的不断发展，计算机科学日渐成熟，其强大的功能已为人们所深刻认识，它己进入人类社会的各个领域并发挥着越来越重要的作用。采用计算机进行校园导航已成为衡量校园数字化的重要标志。校园导航效率的好坏对于来校参观的客人和学校管理者来说都至关重要，在很大程度上影响着校园的数字化建设和学校的影响力。因此，本文所研究的校园导航系统具有一定的使用价值和现实意义。

1.4章节概述
第二章节：概要设计
第三章节：系统模块详细设计
第四章节：程序测试

2 概要设计

本次哈夫曼编码，校园导航，2048等这些程序设计是一重要的项目之一，它们联系多方面的算法设计，数据处理。可以利用哈夫曼编码处理大量的数据，且不浪费存储空间充分体现了计算机在处理数据方面的优势。校园导航作为最完美的设计理念，给我们带来很多方便。
2.1 系统的设计目标与设计思想
哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。利用哈夫曼树可以的到平均长度最短的编码，研究操作码的优化问题主要是为了缩短指令字的长度，减少程序的总长度以及增加指令所能表示的操作信息和地址信息。
2.2 系统的功能结构
1.2048功能模板图

2.哈夫曼树功能模板图

2.3功能分析
2048功能流程图：

哈夫曼编码功能流程图：

校园导航功能流程图：

2.4函数调用
2048头文件跟主函数：
1.头文件：
#include<stdio.h>
#include<stdlib.h>
#include<time.h> //时间函数，生成随机数需要用到
#include<windows.h>//清屏函数的头文件
#include <conio.h> //getch()函数头文件
2.函数调用：
void print(int a[4][4],int count) //打印游戏基本框架
void birth(int a[4][4]) //随机生成初始坐标
void fresh(int a[4][4]) //每一回合后随机生成2或4
int death(int a[4][4]) //判断游戏是否结束
void run(int a[4][4]) // 运行主函数，算法核心

哈夫曼树头文件跟主函数：

头文件：
#include <stdio.h>
#include<stdlib.h>

#define MAXBIT 100
#define MAXVALUE 10000
#define MAXLEAF 30
#define MAXNODE MAXLEAF*2 -1

函数调用
void HuffmanTree (HNodeType HuffNode[MAXNODE], int n)
校园导航功能模块
模块图：

功能模块：
1.功能模块图;
void CreateUDN();//创建无向网
void Search(）;//查询景点信息
void Shortestpath(int i);//计算最短路径
void Output(int sight1,int sight2)😕/输出函数

3.系统模块详细设计

3.1 2048设计详细
1.打印游戏基本框架

实现代码：
void print(int a[4][4],int count)
{
for(int i=0;i<4;i++)
printf(" – “);
printf(”\n");
for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++)
{
if(j==0)
printf("|");
if(a[i][j]==0)
printf(" |");
else
printf("%3d |",a[i][j]);
}
printf("\n");
for(int h=0;h<4;h++)
printf(" – “);
printf(”\n");
}
printf(“w:up s:down a:left d:right\n”);
printf(“当前得分：%d\n”,count);
}

随机生成初始坐标：
void birth(int a[4][4])
{
srand((unsigned)time(NULL));
int x,y;
x=rand()%4;
y=rand()%4;
a[x][y]=2;
x=rand()%4;
y=rand()%4;
while(a[x][y]==2)
{
x=rand()%4;
y=rand()%4;
}
a[x][y]=2;
}
每回合后随机产生2或4：
void fresh(int a[4][4])
{
srand((unsigned)time(NULL));
int x,y;
x=rand()%4;
y=rand()%4;
while(a[x][y]!=0)
{
x=rand()%4;
y=rand()%4;
}
a[x][y]=(rand()%3?2:4);
}
判断游戏是否结束：
int death(int a[4][4])
{
for(int i=0;i<4;i++)
{
for(int j=0;j<3;j++)
{
if(a[i][j]==a[i][j+1])
return 1;
if(a[j][i]==a[j+1][i])
return 1;
}
}
return 0;
}
运行函数，算法核心：
void run(int a[4][4])
{
char b;
b=getch();
switch(b)
{
case ‘w’:
for(int j=0;j<4;j++)
{
for(int i=3;i>0;i–)
{
if(a[i][j]!=0)
{
for(int h=i-1;h>=0;h–)
{
if(a[h][j]!=0)
{
if(a[h][j]==a[i][j])
{
a[h][j]=2;
a[i][j]=0;
i=h;
break;
}
else
break;
}
}
}
}
}
for(int j=0;j<4;j++)
{
for(int k=0;k<3;k++)
{
if(a[k][j]==0)
{
for(int l=k+1;l<4;l++)
{
if(a[l][j]!=0)
{
a[k][j]=a[l][j];
a[l][j]=0;
break;
}
}
}
}
}
break;
case ‘s’:
for(int j=0;j<4;j++)
{
for(int i=0;i<3;i++)
{
if(a[i][j]!=0)
{
for(int h=i+1;h<=3;h++)
{
if(a[h][j]!=0)
{
if(a[h][j]==a[i][j])
{
a[h][j]=2;
a[i][j]=0;
i=h;
break;
}
else
break;
}
}
}
}
}
for(int j=0;j<4;j++)
{
for(int i=3;i>0;i–)
{
if(a[i][j]==0)
{
for(int k=i-1;k>=0;k–)
{
if(a[k][j]!=0)
{
a[i][j]=a[k][j];
a[k][j]=0;
break;
}
}
}
}
}
break;
case ‘a’:
for(int i=0;i<4;i++)
{
for(int j=3;j>0;j–)
{
if(a[i][j]!=0)
{
for(int k=j-1;k>=0;k–)
{
if(a[i][k]!=0)
{
if(a[i][k]==a[i][j])
{
a[i][k]=2;
a[i][j]=0;
j=k;
break;
}
else
break;
}
}
}
}
}
for(int i=0;i<4;i++)
{
for(int j=0;j<3;j++)
{
if(a[i][j]==0)
{
for(int k=j+1;k<4;k++)
{
if(a[i][k]!=0)
{
a[i][j]=a[i][k];
a[i][k]=0;
break;
}
}
}
}
}
break;
case ‘d’:
for(int i=0;i<4;i++)
{
for(int j=0;j<3;j++)
{
if(a[i][j]!=0)
{
for(int k=j+1;k<4;k++)
{
if(a[i][k]!=0)
{
if(a[i][k]==a[i][j])
{
a[i][k]=2;
a[i][j]=0;
j=k;
break;
}
else
break;
}
}
}
}
}
for(int i=0;i<4;i++)
{
for(int j=3;j>0;j–)
{
if(a[i][j]==0)
{
for(int k=j-1;k>=0;k–)
{
if(a[i][k]!=0)
{
a[i][j]=a[i][k];
a[i][k]=0;
break;
}
}
}
}
}
default:
break;
}
}

3.2哈夫曼编码设计详细

构造一颗哈夫曼树
运行代码：
{
int bit[MAXBIT];
int start;
} HCodeType; /* 编码结构体 /
typedef struct
{
int weight;
int parent;
int lchild;
int rchild;
int value;
} HNodeType; / 结点结构体 */
输入叶子点个数：

运行代码：
void HuffmanTree (HNodeType HuffNode[MAXNODE], int n)
{
int i, j, m1, m2, x1, x2;
for (i=0; i<2n-1; i++)
{
HuffNode[i].weight = 0;//权值
HuffNode[i].parent =-1;
HuffNode[i].lchild =-1;
HuffNode[i].rchild =-1;
HuffNode[i].value=i; //实际值，可根据情况替换为字母
} / end for */

/* 输入 n 个叶子结点的权值 /
for (i=0; i<n; i++)
{
printf (“请依次输入权值 %d: \n”, i);
scanf ("%d", &HuffNode[i].weight);
} / end for */

/* 循环构造 Huffman 树 /
for (i=0; i<n-1; i++)
{
m1=m2=MAXVALUE; / m1、m2中存放两个无父结点且结点权值最小的两个结点 /
x1=x2=0;
/ 找出所有结点中权值最小、无父结点的两个结点，并合并之为一颗二叉树 */
for (j=0; j<n+i; j++)
{
if (HuffNode[j].weight < m1 && HuffNode[j].parent==-1)
{
m2=m1;
x2=x1;
m1=HuffNode[j].weight;
x1=j;
}
else if (HuffNode[j].weight < m2 && HuffNode[j].parent==-1)
{
m2=HuffNode[j].weight;
x2=j;
}
}

输出叶子节点个数
运行代码： HuffNode[x1].parent = n+i;
HuffNode[x2].parent = n+i;
HuffNode[n+i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
HuffNode[n+i].lchild = x1;
HuffNode[n+i].rchild = x2;
```
printf ("x1.weight and x2.weight 第 %d 次: %d, %d\n", i+1, HuffNode[x1].weight, HuffNode[x2].weight);  /* 用于测试 */
printf ("\n");
```
} /* end for */
}
void HuffmanCode()
{

HNodeType HuffNode[MAXNODE];
HCodeType HuffCode[MAXLEAF], cd;
int i, j, c, p, n;
char pp[100];
printf (“请输入叶子结点个数 n:\n”);
scanf ("%d", &n);
HuffmanTree (HuffNode, n);

for (i=0; i < n; i++)
{
cd.start = n-1;
c = i;
p = HuffNode[c].parent;
while (p != -1) /* 父结点存在 /
{
if (HuffNode[p].lchild == c)
cd.bit[cd.start] = 0;
else
cd.bit[cd.start] = 1;
cd.start–; / 求编码的低一位 /
c=p;
p=HuffNode[c].parent; / 设置下一循环条件 /
} / end while */
```
/* 保存求出的每个叶结点的哈夫曼编码和编码的起始位 */
for (j=cd.start+1; j<n; j++)
{ HuffCode[i].bit[j] = cd.bit[j];}
HuffCode[i].start = cd.start;
```
} /* end for */

/* 输出已保存好的所有存在编码的哈夫曼编码 */
for (i=0; i<n; i++)
{
printf ("%d 结点的编码是: “, i);
for (j=HuffCode[i].start+1; j < n; j++)
{
printf (”%d", HuffCode[i].bit[j]);
}
```
printf ("\n");
```
}
}
int main()
{
HNodeType HuffNode[5];
HuffmanCode();
return 0;
}

3.3 校园导航设计详细
1.菜单的创建：

CreateUDN(NUM, 11);
do {
ck = Menu();
switch (ck)
{
case ‘1’:
system(“cls”);
printf("\n\n\t\t\t请选择起点景点（0～9）：");
scanf("%d", &v0);
printf("\t\t\t请选择终点景点（0～9）：");
scanf("%d", &v1); ShortestPath(v0);
output(v0, v1);
printf("\n\n\t\t\t\t请按任意键继续…\n");
getchar();
getchar();
break;
case ‘2’:
search();
printf("\n\n\t\t\t\t请按任意键继续…\n");
getchar();
getchar();
break;
};
} while (ck != ‘t’);
}
char Menu()
{
char c;
int flag;
do {
flag = 1;
system(“cls”); narrate();
printf("\n\t\t\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑\n");
printf("\t\t\t┃ ┃\n");
printf("\t\t\t┃ 1、查询景点路径 ┃\n");
printf("\t\t\t┃ 2、查询景点信息 ┃\n");
printf("\t\t\t┃ t、退出 ┃\n");
printf("\t\t\t┃ ┃\n");
printf("\t\t\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
printf("\t\t\t\t请输入您的选择：");
scanf("%c", &c);
if (c == ‘1’ || c == ‘2’ || c == ‘t’)
flag = 0;
} while (flag);
return c;
}
char SearchMenu()
{
char c;
int flag;
do
{
flag = 1;
system(“cls”);
narrate();
printf("\n\t\t\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┑\n");
printf("\t\t\t┃ ┃\n");
printf("\t\t\t┃ 1、按照景点编号查询 ┃\n");
printf("\t\t\t┃ 2、按照景点名称查询 ┃\n");
printf("\t\t\t┃ t、返回 ┃\n");
printf("\t\t\t┃ ┃\n");
printf("\t\t\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");
printf("\t\t\t\t请输入您的选择："); scanf("%c", &c);
if (c == ‘1’ || c == ‘2’ || c == ‘t’)
flag = 0;
} while (flag);
return c;
}

2.创建无向网：
int i, j;
G.vexnum = v;
G.arcnum = a;
for (i = 0; i<G.vexnum; ++i)
G.vex[i].number = i;
G.vex[0].sight = “体育馆”;
G.vex[0].description = “运动、健身”;
G.vex[1].sight = “数学院”;
G.vex[1].description = “数学分析、高等代数”;
G.vex[2].sight = “信息院”;
G.vex[2].description = “语音处理、人工智能”;
G.vex[3].sight = “红湖”;
G.vex[3].description = “清明澄澈，碧水蓝天”;
G.vex[4].sight = “图书馆”;
G.vex[4].description = “自习、查资料”;
G.vex[5].sight = “餐厅”;
G.vex[5].description = “汉餐、民餐”;
G.vex[6].sight = “外院”;
G.vex[6].description = “俄语、英语”;
G.vex[7].sight = “学生会”;
G.vex[7].description = “处理学生事务”;
G.vex[8].sight = “篮球场”;
G.vex[8].description = “打篮球”;
G.vex[9].sight = “综合楼”;
G.vex[9].description = “办公室”;
for (i = 0; i<G.vexnum; ++i)
for (j = 0; j<G.vexnum; ++j)
G.arcs[i][j].adj = Max;
G.arcs[0][1].adj = G.arcs[1][0].adj = 2;
G.arcs[0][2].adj = G.arcs[2][0].adj = 1;
G.arcs[0][3].adj = G.arcs[3][0].adj = 7;
G.arcs[1][4].adj = G.arcs[4][1].adj = 8;
G.arcs[2][4].adj = G.arcs[4][2].adj = 8;
G.arcs[3][5].adj = G.arcs[5][3].adj = 5;
G.arcs[5][7].adj = G.arcs[7][5].adj = 2;
G.arcs[4][6].adj = G.arcs[6][4].adj = 3;
G.arcs[4][7].adj = G.arcs[7][4].adj = 2;
G.arcs[6][8].adj = G.arcs[8][6].adj = 2;
G.arcs[7][8].adj = G.arcs[8][7].adj = 1;
G.arcs[8][9].adj = G.arcs[9][8].adj = 1;
}
4. 查询景点信息：

int num;
int i;
char c;
char name[20];
do {
system(“cls”);
c = SearchMenu();
switch © {
case ‘1’:
system(“cls”);
narrate();
printf("\n\n\t\t请输入您要查找的景点编号：");
scanf("%d", &num);
for (i = 0; i<NUM; i++)
{
if (num == G.vex[i].number)
{
printf("\n\n\t\t\t您要查找景点信息如下:");
printf("\n\n\t\t\t%s\n\n", G.vex[i].description);
printf("\n\t\t\t按任意键返回…");
getchar();
getchar();
break;
}
}
if (i == NUM)
{
printf("\n\n\t\t\t没有找到！");
printf("\n\n\t\t\t按任意键返回…");
getchar();
getchar();
}
break;
case ‘2’:
narrate();
system(“cls”);
printf("\n\n\t\t请输入您要查找的景点名称：");
scanf("%s", name);
for (i = 0; i<NUM; i++)
{
if (!strcmp(name, G.vex[i].sight))
{
printf("\n\n\t\t\t您要查找景点信息如下:");
printf("\n\n\t\t\t%s\n\n", G.vex[i].description);
printf("\n\t\t\t按任意键返回…");
getchar();
getchar();
break;
}
}
if (i == NUM)
{
printf("\n\n\t\t\t没有找到！");
printf("\n\n\t\t\t按任意键返回…");
getchar();
getchar();
}
break;
}
} while (c != ‘t’);
}
5. 计算最短路径：

void ShortestPath(int num)
{
int v, w, i, t;
int final[NUM];
int min;
for (v = 0; v<NUM; v++)
{
final[v] = 0;
D[v] = G.arcs[num][v].adj;
for (w = 0; w<NUM; w++)
P[v][w] = 0;
if (D[v]<30000)
{
P[v][num] = 1; P[v][v] = 1;
}
}
D[num] = 0;
final[num] = 1;
for (i = 0; i<NUM; ++i)
{
min = Max;
for (w = 0; w<NUM; ++w)
if (!final[w])
if (D[w]<min)
{
v = w;
min = D[w];
}
final[v] = 1;
for (w = 0; w<NUM; ++w)
if (!final[w] && ((min + G.arcs[v][w].adj)<D[w]))
{
D[w] = min + G.arcs[v][w].adj;
for (t = 0; t<NUM; t++)
P[w][t] = P[v][t];
P[w][w] = 1;
}
}
}

输出函数：
void output(int sight1, int sight2)
{
int a, b, c, d, q = 0;
a = sight2;
if (a != sight1) /*如果景点二不和景点一输入重合，则进行 */
{
printf("\n\t从%s到%s的最短路", G.vex[sight1].sight, G.vex[sight2].sight);/*输出提示信息 */
printf("\t(最短距离为%dm.)\n\n\t", D[a]); printf("\t%s", G.vex[sight1].sight);
d = sight1;/将景点一的编号赋值给d/
for (c = 0; c<NUM; ++c)
{
gate:;
P[a][sight1] = 0;
for (b = 0; b<NUM; b++)
{
if (G.arcs[d][b].adj<30000 && P[a][b]) /*如果景点一和它的一个临界点之间存在路径且最短路径 */
{
printf("–>%s", G.vex[b].sight); /*输出此节点的名称 */
q = q + 1; /*计数变量加一，满8控制输出时的换行 */
P[a][b] = 0;
d = b;/*将b作为出发点进行下一次循环输出，如此反复 */
if (q % 9 == 0) printf("\n");
goto gate;
}
}
}
}
}

4 运行测试
4.1运行结果
4.1.1 2048结果
1.游戏界面：
游戏内容：
退出游戏

4.1.2哈夫曼编码
1.输入叶子节点个数

2.输入叶子节点权值

输出结果

4.1.3 校园导航
1.菜单

查询景点路径：
查询景点信息：

总结

经过对这次系统的设计，让我们对数据结构有了更深的了解，而不只是单单的在课本中学到的那些理论，平时乏味的课程，通过自己动手亲自编写，变的生动有趣，而在自己动手的过程中，出现的问题很多，比理论要难的多，当一个程序写完以后，经常会有很多错误而没法解决。不过，通过几天的编程，逐渐积攒了一些经验，有些错误可以较快看出来。这次实训有很大的收获，让我们对数据结构有了更深的认识，平时在课堂上学到的东西可以自己动手编写，将其转化成一些实用的技能虽然在这过程中我遇到了很多困难，但是有了导师和同学的帮助和指导，我从中学到了很多。这让我学这门课的兴趣大大加增，以后我会更加努力学习加强对这门课的学习力度。

参考文献

[1] 张维明. 信息管理系统[M]. 北京：北京大学出版社.2019.
[2] 伊朝庆. 计算机结构教程[M]. 北京:北京大学出版社，2013，19：3539-3541
[3] 张海潘. 软件工程[J]. 北京：人民邮电出版社， 2013.
[4] 石双元. Web应用开发技术[M]. 北京：清华大学出版社， 2014.
[5] C语言程序设计教程（第二版）作者王敬华林萍张清国数据结构与算法

Stars-Dirial

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
2021-06-23

课程论文数据结构实践（2019-2020学年第二学期）题　　目：2048游戏哈夫曼树校园导航的实现作　　者：迪力亚尔·所在学院：专业年级：　　指导教师：　　职　　称：2020 年 7 月 4 日声明本人郑重声明，课程论文——《哈夫曼树校园导航 2048游戏的实现》系本人在相关教师指导下独立完成，没有抄袭、剽窃他人成果，由此造成的一切后果由本人负责。声明人：迪力亚尔2020年7月2日摘要本次课程设计将明确阐明
复制链接

扫一扫