数据机构--矩阵问题实现程序代码

 

#include

#include

#include

#include

#include

#include

#include

using namespace std;

enum returninfo{correct,error,none,success,fail};//定义返回信息清单

 

 

class Matrix

{

private:

         int *data;

         int length;

public:

         Matrix(const int *Ndata=NULL,int Nlength=0);

         returninfo Mcreate();                                                     //创建稀疏矩阵

         returninfo Mchange();                                                    //转换成三元组

         returninfo Mdisplay();                                                     //显示矩阵

         returninfo Tdisplay();                                                       //显示转换后的三元组

         returninfo decompression();                                         //三元组还原稀疏矩阵

         returninfo trans();                                                            //转置三元组

         returninfo detrans();                                                       //转置矩阵

         returninfo verify();                                                  //验证三元组是否转换正确

         returninfo originsave();                                         //保存原始数据

         returninfo altersave();                                                    //保存转换后的数据

 

         vector        matrix;                                 //建立动态稀疏矩阵

         vector        triple;                                   //建立动态三元组

         vector        detri;                                    //建立还原后的动态稀疏矩阵

         vector        trantri;                        //建立转置后的动态三元组

         vector        detrantri;                            //建立转置后的动态稀疏矩阵

};

 

Matrix::Matrix(const int *Ndata,int Nlength)

{

         length=Nlength;

         data=new int[Nlength];

         for(int i=0;i

                   data[i]=Ndata[i];

}

 

//创建矩阵

returninfo Matrix::Mcreate()

{

         int i,j,row,col,Tdata;

         int temp[30];

 

         srand((int)(time(NULL)));

         row=rand()+10;

         col=rand()+10;

         matrix.clear();

         for(i=0;i

         {

                   for(j=0;j

                   {

                            Tdata=rand()0;

                            if(rand()%5<=3)

                                     Tdata=0;

                            temp[j]=Tdata;

                   }

                   matrix.push_back(Matrix(temp,col));

         }

         return success;

}

 

//转换三元组

returninfo Matrix::Mchange()

{

         if(matrix.size()==0)

                   return none;

 

         int temp[3]={matrix.size(),matrix[0].length,0};

         int n=0;

         triple.clear();

         triple.push_back(Matrix(temp,3));

         for(int i=0;i

                   for(int j=0;j

                            if(matrix[i].data[j]>0)

                            {

                                     n++;

                                     temp[0]=i;

                                     temp[1]=j;

                                     temp[2]=matrix[i].data[j];

                                     triple.push_back(Matrix(temp,3));

                            }

         triple[0].data[2]=n;

         return success;

}

 

//显示稀疏矩阵

returninfo Matrix::Mdisplay()

{

         if(matrix.size()==0)

                   return none;

         else

         {

                   cout<<"行为 "<<matrix.size()<<" 列为 "<<matrix[0].length<<" 的稀疏矩阵是: "<<endl;

                   for(int i=0;i

                   {

                            for(int j=0;j

                                     cout<<setw(5)<<matrix[i].data[j];

 

                            cout<<endl;

                   }

                   return success;

         }

}

 

//显示三元组

returninfo Matrix::Tdisplay()

{

         if(triple.size()==0)

                   return none;

         else

         {

                   cout<<" 列为"<<triple.size()<<"的三元组是:"<<endl;

                   for(int i=0;i

                   {

                            for(int j=0;j<3;j++)

                                     cout<<setw(5)<<triple[i].data[j];

                            cout<<endl;

                   }

                   return success;

         }

}

 

//解压三元组

returninfo Matrix::decompression()

{

         int i,j,temp[30];

         int row,col;

 

         if(triple.size()==0)

                   return none;

         else

         {

                   detri.clear();

                   for(i=0;i

                   {

                            for(j=0;j

                                     temp[j]=0;

                            detri.push_back(Matrix(temp,triple[0].data[1]));

                   }

                   for(i=1;i

                   {

                            row=triple[i].data[0];

                            col=triple[i].data[1];

                            detri[row].data[col]=triple[i].data[2];

                   }

 

                   cout<<"解压后矩阵为:"<<endl;

                   for(i=0;i

                   {

                            for(j=0;j

                                     cout<<setw(5)<<detri[i].data[j];

                            cout<<endl;

                   }

 

                   return success;

         }

}

 

//判断转换时候无误

returninfo Matrix::verify()

{

         if(matrix.size()==0||triple.size()==0)

                   return none;

         else

         {

                   int returnvalue,temp1,temp2;

                   returnvalue=decompression();

                   if((detri.size()!=matrix.size())||(detri[0].length!=matrix[0].length)||(returnvalue==error))

                            return error;

                   else

                   {

                            returnvalue=Mdisplay();

                            for(int i=0;i

                                     for(int j=0;j

                                     {

                                               temp1=matrix[i].data[j];

                                               temp2=detri[i].data[j];

                                               if(temp1!=temp2)

                                                        return error;

                                     }

                            return correct;

                   }

         }

}

 

//转置三元组

returninfo Matrix::trans()

{

         if(triple.size()==0)

                   return none;

 

         int i=0,j=0;

         int temp[3]={triple[0].data[1],triple[0].data[0],triple[0].data[2]};

         int trans[800][2];

         int temp1[1][2];

 

         trantri.clear();

         trantri.push_back(Matrix(temp,3));

         while(i

         {

                   trans[i][0]=i+1;

                   trans[i][1]=triple[i+1].data[1];

                   i++;

         }

         for(i=0;i

         {

                   for(j=i+1;j

                            if(trans[i][1]>trans[j][1])

                            {

                                     temp1[0][0]=trans[j][0];

                                     temp1[0][1]=trans[j][1];

                                     trans[j][0]=trans[i][0];

                                     trans[j][1]=trans[i][1];

                                     trans[i][0]=temp1[0][0];

                                     trans[i][1]=temp1[0][1];

                            }

         }

         for(i=0;i

         {

                   j=trans[i][0];

                   temp[0]=triple[j].data[1];

                   temp[1]=triple[j].data[0];

                   temp[2]=triple[j].data[2];

                   trantri.push_back(Matrix(temp,3));

         }

 

         cout<<"列为"<<trantri.size()<<"的转置三元组是:";

         cout<<setw(10)<<"列为"<<triple.size()<<"的原三元组是:"<<endl;

         for(i=0;i

         {

                   for(int j=0;j<3;j++)

                            cout<<setw(5)<<trantri[i].data[j];

                   cout<<"                  ";

                   for(j=0;j<3;j++)

                            cout<<setw(5)<<triple[i].data[j];      

                  cout<<endl;

         }

         return success;

}

 

//转置矩阵

returninfo Matrix::detrans()

{

         int i,j,temp[30];

         int row,col;

 

         if(trantri.size()==0)

                   return none;

         else

         {

                   detrantri.clear();

                   for(i=0;i

                   {

                            for(j=0;j

                                     temp[j]=0;

                            detrantri.push_back(Matrix(temp,trantri[0].data[1]));

                   }

                   for(i=1;i

                   {

                            row=trantri[i].data[0];

                            col=trantri[i].data[1];

                            detrantri[row].data[col]=trantri[i].data[2];

                   }

 

                   cout<<"转置矩阵为:"<<endl;

                   for(i=0;i

                   {

                            for(j=0;j

                                     cout<<setw(5)<<detrantri[i].data[j];

                            cout<<endl;

                   }

 

                   return success;

         }

}

 

//保存原始数据

returninfo Matrix::originsave()

{

                   ofstream out("原始数据.txt");

                   int i,j;

 

                   if(!out)

                            return fail;

                  out<<"行为 "<<matrix.size()<<" 列为 "<<matrix[0].length<<" 的稀疏矩阵是: "<<endl;

                   for(i=0;i

                   {

                            for(j=0;j

                                     out<<setw(5)<<matrix[i].data[j];

                            out<<endl;

                   }

                   out<<endl;

                   out<<" 列为"<<triple.size()<<"的三元组是:"<<endl;

                   for(i=0;i

                   {

                            for(j=0;j<3;j++)

                                     out<<setw(5)<<triple[i].data[j];

                            out<<endl;

                   }

 

                   out<<endl;

                   out.close();

                   return success;

}

 

//保存转换转置后的数据

returninfo Matrix::altersave()

{

         ofstream out("转换后数据.txt");

         int i,j;

        

         if(!out)

                   return fail;

         out<<"三元组解压后的行为"<<detri.size()<<" 列为 "<<detri[0].length<<" 的稀疏矩阵是: "<<endl;

         for(i=0;i

         {

                   for(j=0;j

                            out<<setw(5)<<detri[i].data[j];

                   out<<endl;

         }

         out<<endl;

 

         out<<"转置后的列为"<<trantri.size()<<"的三元组是:"<<endl;

         for(i=0;i

         {

                   for(int j=0;j<3;j++)

                            out<<setw(5)<<trantri[i].data[j];

                   out<<endl;

         }

         out<<endl;

 

         out<<"转置后的行为"<<detrantri.size()<<"列为"<<detrantri[0].length<<"的稀疏矩阵是:"<<endl;

         for(i=0;i

         {

                   for(j=0;j

                            out<<setw(5)<<detrantri[i].data[j];

                   out<<endl;

         }

         out.close();

 

         return success;

}

 

 

class interfacebase

{

private:

         Matrix data;

public:

         void clearscreen(void);

         void showmenu(void);

         int userchoice(void);

         void processmenu(char menuchoice);

};

 

void interfacebase::clearscreen(void)

{

    system("cls");

}

 

void interfacebase::showmenu(void)

{

       cout<<"****稀疏矩阵基本功能菜单*****"<<endl;

    cout<<"====程序作者:BY  霍柱安====="<<endl;

    cout<<"1.创建新稀疏矩阵"<<endl;

         cout<<"2.显示稀疏矩阵"<<endl;

    cout<<"3.转换三元组"<<endl;

         cout<<"4.显示三元组"<<endl;

    cout<<"5.解压三元组"<<endl;

    cout<<"6.验证转化三元组是否正确"<<endl;

    cout<<"7.转置三元组"<<endl;

         cout<<"8.显示转置后的稀疏矩阵"<<endl;

         cout<<"9.保存原始数据"<<endl;

         cout<<"a.保存转换后的数据"<<endl;

    cout<<"q.结束程序"<<endl;

         cout<<"============================="<<endl;

}

 

int interfacebase::userchoice(void)

{        char menuchoice;

         cout<<"请输入您的选择:";  

         cin>>menuchoice;

         return menuchoice;

}

 

void interfacebase::processmenu(char menuchoice)

{

         int returnvalue;

         switch(menuchoice)    //根据用户的选择进行相应的操作

         {

         case '1':            

                   returnvalue=data.Mcreate();

                   if(returnvalue!=success)

                            cout<<"创建稀疏矩阵失败!"<<endl;

                   else

                            returnvalue=data.Mdisplay();

                   break;

         case '2':

                   returnvalue=data.Mdisplay();

                   if(returnvalue==none)

                            cout<<"不存在稀疏矩阵,请先建立稀疏矩阵!";

                   break;

         case '3':

                   returnvalue=data.Mchange();

                   if(returnvalue==none)

                            cout<<"不存在稀疏矩阵,请先建立稀疏矩阵!"<<endl;

                   else

                            returnvalue=data.Tdisplay();

                   break;

 

         case '4':

                   returnvalue=data.Tdisplay();

                   if(returnvalue==none)

                            cout<<"不存在三元组!请先创建三元组!"<<endl;

                   break;

         case '5':

                   returnvalue=data.decompression();

                   if(returnvalue==none)

                            cout<<"不存在三元组,请先建立三元组!"<<endl;

                   break;

         case '6':

                   returnvalue=data.verify();

                   if(returnvalue==correct)

                            cout<<"矩阵转换无误!"<<endl;

                   else if(returnvalue==error)

                            cout<<"矩阵转换出错!"<<endl;

                   else

                            cout<<"不存在三元组!请先创建三元组"<<endl;

                   break;

         case '7':

                   returnvalue=data.trans();

                   if(returnvalue==none)

                            cout<<"不存在三元组!请先创建三元组!"<<endl;

                   break;

         case '8':

                   returnvalue=data.detrans();

                   if(returnvalue==none)

                            cout<<"不存在转置三元组!请先转置三元组!"<<endl;

                   break;

         case '9':

                   returnvalue=data.originsave();

                   if(returnvalue==fail)

                            cout<<"数据保存失败!"<<endl;

                   else

                            cout<<"原始数据保存成功!请查看'原始数据.txt'文件!"<<endl;

                   break;

         case '0':

                   returnvalue=data.altersave();

                   if(returnvalue==fail)

                            cout<<"数据保存失败!"<<endl;

                   else

                            cout<<"变化后的数据保存成功!请查看'转换后数据.txt'文件!"<<endl;

                   break;

         case 'q':

         case 'Q':

                   cout<<"感谢你的使用,再见!"<<endl;

                   exit(0);

 

         default:

                   cout<<"对不起,您输入的功能编号有错!请重新输入!!!"<<endl;

                   break;

         }

         cout<<"请按任意键继续..."<<endl;

}

 

 

void main(void)                     //程序主入口

{  

         int menuchoice;                

         interfacebase interfacenow;

         interfacenow.clearscreen();

    while (1)

         {

                interfacenow.showmenu();

                   menuchoice=interfacenow.userchoice();

                   interfacenow.processmenu(menuchoice);

                   getch();

                   Sleep(200);                     //延迟了一会

                   interfacenow.clearscreen();

    }

}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值