欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 2749|回復: 1
打印 上一主題 下一主題
收起左側

C++面向對象程序設計實驗報告 帶兩種定義矩陣方法源程序

[復制鏈接]
跳轉到指定樓層
樓主

完整的報告下載（word格式）：
第2次實驗.zip (2.48 MB, 下載次數: 4)



下面是部分內容預覽：
----------------------------------------------------------------------------
C++面向對象程序設計實驗報告

實驗報告

學生姓名：吳琪學    號：19215115專業班級：計科151

一．實驗目的
（1）熟練Visual Studio 6.0和2008兩種開發環境，包括基本操作命令、相應菜單項和快捷鍵；掌握C++程序的基本結構及相應編輯、編譯、調試和運行的方法；
（2）復習數組、單鏈表等數據結構的編程實現；
（3）掌握利用數組、單鏈表實現n×n矩陣的存儲、數乘、轉置和旋轉反射等
二．實驗內容
實驗1：矩陣的數乘
（1）程序功能簡介
根據矩陣處理的數據知識，編程實現矩陣的數乘程序。
（2）程序設計要求
① 實現n×n矩陣的數乘，其中n為用戶輸入的任意整數；
② 先采用數組來表示矩陣，再采用單鏈表來表示矩陣，分別實現兩種數據結構下的矩陣數乘，并比較兩種數據結構的程序實現難易程度；
③生成相應可執行程序，并提交實驗報告和可執行程序。
實驗2：矩陣的旋轉反射和轉置
（1）程序功能簡介
根據矩陣處理的數據知識，編程實現矩陣旋轉反射和轉置程序。
（2）程序設計要求
① 實現n×n矩陣的旋轉反射和轉置，其中n為用戶輸入的任意整數；
② 先采用數組來表示矩陣，再采用單鏈表來表示矩陣，分別實現兩種數據結構下的矩陣旋轉反射和轉置程序，并比較兩種數據結構的程序實現難易程度；
③生成相應可執行程序，并提交實驗報告和可執行程序。

三．實驗環境
PC微機
DOS操作系統或 Windows 操作系統
Visual c++程序集成環境
四．實驗內容和步驟
實驗1：矩陣的數乘
程序設計說明
① 矩陣數乘的數據原理相對簡單，主要是解決矩陣的表示，可以采用數組和單鏈表兩種方式；
② 先采用數組來表示矩陣，實現相應矩陣數乘程序；
③ 再采用單鏈表來表示矩陣，相應矩陣的數乘操作變得簡單。
實驗2：矩陣的旋轉反射和轉置
程序設計說明
① 矩陣旋轉反射和轉置的數據原理相對簡單，主要是解決矩陣的表示，可以采用數組和單鏈表兩種方式；
② 先采用數組來表示矩陣，實現相應旋轉反射和轉置程序；
③ 再采用單鏈表來表示矩陣，相應矩陣的旋轉反射和轉置操作變得簡單，只要按一定的算法改變鏈表中節點的次序即可。
五．實驗數據及處理結果
【實驗1】
【設計思路】
輸入矩陣n*n的大小n，數乘的大小，按行列順序輸入矩陣的賦值，輸出矩陣的初始狀態以及數乘的結果。
【數據輸入】輸入矩陣n*n的大小n，數乘的大小，按行列順序輸入矩陣的賦值。
【數據輸出】輸出矩陣的初始狀態以及數乘的結果。



【結果及截圖】
答：運行程序，（對于數組）輸入矩陣大小4，按行列順序輸入矩陣賦值：9 6 3 8 5 2 7 4 1 7 8 9 4 5 6 0，輸入旋轉角度90，選擇x反射，矩陣初始布局以及特殊變換后的布局如下：
（對于鏈表）輸入矩陣大小4，按行列順序輸入矩陣賦值：6 4 2 8 4 3 6 7 1 2 3 6 4 1 7 5，輸入旋轉角度270，選擇y反射，矩陣初始布局以及特殊變換后的布局如下：



六、實驗總結及體會

       通過本次實驗，熟練了Visual Studio 6.0和2008兩種開發環境，包括基本操作命令、相應菜單項和快捷鍵，并掌握C++程序的基本結構及相應編輯、編譯、調試和運行的方法。此外，復習數組、單鏈表等數據結構的編程實現，掌握利用數組、單鏈表實現n×n矩陣的存儲、數乘、轉置和旋轉反射等操作的方法，對數據存儲和算法復雜度有了更深刻的理解。




【源程序實現】
【shucheng.h】
  1. //鏈表操作

  3. typedef struct LNode{

  5.               int num;

  7.               LNode *next;

  9. }*LinkList,LNode;

  11. void initList(int n,LinkList &list);

  13. void meanList(int n,LinkList &list);

  15. void valueList(int k,int n,LinkList &list);

  17. void printList(int n,LinkList &list);



  21. //數組操作

  23. void initma(int n,int **&matrix);

  25. void meanma(int n,int **matrix);

  27. void valuema(int k,int n,int **matrix);

  29. void printma(int n,int **matrix);

  31. 【shucheng.cpp】

  33. #include"shucheng.h"

  35. #include"iostream"

  37. using namespace std;



  41. void initma(int n,int **&matrix){

  43.               matrix=new int*[n];

  45.               int i;

  47.               for(i=0;i<n;i++){

  49.                             matrix[i]=new int[n];

  51.               }

  53. }



  57. void meanma(int n,int **matrix){

  59.               int i,j;

  61.               cout<<"please input 數組矩陣 in order:";

  63.               for(i=0;i<n;i++){

  65.                             for(j=0;j<n;j++){

  67.                                           cin>>matrix[i][j];

  69.                             }

  71.               }

  73. }



  77. void valuema(int k,int n,int **matrix){

  79.               int i,j;

  81.               for(i=0;i<n;i++){

  83.                             for(j=0;j<n;j++){

  85.                                           matrix[i][j]*=k;

  87.                             }

  89.               }

  91. }



  95. void printma(int n,int **matrix){

  97.               int i,j;

  99.               for(i=0;i<n;i++){

  101.                             for(j=0;j<n;j++){

  103.                                           cout<<matrix[i][j]<<" ";

  105.                             }

  107.                             cout<<endl;

  109.               }            

  111. }



  115. void initList(int n,LinkList &list){

  117.               int i;

  119.               list=new LNode;

  121.               list->num=1;

  123.               list->next=NULL;



  127.               LinkList p;

  129.               for(i=0;i<n*n;i++){

  131.                             p=new LNode;

  133.                             p->num=1;//初值定為1

  135.                             p->next=list->next;

  137.                             list->next=p;

  139.               }

  141. }



  145. void meanList(int n,LinkList &list){

  147.               LinkList p=list->next;

  149.               cout<<"please input 鏈表矩陣 in order:";

  151.               int i;

  153.               for(i=0;i<n*n;i++){

  155.                             cin>>p->num;

  157.                             p=p->next;

  159.               }

  161. }



  165. void valueList(int k,int n,LinkList &list){

  167.               LinkList p=list->next;

  169.               int i;

  171.               for(i=0;i<n*n;i++){

  173.                             p->num*=k;

  175.                             p=p->next;

  177.               }

  179. }



  183. void printList(int n,LinkList &list){

  185.               LinkList p=list->next;

  187.               int i;

  189.               for(i=0;i<n*n;i++){

  191.                             cout<num<<" ";

  193.                             p=p->next;

  195.                             if((i+1)%n==0)

  197.                                           cout<<endl;

  199.               }

  201. }
復制代碼


【test.cpp】
  1. #include"shucheng.h"

  3. #include"iostream"

  5. using namespace std;



  9. void main(){

  11.               int n;

  13.               cout<<"please input the size of matrix:";

  15.               cin>>n;

  17.               int k;

  19.               cout<<"please input the 數乘的值：";

  21.               cin>>k;

  23.               int **matrix;

  25.               initma(n,matrix);//建立數組

  27.               meanma(n,matrix);//賦值

  29.               printma(n,matrix);

  31.               valuema(k,n,matrix);//求數乘

  33.               cout<<"the result of 數乘"<<endl;

  35.               printma(n,matrix);



  39.               LinkList list;

  41.               initList(n,list);

  43.               meanList(n,list);

  45.               printList(n,list);

  47.               valueList(k,n,list);

  49.               cout<<"the result of 數乘"<<endl;

  51.               printList(n,list);



  55. }
復制代碼


【結果及截圖】
答：運行程序，輸入矩陣大小4，輸入數乘的值2，（數組）按行列順序輸入矩陣賦值：5 3 1 4 8 9 6 4 2 8 6 3 0 1 4 5,輸出矩陣初始賦值以及數乘后的結果如下：
（鏈表）按行列順序輸入矩陣賦值：5 3 1 4 8 9 6 4 2 8 6 3 0 1 4 5,輸出矩陣初始賦值以及數乘后的結果如下：
【比較數組與鏈表】
在對于矩陣賦值、對矩陣進行數乘以及輸出矩陣時，以數組形式存儲的矩陣需要通過兩層循環實現操作，而以鏈表來表示矩陣只需一層循環，相較之下，以鏈表表示矩陣，進行相關操作的效率更高。
【實驗2】
【設計思路】
分別通過數組和鏈表實現矩陣的變換：
輸入矩陣n*n的大小n，以及按行列順序輸入矩陣的賦值，回車輸出矩陣轉置的結果，根據提示輸入旋轉矩陣的角度x（90的倍數），回車輸出矩陣順時針旋轉x度的結果，根據提示反射的方式（x或y），輸入x或y后回車，輸出矩陣反射的結果。
【數據輸入】 輸入矩陣的大小，矩陣的賦值，旋轉的角度，反射的方式。
【數據輸出】 矩陣的初始狀態，矩陣轉置、旋轉、反射的結果。







【源程序實現】
【second.h】
  1. //鏈表操作

  3. typedef struct LNode{

  5.               int num;

  7.               LNode *next;

  9. }*LinkList,LNode;

  11. void initList(int n,LinkList &list);

  13. void meanList(int n,LinkList &list);

  15. void printList(int n,LinkList &list);

  17. void zhuanzhiList(int n,LinkList &list);

  19. void xuanzhuanList(int n,LinkList &list);

  21. void fansheList(int n,LinkList &list);



  25. //數組操作

  27. void initma(int n,int **&matrix);

  29. void meanma(int n,int **matrix);

  31. void printma(int n,int **matrix);



  35. void zhuanzhi(int n,int **matrix);



  39. void xuanzhuan(int n,int **matrix);



  43. void fanshe(int n,int **matrix);
復制代碼

//其他
【second.cpp】
內容詳見附件

【test.cpp】

  1. #include"second.h"

  3. #include"iostream"

  5. using namespace std;



  9. void main(){

  11.               int n;

  13.               cout<<"please input the size of matrix:";

  15.               cin>>n;

  17.             

  19.               //數組

  21.               int **matrix;

  23.               initma(n,matrix);//建立數組

  25.               meanma(n,matrix);//賦值

  27.               cout<<"please input 數組矩陣 in order:";



  31.               cout<<"the original state:"<<endl;

  33.               printma(n,matrix);

  35.               zhuanzhi(n,matrix);//轉置



  39.               xuanzhuan(n,matrix);//旋轉



  43.               fanshe(n,matrix);//反射





  49.               //鏈表

  51.               LinkList list;

  53.               cout<<"please input the size of matrix:";

  55.               cin>>n;

  57.               initList(n,list);

  59.               meanList(n,list);

  61.               LinkList p=list->next;

  63.               cout<<"please input 鏈表矩陣 in order:";

  65. /*              int i;

  67.               int rt=0;

  69.               for(i=0;i<16;i++){

  71.                             p->num=rt;

  73.                             rt++;

  75.                             p=p->next;

  77.               }*/



  81.               cout<<"the original state:"<<endl;

  83.               printList(n,list);

  85.               zhuanzhiList(n,list);

  87.               xuanzhuanList(n,list);

  89.               fansheList(n,list);

  91. }
復制代碼
  1. #include"second.h"
  2. #include"iostream"
  3. using namespace std;

  5. //其他

  7. //數組操作
  8. void initma(int n,int **&matrix){
  9.         matrix=new int*[n];
  10.         int i;
  11.         for(i=0;i<n;i++){
  12.                 matrix[i]=new int[n];
  13.         }
  14. }

  16. void meanma(int n,int **matrix){
  17.         int i,j;
  18.         cout<<"please input 數組矩陣 in order:";
  19.         for(i=0;i<n;i++){
  20.                 for(j=0;j<n;j++){
  21.                         cin>>matrix[i][j];
  22.                 }
  23.         }
  24. }

  26. void printma(int n,int **matrix){
  27.         int i,j;
  28.         for(i=0;i<n;i++){
  29.                 for(j=0;j<n;j++){
  30.                         cout<<matrix[i][j]<<" ";
  31.                 }
  32.                 cout<<endl;
  33.         }       
  34. }

  36. void zhuanzhi(int n,int **matrix){
  37.         int i,j;
  38.         int t;
  39.         for(i=0;i<n;i++){
  40.                 for(j=i;j<n;j++){
  41.                         t=matrix[i][j];
  42.                         matrix[i][j]=matrix[j][i];
  43.                         matrix[j][i]=t;
  44.                 }
  45.         }
  46.         cout<<"the 轉置 state:"<<endl;
  47.         printma(n,matrix);
  48. }

  50. void xuanzhuan(int n,int **matrix){
  51.         cout<<"please input 旋轉度數(90 180 270 360...):";
  52.         int c;
  53.         cin>>c;

  55.         int num=(c/90)%4;
  56.         int x;
  57.         int i,j;
  58.         int t;

  60.         for(x=0;x<num;x++){
  61.                 for(i=0;i<n/2;i++){
  62.                         for(j=i;j<n-i-1;j++){
  63.                                 t=matrix[i][j];
  64.                                 matrix[i][j]=matrix[n-1-j][i];
  65.                                 matrix[n-1-j][i]=matrix[n-i-1][n-j-1];
  66.                                 matrix[n-i-1][n-j-1]=matrix[j][n-i-1];
  67.                                 matrix[j][n-i-1]=t;
  68.                         }
  69.                 }
  70.         }

  72.         cout<<"the 順時針旋轉 state:"<<endl;
  73.         printma(n,matrix);
  74. }
  75. void fanshe(int n,int **matrix){
  76.         char c;
  77.         cout<<"please choose x或y 反射:";
  78.         cin>>c;
  79.         int sign;
  80.         switch(c){
  81.         case 'x':sign=1;break;
  82.         case 'y':sign=0;break;
  83.         }
  84.         int i,j;
  85.         int t;
  86.         if(sign==1){
  87.                 for(j=0;j<n;j++){
  88.                         for(i=0;i<n/2;i++){
  89.                                 t=matrix[i][j];
  90.                                 matrix[i][j]=matrix[n-i-1][j];
  91.                                 matrix[n-1-i][j]=t;
  92.                         }
  93.                 }
  94.         }
  95.         else{
  96.                 for(i=0;i<n;i++){
  97.                         for(j=0;j<n/2;j++){
  98.                                 t=matrix[i][j];
  99.                                 matrix[i][j]=matrix[i][n-1-j];
  100.                                 matrix[i][n-1-j]=t;
  101.                         }
  102.                 }       

  104.         }

  106.         cout<<"the 反射 state:"<<endl;
  107.         printma(n,matrix);
  108. }

  110. //鏈表操作
  111. void initList(int n,LinkList &list){
  112.         int i;
  113.         list=new LNode;
  114.         list->num=1;
  115.         list->next=NULL;

  117.         LinkList p;
  118.         for(i=0;i<n*n;i++){
  119.                 p=new LNode;
  120.                 p->num=1;//初值定為1
  121.                 p->next=list->next;
  122.                 list->next=p;
  123.         }
  124. }

  126. void meanList(int n,LinkList &list){
  127.         LinkList p=list->next;
  128.         cout<<"please input 鏈表矩陣 in order:";
  129.         int i;
  130.         for(i=0;i<n*n;i++){
  131.                 cin>>p->num;
  132.                 p=p->next;
  133.         }
  134. }

  136. void printList(int n,LinkList &list){
  137.         LinkList p=list->next;
  138.         int i;
  139.         for(i=0;i<n*n;i++){
  140.                 cout<<p->num<<" ";
  141.                 p=p->next;
  142.                 if((i+1)%n==0)
  143.                         cout<<endl;
  144.         }
  145. }

  147. //小函數
  148. void inList(LinkList &e,LinkList &qian){//插入到qian之后
  149.         e->next=qian->next;
  150.         qian->next=e;
  151. }
  152. void outList(LinkList &e,LinkList &qian){//刪除qian后的結點
  153.         e=qian->next;
  154.         qian->next=qian->next->next;
  155.         e->next=NULL;
  156. }

  158. void zhuanzhiList(int n,LinkList &list){
  159.         LinkList po=list->next,p=list->next;
  160.         int k,i,j;
  161.         LinkList e;
  162.         for(k=0;k<n-1;k++){

  164.         for(i=0;i<n-1;i++){
  165.                 for(j=1;j<n-k;j++){
  166.                         p=p->next;
  167.                 }
  168.                 outList(e,p);
  169.                 inList(e,po);
  170.                 po=po->next;
  171.         }
  172.         po=po->next;
  173.         p=po;
  174.         }
  175.         cout<<"the 轉置 state:"<<endl;
  176.         printList(n,list);
  177. }

  179. void xuanzhuanList(int n,LinkList &list){
  180.         cout<<"please input 旋轉度數(90 180 270 360...):";
  181.         int c;
  182.         cin>>c;

  184.         int num=(c/90)%4;
  185.         int x,i,j,k;
  186.         LinkList e;
  187.         LinkList p;
  188.         LinkList t;
  189.         for(x=0;x<num;x++){
  190.                 p=list;
  191.                 t=list->next;
  192.                 for(i=0;i<n;i++){
  193.                         t=p->next;
  194.                         for(k=0;k<n-1;k++){
  195.                         for(j=0;j<n-i-1;j++){
  196.                                 t=t->next;
  197.                         }
  198.                         outList(e,t);
  199.                         inList(e,p);
  200.                         }
  201.                         for(j=0;j<n;j++){
  202.                                 p=p->next;
  203.                         }
  204.                 }
  205.         }//x

  207.         cout<<"the 旋轉 state:"<<endl;
  208.         printList(n,list);
  209. }

  211. void fansheList(int n,LinkList &list){
  212.         char ch;
  213.         cout<<"please choose x或y 反射:";
  214.         cin>>ch;
  215.         int sign;
  216.         switch(ch){
  217.         case 'x':sign=1;break;
  218.         case 'y':sign=0;break;
  219.         }
  220.         int i,j,k;
  221.         LinkList a,b,c,d;
  222.         LinkList p,t,e;
  223.         if(sign==1){//x反射 上下
  224.                 a=list;
  225.                 b=list;
  226.                 for(i=0;i<n;i++){
  227.                         b=b->next;
  228.                 }
  229.                 for(i=0;i<n-1;i++){
  230.                         c=b->next;
  231.                         d=b;
  232.                         for(j=0;j<n;j++){
  233.                                 d=d->next;       
  234.                         }
  235.                         b->next=d->next;
  236.                         d->next=a->next;
  237.                         a->next=c;
  238.                 }
  239.         }
  240.         else{//y反射  左右
  241.                 p=list;
  242.                 for(i=0;i<n;i++){
  243.                         t=p->next;
  244.                         for(j=0;j<n-1;j++){
  245.                                 outList(e,t);
  246.                                 inList(e,p);
  247.                         }
  248.                         for(k=0;k<n;k++){
  249.                                 p=p->next;
  250.                         }
  251.                 }

  253.         }

  255.         cout<<"the 反射 state:"<<endl;
  256.         printList(n,list);
  257. }



復制代碼


評分

參與人數 1黑幣 +100 收起 理由
admin + 100 共享資料的黑幣獎勵！

查看全部評分

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏 分享淘帖 頂頂 踩踩
回復

使用道具 舉報

沙發
ID:1 發表于 2017-3-17 16:45 | 只看該作者
好資料，51黑有你更精彩
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表