基于C++实现的猴子选大王-各种排序-纸牌游戏

Brokenner

发布日期: 2018-11-06 10:00:56 浏览量: 1240
评分:
star star star star star star star star_border star_border star_border
*转载请注明来自write-bug.com

1 课程设计任务和具体技术参数

1.1 项目一

1.1.1 任务

一堆猴子都有编号,编号是1,2,3…m, 这群猴子(m个)按照1-m的顺序围坐一圈,从第1开始数,每数到第N个,该猴子就要离开此圈,这样依次下来,直到圈中只剩下最后一只猴子,则该猴子为大王。

1.1.2 要求

  • 输入数据:输入m, nm, n为整数, n<m

  • 输出形式:中文提示按照m个猴子,数n个数的方法,输出为大王的猴子是几号,建立一个函数来实现此功能

1.2 项目二

1.2.1 任务

用程序实现插入法排序、选择法排序、起泡法改进算法排序;利用插入排序、选择法排序和冒泡法的改进算法,将用户随机输入的一列数按递增的顺序排好。

1.2.2 要求

  • 输入的数据形式为任何一个正整数,大小不限

  • 输出的形式:数字大小逐个递增的数列

1.3 项目三

1.3.1 任务

编号为1-52张牌,正面向上,从第2张开始,以2为基数,是2的倍数的牌翻一次,直到最后一张牌;然后,从第3张开始,以3为基数,是3的倍数的牌翻一次,直到最后一张牌;然后…从第4张开始,以4为基数,是4的倍数的牌翻一次,直到最后一张牌;…再依次5的倍数的牌翻一次,6的,7的直到以52为基数的翻过,输出:这时正面向上的牌有哪些?要求有翻牌过程说明。

2 项目一

2.1 对设计任务内容的概述

接收用户输入的猴子数来形成一个圈,再接收用户输入的淘汰间隔来不断淘汰对应位置的猴子,最后剩下的即为王。

2.2 需求分析或功能描述

用m来接收用户输入的猴子数,用n来接收用户输入的淘汰间隔,然后生成一个m个节点的循环单链表,通过头结点的移动n次找到淘汰对象进行淘汰,并输出淘汰情况,最后当尾节点指向自己时,表示未最后一个猴子,即输出此猴子为王。

2.3 概要设计或程序流程图

接收用户输入m、n,创建m长度的单向循环链表,以n为间隔不断淘汰。判断最后剩下的为王。以下为流程图:

2.4 详细设计或源代码说明

Monkey.cpp文件

  1. #include "Monkey.hpp"
  2. Monkey::Monkey(){
  3. int m = 0,n = 0; //用来接收用户输入
  4. while(m <= n && n > 1){ //m不大于n将无线循环
  5. cout << "#请输入m,n(m必须大于n): ";
  6. cin >> m >> n;
  7. }
  8. /*
  9. * 创建长度为m的单项循环链表
  10. */
  11. LinkNode *L; //头结点
  12. creatList(L,m);
  13. /*
  14. * 循环删除第n个结点
  15. */
  16. while(L -> next != L){
  17. listDeleteN(L,n);
  18. }
  19. cout << "@@@大王就是,第" << L -> data <<"号猴子@@@" <<endl;
  20. }
  21. void Monkey::creatList(LinkNode *&L,int m){
  22. int *a = new int[m];
  23. for(int i = 1;i <= m;i++){ //给数组里顺序赋值
  24. a[i - 1] = i;
  25. }
  26. LinkNode *s,*r;
  27. L = (LinkNode *)malloc(sizeof(LinkNode));
  28. r = L;
  29. for(int i = 0;i < m;i++){
  30. s = (LinkNode *)malloc(sizeof(LinkNode));
  31. s -> data = a[i];
  32. r -> next = s;
  33. r = s;
  34. }
  35. r -> next = L -> next; //把最后的指针指向头指针的下一个变为循环链表
  36. //让L不参与删除
  37. }
  38. void Monkey::destroyList(LinkNode *&L){
  39. LinkNode * pre = L,*p = L -> next;
  40. while(p != NULL){
  41. free(pre);
  42. pre = p;
  43. p = pre ->next;
  44. }
  45. free(pre);
  46. }
  47. void Monkey::listDeleteN(LinkNode *&L,int n){
  48. LinkNode *s,*p;
  49. for(int i = 0;i < n-1;i++){ //循环n次让头结点指向要删除的上一个
  50. L = L -> next;
  51. }
  52. s = L -> next;
  53. Sleep(1);
  54. cout << "#" << s -> data << "号猴子已被淘汰" << endl;
  55. p = s;
  56. s = s -> next;
  57. L -> next = s;
  58. free(p);
  59. }

2.5 程序模块及其接口描述

  1. Monkey(); // 构造函数
  2. void creatList(LinkNode *&L,int m); // 创建循环链表
  3. void destroyList(LinkNode *&L); // 摧毁链表
  4. void listDeleteN(LinkNode *&L,int n); // 传入变量n,删除第n个元素

2.6 程序的输入与输出描述

  • 输入:两个数

  • 输出:淘汰情况和最终结果

2.7 调试分析或程序测试

2.8 尚未解决的问题或改进方向

可以把界面改进更好看点。

2.9 对软件的使用说明

进入猴子选王界面后,需输入m与n用空格隔开,且m一定需要大于n,否则会要求重新输入。

3 项目二

3.1 对设计任务内容的概述

对数组进行各种各样的排序。

3.2 需求分析或功能描述

需要用户输入数组的长度和数组内容,然后给用户选择排序方法,并可以看到排序的整个过程,并可以返回重新选择,则排序的数组并不能是原数组,需要每次用户选择时创建一个新的数组用来排序。

3.3 概要设计或程序流程图

3.4 详细设计或源代码说明

Sorts.cpp文件

  1. #include "Sorts.hpp"
  2. Sorts::Sorts(int t){
  3. n = t;
  4. }
  5. //插入排序
  6. //直接插入排序
  7. void Sorts::insertSort(int r[]){
  8. int tmp,j;
  9. for (int i = 0; i < n; i++) {
  10. if(r[i] < r[i-1]){
  11. tmp = r[i];
  12. for (j = i - 1;j >= 0 && r[j] > tmp; j--) {
  13. r[j+1] = r[j];
  14. }
  15. r[j+1] = tmp;
  16. }
  17. showArray(r);
  18. }
  19. system("pause");
  20. }
  21. //折半插入排序
  22. void Sorts::binInsertSort(int r[]){
  23. int i,j,low,high,mid,tmp;
  24. for (i = 1; i < n; i++) {
  25. if(r[i] < r[i-1]){
  26. tmp = r[i];
  27. low = 0;
  28. high = i-1;
  29. while(low <= high){
  30. mid = (low + high) / 2;
  31. if(tmp < r[mid]){
  32. high = mid - 1;
  33. }else{
  34. low = mid + 1;
  35. }
  36. }
  37. for (j = i-1; j >= high+1;j--) {
  38. r[j+1] = r[j];
  39. }
  40. r[high+1] = tmp;
  41. }
  42. showArray(r);
  43. }
  44. system("pause");
  45. }
  46. //选择排序
  47. void Sorts::selectSort(int r[]){
  48. int k;
  49. for (int i = 0; i < n-1; i++) {
  50. k = i;
  51. for (int j = i+1; j < n; j++) {
  52. if(r[j] < r[k]){
  53. k = j;
  54. }
  55. }
  56. if(k != i){
  57. swap(r[i], r[k]);
  58. }
  59. showArray(r);
  60. }
  61. system("pause");
  62. }
  63. //改进冒泡排序
  64. void Sorts::bubbleSort(int r[]){
  65. bool exchange;
  66. for (int i = 0; i < n-1; i++) {
  67. exchange = false;
  68. for (int j = n-1; j > i; j--) {
  69. if(r[j] < r[j-1]){
  70. swap(r[j], r[j-1]);
  71. exchange = true;
  72. }
  73. }
  74. if(!exchange){
  75. return;
  76. }
  77. showArray(r);
  78. }
  79. system("pause");
  80. }
  81. //打印整个数组
  82. void Sorts::showArray(int r[]){
  83. for (int i = 0; i < n; i++) {
  84. cout << r[i] << "\t";
  85. }
  86. cout << endl;
  87. Sleep(1000);
  88. }

3.5 程序模块及其接口描述

  1. //插入排序
  2. Sorts(int n);
  3. //直接插入排序
  4. void insertSort(int r[]);
  5. //折半插入排序
  6. void binInsertSort(int r[]);
  7. //选择排序
  8. void selectSort(int r[]);
  9. //冒泡改进排序
  10. void bubbleSort(int r[]);
  11. //打印整个数组
  12. void showArray(int r[]);

3.6 程序的输入与输出描述

3.6.1 输入

3.6.2 输出

直接插入排序

折半插入排序

选择排序

冒泡排序

4 项目三

4.1 对设计任务内容的概述

纸牌1-54号,基数从1到54,当号数能整除基数则翻面。

4.2 需求分析或功能描述

需要定义一个数组存储54个1表示正面,然后循环基数,当号数能整除基数即取反,1变为0,0变为1。

4.3 概要设计或程序流程图

用到双重循环,第一个循环遍历数组,从0到53,第二层循环从号数到最后一个,循环里面判断 号数%基数是否为0,为0则需让其值取反。

4.4 详细设计或源代码说明

  1. #include "Card.hpp"
  2. Card::Card(){
  3. for (int i = 0; i < 54; i++) { //全部初始化为正面(1为正面,0为反面)
  4. card[i] = 1;
  5. }
  6. for (int i = 2; i < 54; i++) {
  7. for (int j = i; j < 54; j++) {
  8. if (j % i == 0) {
  9. card[j] = !card[j];
  10. }
  11. }
  12. system("cls");
  13. showCard(); //每改变一次清空界面,显示新的结果
  14. cout << "#现在的基数为:" << i ;
  15. Sleep(1000);
  16. }
  17. }
  18. void Card::showCard(){ //用来输出整个数组
  19. for (int i = 1; i <= 54; i++) {
  20. cout << card[i-1] << "\t";
  21. if (i % 7 == 0) {
  22. cout << endl;
  23. }
  24. }
  25. cout << endl;
  26. }

4.5 程序模块及其接口描述

  1. // 构造函数,所有执行都在里面表示,创造对象即可执行,无需调用其他函数
  2. Card();
  3. // 用来遍历显示整个数组
  4. void showCard();

4.6 程序的输入与输出描述

4.6.1 输入

无需输入。

4.6.2 输出

4.7 尚未解决的问题或改进方向

界面只用0和1表示正反面,可以用更好看的来表示。

4.8 对软件的使用说明

进入界面即可,界面不断变化表示翻转的变化。

5 总结

这次课程设计选择的三个题目分别为猴子选大王、各种排序、纸牌游戏分别用到了循环单向链表、多种排序算法和数组的灵活运用。多方面的对数据结构的概念运用起来,让在学习数据结构课程过程中留下的“学这些用来干什么?”疑问得到了解答,同时加强了自己C++的编程能力。同时在完成课程设计过程中也遇到了各种各样的问题,比如实现猴子选大王时,淘汰猴子时多了一个猴子,经过设断点发现带着头指针一起淘汰了,就多了一个淘汰名额,最后通过把头指针分离出循环链表来改正了这个错误。还有在排序过程中,太多排序方法有点混淆,最后通过翻书确认最后完成了这个模块。最后通过不断改进,不断调试完成了界面整合,也对一些防止用户错误输入进行了判断,整体变得更加一体性。

参考文献

[1]《数据结构实验教程(C/C++语言版)(第二版)》,张仕等,厦门大学出版社,2018

[2]《数据结构(C语言版)》,董树锋,科学出版社,2018

[3]《数据结构(C语言版)》,严蔚敏 吴伟民,清华大学出版社,1997

[4]《Data Structures Using C数据结构(C语言版)》,R Krishnamoorthy、G Indirani Kumaravel,清华大学出版社,2009

[5]《C++数据结构与程序设计 (美)Robert L.Kruse/Alexander J.Ryba著/钱丽萍译》,
清华大学出版社,2004

[6]《计算机算法设计与分析(第2版)》,王晓东, 电子工业出版社, 2004

上传的附件 cloud_download 猴子选大王-各种排序-纸牌游戏.7z ( 181.10kb, 7次下载 )
error_outline 下载需要6点积分

keyboard_arrow_left上一篇 : 基于C++实现的迷你数据库 基于Python实现的简单生命游戏 : 下一篇keyboard_arrow_right



Brokenner
2018-11-06 10:02:18
使用C++实现的猴子选大王、各种排序和纸牌游戏,其中,排序包括:直接插入排序、折半插入排序、选择排序、冒泡排序

发送私信

时间能冲淡一切,但却冲不掉一切

9
文章数
6
评论数
最近文章
eject