稀疏矩阵与广义表的操作（用C写的）

最新推荐文章于 2023-01-29 15:29:12 发布
最新推荐文章于 2023-01-29 15:29:12 发布
阅读量747 收藏 1
点赞数
文章标签： c null struct 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shanshan13635827196/article/details/6522954
版权

该程序有两个菜单：主菜单与副菜单。副菜单有分为A菜单和B菜单，A菜单目录是稀疏矩阵的操作，B菜单目录是广义表的操作
运行界面：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
 typedef struct
 {
   int i,j; /*  行下标,列下标 */
   int e; /*  非零元素值 */
 }triple;
 typedef struct tsmatrix
 {
   triple data[MAXSIZE];
   int mu,nu,tu;
 }rlsmatrix;

 

typedef struct lnode
{
 int tag;    /*结点类型标识,0表示原子结点,1表示表或子表结点*/
     union
     { int  data;  
        struct lnode *sublist; /*存储子表的地址*/
     } val;
     struct lnode *link;   /*指向下一个元素*/
} GLNode;//广义表结构定义

 

 


void  createsmatrix(rlsmatrix *M)// 创建稀疏矩阵M */
{
   int e,i,m,n;
  // M->data[0].i=0; /*  为以下比较顺序做准备 */
   printf("请输入矩阵的行数，列数，和非零元素的个数:");
   scanf("%d",&M->mu);
   scanf("%d",&M->nu);
   scanf("%d",&M->tu);
   for(i=0;i<M->tu;i++)
   {
       printf("请按行序顺序输入第%d个非零元素所在的行(0～%d),列(0～%d),元素值：",i,M->mu,M->nu);
       scanf("%d",&m);
    scanf("%d",&n);
    scanf("%d",&e);
       if(m<0||m>M->mu||n<0||n>M->nu) /*行或列超出范围 */
         {printf("行或列超出范围");
    continue;
  
    }
      // if(m<=M->mu||n<=M->nu) /*行或列的顺序有错*/
        // {printf("行或列的顺序有错");
   /// continue;
  //
   // }
     M->data[i].i=m;
     M->data[i].j=n;
     M->data[i].e=e;
   }
 
}

void transposesmatrix(rlsmatrix M,rlsmatrix *T)// 求矩阵的快速转置
 { /* cpos存放每列的第一个非零元素的地址，num数组存放每列中非零元素的个数 */
   int col,num[MAXSIZE],cpot[MAXSIZE];
   int t,p,q;
  
   T->mu=M.nu;
   T->nu=M.mu;
   T->tu=M.tu;
   if(T->tu)
   {
    for(col=0;col<M.nu;col++)
     num[col]=0;
    for(t=0;t<M.tu;t++)
     ++num[M.data[t].j];
    for(t=0;t<M.tu;t++)
     if(M.data[t].j==0)
     {
    cpot[0]=M.data[t].i;
     break;
     }
    for(col=1;col<M.nu;col++)

    cpot[col]=cpot[col-1]+num[col-1];

    for(p=0;p<M.tu;p++)
    {
     col=M.data[p].j;
     q=cpot[col];
     T->data[p].i=M.data[q].j;
     T->data[p].j=M.data[q].i;
     T->data[p].e=M.data[q].e;
     cpot[col]++;
    
    
    }
   }
  
 }
void multsmatrix(rlsmatrix M,rlsmatrix N,rlsmatrix *T)//矩阵相乘
{
      rlsmatrix K;
   int p,t=0;
    T->mu=M.mu;
      T->nu=N.nu;
   T->tu=0;
 if(M.nu!=N.mu)
        {printf("两矩阵无法相乘/n");}
 else {
     transposesmatrix(N,&K);
  for(t=0;t<M.tu;t++)
   for(p=0;p<K.tu;p++)
    if(M.data[t].j==K.data[p].j)
    {
     T->data[T->tu].i=M.data[t].i;
     T->data[T->tu].j=K.data[p].i;
     T->data[T->tu].e=M.data[t].e*K.data[p].e;
     T->tu++;
   }
    for(t=0;t<T->tu;t++)
     if((T->data[t].i==T->data[t+1].i)&&(T->data[t].j==T->data[t+1].j))
     {
      T->data[t].e+=T->data[t+1].e;
     for(p=1;p<T->tu-1;p++)
                     T->data[t+p]=T->data[t+1+p];
     T->tu--;
     }
 }
 }
void Addmatrix(rlsmatrix M,rlsmatrix N,rlsmatrix *W)//两矩阵相加
{
 int p,q;
 W->mu=M.mu;
    W->nu=M.nu;
 W->tu=0;
 if((M.mu!=N.mu)&&(M.nu!=N.nu))
  printf("两矩阵不能相加：/n");
 else {
 
  
 for(p=0,q=0;p<M.tu&&q<N.tu;)
 if((M.data[p].i>M.data[q].i)||((M.data[p].i==M.data[q].i)&&(M.data[p].j>M.data[q].j)))
     {
  W->data[W->tu].i=N.data[q].i;
        W->data[W->tu].j=N.data[q].j;
  W->data[W->tu].e=N.data[q].e;
      W->tu++;
     q++;
  }
   
  else if((M.data[p].i<M.data[q].i)||((M.data[p].i==M.data[q].i)&&(M.data[p].j<M.data[q].j)))
  { 
         W->data[W->tu].i=M.data[p].i;
            W->data[W->tu].j=M.data[p].j;
   W->data[W->tu].e=M.data[p].e;
      W->tu++;
      p++;
  }
  else if((M.data[p].i==M.data[q].i)&&(M.data[p].j==M.data[q].j))
  {
   W->data[W->tu].i=M.data[p].i;
            W->data[W->tu].j=M.data[p].j;
   W->data[W->tu].e=M.data[p].e+N.data[q].e;
      W->tu++;
      p++;
      q++;
  }
  while(p<M.tu)
        {
   W->data[W->tu].i=M.data[p].i;
            W->data[W->tu].j=M.data[p].j;
   W->data[W->tu++].e=M.data[p].e;
      p++;
  }
  while(q<N.tu)
        {
   W->data[W->tu].i=N.data[q].i;
            W->data[W->tu].j=N.data[q].j;
   W->data[W->tu++].e=N.data[q].e;
      q++;
  }
 }
}
void searchmatrix(rlsmatrix *M,int e)//查找元素
{
   int n,t=0;
   for(n=0;n<M->tu;n++)
    if(M->data[n].e==e)
    {
    printf("该元素所在的行，列，值为：/n");
     printf("%2d %2d %2d",M->data[n].i,M->data[n].j,M->data[n].e);
     t=-2;
     //break;
   }
   if(t!=-2)
printf("该元素不存/n");
}

void printmatrix(rlsmatrix *M)//稀疏矩阵输出
 {
     int m,n,k;
     printf("矩阵的简化模式是:/n");
     for(m=0;m<M->tu;m++)
     printf("%d,%d,%d/n",M->data[m].i,M->data[m].j,M->data[m].e);
     printf("矩阵的行数是:%d/n",M->mu);
     printf("矩阵的列数是:%d/n",M->nu);
     printf("矩阵中非零元素个数是:%d/n",M->tu);
     printf("矩阵的完整模式的:/n");
  m=0;
     for(n=0;n<M->mu;n++)
        {
            printf("| ");
            for(k=0;k<M->nu;k++)
            {
    
                if(M->data[m].i==n&&M->data[m].j==k)
                    {printf("%3d ",M->data[m].e);
                     m++;}
                else
                    printf("  0 ");
    
             }
            printf("  |/n");
        }
  
 }
 void destrmartix()
 {
         rlsmatrix M,N,T,K,W,Q;
  int choice,e;
  int Y=1;
         printf("/n/t/t==================================================================");
         printf("/n/t/t=            A 矩阵的基本操作有:                                  ");
         printf("/n/t/t=             1---------矩阵的创建                                ");
         printf("/n/t/t=             2---------矩阵的相乘                                ");
         printf("/n/t/t=             3---------矩阵的相加                                ");
         printf("/n/t/t=             4---------矩阵的转置                                ");
         printf("/n/t/t=             5---------元素的查找                                ");
         printf("/n/t/t==================================================================");
  while(Y)
  {
   printf("请(从菜单A（1--5）中)选择：/n");
   scanf("%d",&choice);
         switch(choice){
         case 1:
                 printf("矩阵的创建：/n");
                       printf("请为矩阵M赋值/n");
                       createsmatrix(&M);
                       printmatrix(&M);
        printf("/n");
                    break;
         case 2:
                 printf("矩阵M与矩阵N相乘:/n");
                       printf("请为矩阵N赋值!/n");
                       createsmatrix(&N);
                       printmatrix(&N);
                       multsmatrix(M,N,&T);
                    if(T.tu!=0)
                   {printf("矩阵M*N得矩阵T!/n");
                                printmatrix(&T);
                   }
        printf("/n");
                 break;
            case 3:
                printf("矩阵M与矩阵Q相加:/n");
                printf("请输入要与矩阵M相加的另一矩阵Q：/n");
                      createsmatrix(&Q);
   //printmatrix(&Q);
                      Addmatrix(M,Q,&W);
            if(W.tu!=0)
             {
             printf("相加后的矩阵Q为：/n");
              printmatrix(&W);
              }
      printf("/n");
            break;
    
          case 4:
                         printf("对矩阵T进行转置!");
                         printf("请为矩阵T赋值!/n");
                         createsmatrix(&T);
                         transposesmatrix(T,&K);
                         printf("转置后的矩阵是/n");
                         printmatrix(&K);
       printf("/n");
                  break;
              case 5:
                         printf("查找元素e/n");
                         scanf("%d",&e);
                         searchmatrix(&M,e);
       printf("/n");
                         break; 
             default:
           break;

  }
  printf("菜单A继续吗?Y(1)/N(0)/n");
  scanf("%d",&Y);
  }
 
 }

 


GLNode *CreatGL()//广义表的创建 
{
          char ch;
   GLNode *h;
     ch=getchar();
  //getchar();
        if (ch!='/0')                        /*串未结束判断*/
  {
   h=(GLNode *)malloc(sizeof(GLNode));/*创建一个新结点*/
         if (ch=='(')                    /*当前字符为左括号时*/
            {
          h->tag=1;                    /*新结点作为表头结点*/
                        h->val.sublist=CreatGL();  /*递归构造子表并链到表头结点*/
                  }
          else if (ch==')')
    
           h=NULL;            /*遇到')'字符,子表为空*/
                 else
           {   h->tag=0;  
                h->val.data=ch;
             }
  }
     else
              h=NULL;                           /*串结束,子表为空*/
   
       ch=getchar();
     //if (h!=NULL)        /*串未结束判断*/

        if (ch==',')             
            h->link=CreatGL();  /*递归构造后续子表*/

        else                                /*串结束*/
            h->link=NULL;  
     return h;               /*返回广义表指针*/
}

 

 

int  depthGList(GLNode *h)//求广义表的深度
{
    int max = 0; /* 遍历每个结点，求出所以子表的最大深度 */
    int dep;
    while(h!= NULL)
 {
        if(h->tag == 1)
       {
            dep = depthGList(h->val.sublist);

        if(dep > max)/* 让max始终为同一个所求子表中深度的最大值 */
            {
                max = dep;
            }
        }
        h = h->link;     /* 让gl指向下一个结点 */
    }
 max++;
    return max;      /* 返回表的深度 */
}

 

int Atomnum(GLNode *h) //求广义表的原子的个数
{   int n=0;
 if  (h==NULL) 
             return 0;   /*为空表时返回0*/
 while (h!=NULL)       /*遍历表中的每一个元素*/
 { if (h->tag==1)     /*元素为子表的情况*/
   n=n+Atomnum(h->val.sublist);   /*递归调用求出子表的原子个数*/
    else
     n=n+1;   
        h=h->link;        /*使g指向下一个元素*/
 }
     return(n);    
}

 

 

GLNode *CopyGList(GLNode *L)//广义表的复制
 {
GLNode *T;
    if (!L)
         T = NULL;  // 复制空表
    else {
       T = (GLNode *)malloc(sizeof(GLNode));
       T->tag = L->tag;
       if (L->tag ==0)
           T->val.data= L->val.data;  // 复制单原子结点
       else
           {
            T->val.sublist=CopyGList(L->val.sublist);                                      
           }
        //L=L->link;
       // T=T->link;
        T->link=CopyGList(L->link);
    }
 return T;
}

 

 

void printGList(GLNode *h)//广义表的遍历
{
  
    if(h->tag == 1)
    {
      
        printf("("); /* 存在子表，先输出左括号 */
       
        if(h->val.sublist == NULL)/* 若子表为空，则输出'#'字符 */
        {
            printf(" ");
        }
       
        else/* 若子表非表，则递归输出子表 */
       {
            printGList(h->val.sublist);
        }
       
        printf(")");/* 当一个子表输出结束后，再输出右括号 */
    }
    /* 对单元素结点，则输出该结点的值 */
    else{
        printf("%c", h->val.data);
    }
   
    if(h->link != NULL)/* 输出该结点的后继表 */
    {
       
        printf(", ");/* 先输出逗号分隔 */
      
        printGList(h->link); /* 再递归输出后继表 */
    }
  
}

 

void destrGLNode()
{
int choice;
int k=1,depth,num;
GLNode *h,*T;
         printf("/n/t/t==================================================================");
         printf("/n/t/t=            B 广义表的基本操作如下:                              ");
         printf("/n/t/t=             1---------广义表的建立                              ");
         printf("/n/t/t=             2---------广义表的复制                              ");
         printf("/n/t/t=             3---------求广义表的深度                            ");
         printf("/n/t/t=             4---------求广义表的原子的个数                      ");
         printf("/n/t/t=             5---------广义表的遍历                              ");
         printf("/n/t/t==================================================================");

while(k)
{
printf("请(从菜单B（1--5）中)选择：/n");
scanf("%d",&choice);
 getchar();
switch(choice)
{
case 1:
     printf("广义表h的建立/n");
     h=CreatGL(); //由括号表示串s建立一个带头结点的广义表*
  printf("(");
     printGList(h);
  printf(")");
  printf("/n");
     break;
case 2:
     printf("广义表的h复制到T中/n");
  T = (GLNode *)malloc(sizeof(GLNode));
  T=NULL;
  T=CopyGList(h);
  printf("(");
     printGList(T);
  printf(")");
  printf("/n");
     break;
case 3:
     printf("求广义表h的深度/n");
     depth=depthGList(h);
     printf("广义表h的深度为：%d",depth);
  printf("/n");
     break;
case 4:
     printf("求广义表的原子的个数 /n");
     num=Atomnum(h);
     printf("广义表的原子的个数：%d",num);
  printf("/n");
     break;
case 5: 
     printf("广义表的遍历 /n");
   printf("(");
     printGList(h);
  printf(")");
  printf("/n");
     break;
default:
     break;
}
 printf("菜单B继续继续吗?Y(1)/N(0)/n");
  scanf("%d",&k);
  getchar();
}
}
void main()
{
char w;
int m=1;
printf("进入稀疏矩阵与广义表的基本操作程序：/n");

while(m)
{   
     printf("请选择主菜单：/nA矩阵的基本操作/nB 广义表的基本操作/n");
     w=getchar();
   if(w=='A')
       destrmartix();
    else if(w=='B')
        destrGLNode();
       else
           printf("谢谢使用/n");
    printf("是否继续在主菜单中选择？Y (1)/N(0)");
    scanf("%d",&m);
    getchar();
}
 printf("谢谢使用/n");
}
  

这个程序是我结合课本与自己的想法写的，程序是能够运行，但是从时间与空间上考虑估计不是最好的。

（如果有好的意见或者有哪些需要修改的地方，请提出来，谢谢。）

shanshan13635827196
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
数组存储结构-矩阵的压缩存储
有朋自远方来，不亦乐乎。
08-14 1963
数据结构中，提供针对某些特殊矩阵的压缩存储结构。本节主要介绍三种特殊矩阵，以及对稀疏矩阵压缩存储的三种具体实现方法：1、三元组顺序表2、行逻辑链接的顺序表3、十字链表。
数据结构—稀疏矩阵和广义表 Ⅹ
Miss Z的博客
08-22 805
数据结构-数组和广义表(第六章)的整理笔记，若有错误，欢迎指正。 特殊矩阵的压缩存储 稀疏矩阵 稀疏矩阵的三元组表示 从一个二维稀疏矩阵创建其三元组表示 三元组元素的赋值 将指定位置的元素值赋给变量 输出三元组 稀疏矩阵转置 稀疏矩阵的十字链表表示 ...
数据结构 稀疏矩阵的实现方法
ccjjjjdff的博客
03-13 2177
稀疏矩阵的实现 什么是稀疏矩阵，怎么定义才是稀疏矩阵?假设在m x n的矩阵中，有t个不为0的元素。令z=t/(m x n),若z<=0.05则称此矩阵为稀疏矩阵。由于稀疏矩阵的非0元素较少，所以如果用大容量存储必定会造成内存浪费，因此只需存储非0元素值即可，以下列出了常用的三种存储稀疏矩阵的方法。 三元组顺序表 三元组顺序表的实现用顺序存储结构来实现。定义一个数组的结构体，存储的是三元组（即由 3 部分数据组成的集合），组中数据分别表示（行标，列标，元素值）。结构体的实现如下： ...
数据结构与算法2稀疏矩阵与广义表
最新发布
ohuojiuwo的博客
01-29 297
8，列下标 j=1,2,…（SWPU-DS）若有 n 阶对称矩阵 A，以行序为主序方式，将其下三角形的元素(包括主对角线上所有元素)依次存放于一维数组B[1..(n(n+1))/2]中，则在 B 中确定 a[i, j]（i
稀疏矩阵与广义表
03-27
orz noip2010 gogo yrmlzzy
数据结构数组稀疏矩阵及广义表、递归实验报告
03-12
1、掌握各种特殊矩阵如对称矩阵、上、下三角矩阵和对角矩阵的压缩...掌握稀疏矩阵的各种存储结构以及基本运算实现算法。 2、掌握广义表的定义、存储结构和运算。 3、掌握递归算法的设计，递归算法到非递归算法的转换
稀疏矩阵和广义表PPT学习教案.pptx
10-05
稀疏矩阵和广义表PPT学习教案.pptx
数据结构实验报告4-数组与广义表-基于十字链表的稀疏矩阵转置-实验内容及要求.docx
07-06
编写程序，从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵的十字链表存储结构。其中，m、n分别表示矩阵行数和列数；i, j为非零元素行号和列号。编写算法，实现矩阵转置，输出转置后的三元组到...
create-matrix:创建矩阵的助手
06-21
创建矩阵 创建矩阵的助手 安装 如果您使用管理项目的依赖项，则向项目的 composer.json 文件添加依赖项： { " require " : { " petrgrishin/create-matrix " : " ~1.0 " } } 使用示例 通过变体创建矩阵 $ variants = [ 'a' => [ 1 , 2 ], 'b' => [ 10 , 20 ], ]; $ matrix = CreateMatrix :: byVariants ( $ variants )-> getArray (); // result $ matrix = Array ( [ 0 ] => Array ( [a] => 1 [b] => 10 )
稀疏矩阵的创建【严蔚敏】
MooMLu的博客
04-25 3100
// c1.h (程序名) #include #include #include // malloc()等 #include // INT_MAX等 #include // EOF(=^Z或F6),NULL #include // atoi() #include // floor(),ceil(),abs() #include //cout,cin usin
稀疏矩阵
03-17 941
#include<cstdio> #include<cstring> #define ElemType int #define Status int //稀疏矩阵的三元组顺序表存储表示 #define MAXSIZE 12500 //非零元的最大个数 #define MAXRC 100 //非零元的最大个数 typedef struct{ ...
稀疏矩阵相乘
某翟的博客
11-14 2971
对于用三元组实现稀疏矩阵相乘的算法，首先构造一个结构体，结构图体中应该有五个量。其中第一个量是表示稀疏矩阵常用的三元组,定义如下：typedef struct{ int i, j; //该非零元素行列下标 ElemType e; }Triple; /*--------稀疏矩阵的三元组顺序表存储表示-------*/下面是结构体的完整定义：typedef struct
矩阵（稀疏矩阵）压缩存储（3种方式）
热门推荐
数据结构和算法教程（C语言版）
03-17 1万+
数据结构中，提供针对某些特殊矩阵的压缩存储结构。 这里所说的特殊矩阵，主要分为以下两类： 含有大量相同数据元素的矩阵，比如对称矩阵； 含有大量 0 元素的矩阵，比如稀疏矩阵、上（下）三角矩阵； 针对以上两类矩阵，数据结构的压缩存储思想是：矩阵中的相同数据元素（包括元素 0）只存储一个。 对称矩阵 ...
5.3矩阵乘积(三元组存储结构)
IT1995的博客
02-10 1万+
5.3矩阵乘积(三元组存储结构)
稀疏矩阵的乘法操作
snakewarhead的专栏
03-17 1万+
<br /> <br />此操作的算法我就不多说了，代码里面叙述得很清楚了。下面就是此程序：<br /> <br /># include <stdio.h> # include <stdlib.h> # define NULL 0 # define OK 1 # define ERROR 0 # define MAXSIZE 100 /* 矩阵中非零元的最大值 */ # define MAXRC 10 /* 矩阵的最大行值 */ typedef int st
矩阵的压缩存储
斜阳雨陌
08-23 1万+
§5.3 矩阵的压缩存储 矩阵是很多科学与工程计算问题中研究的数学对象，在此，我们讨论如何存储矩阵的元，从而使矩阵的各种运算能有效第进行。对于一个矩阵结构显然用一个二维数组来表示是非常恰当的，但在有些情况下，比如常见的一些特殊矩阵，如三角矩阵、对称矩阵、带状矩阵、稀疏矩阵等，从节约存储空间的角度考虑，对这类矩阵进行压缩存储，即：为多个值相同的元素或只分配一个存储单元，对零元素不分配空间。下面从这
数组和广义表
a1351937368的博客
12-10 1084
数组和广义表 文章目录数组和广义表1.广义表 ( (a, b), c, d, e) 的表头和表尾分别是（C）。2.广义表是一种（B）数据结构。3.一个广义表为 ( a, (b, c), d, (), ((f, g), h) )，则该广义表的长度与深度分别为（D）。4.广义表与稀疏矩阵都是线性表的扩展，它们的共同点为（D）。5.广义表L = (a,(a,b),c,d,((i,j),k))的长度和深度为（D）。6.适用于压缩存储稀疏矩阵的两种存储结构是：（B）7.稀疏矩阵在计算机中通常采用（D）来表示。8.稀疏
数据结构与算法 ~ 数组和广义表 ~ 稀疏矩阵的传统转置
cskmyjy的博客
10-29 202
数据结构与算法中数组和广义表的 稀疏矩阵的传统转置 #include<stdlib.h> #include<stdio.h> #define MAXSIZE 100 typedef struct{ int row ,col ;/*该非零元的行下标和列下标*/ int data ; } Triple; typedef struct{ Triple d...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值