稀疏矩阵与广义表

最新推荐文章于 2023-01-29 15:29:12 发布
最新推荐文章于 2023-01-29 15:29:12 发布
阅读量214 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/luowei010101/archive/2011/09/07/2170220.html
版权

稀疏矩阵的运算：

/* 
设矩阵 A 中有 s 个非零元素，若 s 远远小于矩阵元素的总数，则称 A 为稀疏矩阵。 
 
这里以一维数组顺序存放非零元素的行号、列号和数值，行号 -1 作为结束标志。  
*/ 
 
#include<stdio.h> 
#define m    6                //用户可根据需要定义原始矩阵行数  
#define n    8                //定义原始矩阵列数  
#define max 50 
 
/*********************************************/  
/*            转储稀疏矩阵的算法             */ 
/*********************************************/  
void CreateMatrix(int A[m][n],int B[50]) 
{ 
    int i,j,k=0; 
    for(i=0;i<m;i++) 
        for(j=0;j<n;j++) 
            if(A[i][j]!=0) 
            { 
                B[k]=i;k++; 
                B[k]=j;k++; 
                B[k]=A[i][j];k++; 
            } 
    B[k]=-1;    //非零元素存储的结束  
}  
 
/*********************************************/  
/*            转储稀疏矩阵的算法             */ 
/*********************************************/  
void MatrixAdd(int A[max],int B[max],int C[max]) 
{ 
    int i=0,j=0,k=0; 
    while(A[i]!=-1 && B[j]!=-1) 
    { 
        if(A[i]==B[j])                //行相等 
        { 
            if(A[i+1]==B[j+1])        //且列相等  
            { 
                C[k]=A[i]; 
                C[k+1]=A[i+1]; 
                C[k+2]=A[i+2]+B[j+2]; 
                k=k+3; 
                i=i+3; 
                j=j+3;     
            }  
            else if(A[i+1]<B[j+1])    //A的列小于B的列，将 A 的三个元素直接存入 C 中 
            { 
                C[k]=A[i]; 
                C[k+1]=A[i+1]; 
                C[k+2]=A[i+2]; 
                k=k+3; 
                i=i+3;  
            }  
            else                    //B的列小于A的列，将B的三个元素直接存入C中  
            { 
                C[k]=B[j]; 
                C[k+1]=B[j+1]; 
                C[k+2]=B[j+2]; 
                k=k+3; 
                j=j+3;     
            } 
        }  
        else if(A[i]<B[j])            //A的行小于B的行，将A的三个元素直接存入C中 
        { 
            C[k]=A[i]; 
            C[k+1]=A[i+1]; 
            C[k+2]=A[i+2]; 
            k=k+3; 
            i=i+3;  
        }  
        else                        //B的行小于A的行，将B的三个元素直接存入C中  
        { 
            C[k]=B[j]; 
            C[k+1]=B[j+1]; 
            C[k+2]=B[j+2]; 
            k=k+3; 
            j=j+3; 
        } 
    }                                //循环结束  
    if(A[i]==-1) 
        while(B[j]!=-1)                //A结束B还有元素，将B的所有元素直接存入C中  
        { 
            C[k]=B[j]; 
            C[k+1]=B[j+1]; 
            C[k+2]=B[j+2]; 
            k=k+3; 
            j=j+3;     
        }  
    else 
        while(A[i]!=-1)                //B结束，A还有元素，将A的所有元素直接存入C中  
        { 
            C[k]=A[i]; 
            C[k+1]=A[i+1]; 
            C[k+2]=A[i+2]; 
            k=k+3; 
            i=i+3;     
        } 
    C[k]=-1; 
}  
 
/*********************************************/  
/*                   主函数                  */ 
/*********************************************/  
void main() 
{ 
    int E[m][n],F[m][n],A[max],B[max],C[max]; 
    int i,j,k; 
    printf("输入E矩阵：\n"); 
    for(i=0;i<m;i++)                //输入E矩阵所有元素值 
        for(j=0;j<n;j++) 
            scanf("%d",&E[i][j]); 
    printf("输入F矩阵：\n"); 
    for(i=0;i<m;i++)                //输入F矩阵所有元素值 
        for(j=0;j<n;j++) 
            scanf("%d",&F[i][j]); 
    CreateMatrix(E,A);                //E矩阵的非零元素存储到一维数组A中 
    CreateMatrix(F,B);                //F矩阵的非零元素存储到一维数组B中  
    MatrixAdd(A,B,C);                //A,B相加存入C 
    i=0; 
    j=0; 
    k=0; 
    printf("A数组内容如下:\n"); 
    while(A[i]!=-1)                    //输出A中内容  
    { 
        printf("%5d,%5d,%5d\n",A[i],A[i+1],A[i+2]); 
        i=i+3;     
    }  
    printf("B数组内容如下;\n"); 
    while(B[j]!=-1) 
    { 
        printf("%5d,%5d,%5d\n",B[j],B[j+1],B[j+2]); 
        j=j+3; 
    } 
    printf("C数组内容如下;\n"); 
    while(C[k]!=-1) 
    { 
        printf("%5d,%5d,%5d\n",C[k],C[k+1],C[k+2]); 
        k=k+3; 
    } 
}  
 
/* 
测试输入： 
E矩阵： 
0 0 3 0 0 0 0 0 
0 0 0 0 0 0 5 0 
0 0 0 0 0 0 0 0 
0 0 0 0 7 0 0 0 
0 0 0 0 0 0 0 0 
0 9 0 0 0 0 0 0 
F矩阵： 
0 2 0 0 0 0 0 0 
0 0 0 4 0 0 0 0 
0 0 0 0 0 6 0 0 
0 0 0 0 8 0 0 0 
0 0 1 0 0 0 0 0 
0 0 0 0 0 0 0 0 
*/ 
 
 
 

 

广义表运算：

#include<stdio.h> 
#include<stdlib.h> 
 
/*************************/  
/*    广义表的存储结构   */ 
/*************************/ 
typedef char DataType; 
enum{fasle,true}; 
typedef enum{atom,list}NodeTag;        //atom=0,表示原子;list=1,表示子表 
typedef struct GLnode 
{ 
    NodeTag tag;            //用以区分原子结点和表结点 
    union 
    { 
        DataType data;        //用以存放原子结点值，其类型由用户自定义 
        struct GLnode * slink;        //指向子表的指针  
    }; 
    struct GLnode * link;            //指向下一个表结点  
}GLNode,*Glist;            //广义表结点及广义表类型  
 
 
/*************************/  
/*    建立广义表函数     */ 
/*************************/ 
//注：C语言中&(如&a)是取变量a的地址;而C++中&(&a)是变量a的引用(即表示变量a的地址),仅仅只是一个标识而已。 
void CreatGList(Glist GL) 
{ 
    char ch; 
    scanf("%c",&ch); 
    if(ch!=10)                    //如果广义表未结束(10是回车的ASCII码) 
    { 
         
        if(ch=='(') 
        { 
            GL->tag=list; 
            GL->slink=(GLNode *)malloc(sizeof(GLNode)); 
            CreatGList(GL->slink);    //递归调用构造子表  
        } 
        else if (ch == ')')   
            GL = NULL; 
        else 
        { 
            //GL=(GLNode *)malloc(sizeof(GLNode)); 
            //构造原子结点 
            GL->tag=atom; 
            GL->data=ch;  
        }  
    }                            //结束 
    else 
        GL=NULL; 
    scanf("%c",&ch); 
    if(GL!=NULL) 
        if(ch!=10) 
        { 
            if(ch==',') 
            { 
                GL->link=(GLNode *)malloc(sizeof(GLNode)); 
                CreatGList(GL->link);    //递归构造后续广义表 
            } 
            else 
                GL->link=NULL;            //表示遇到 ')'或结束符 ';'时无后续表  
        } 
        else 
            GL->link=NULL; 
} 
 
/*************************************/  
/*           输出广义表函数          */ 
/*************************************/ 
void PrintGList(Glist GL) 
{ 
    if(GL!=NULL) 
    { 
        if(GL->tag==list) 
        { 
            printf("("); 
            if(GL->slink==NULL) 
                printf(" "); 
            else PrintGList(GL->slink);    //递归调用输出子表  
        } 
        else 
            printf("%c",GL->data);        //输出结点数据域值 
        if(GL->tag==list) 
            printf(")"); 
        if(GL->link!=NULL) 
        { 
            printf(","); 
            PrintGList(GL->link);        //递归调用输出下一个结点  
        } 
    } 
}  
 
/*************************************/  
/*           广义表查找函数          */ 
/*************************************/ 
Glist FindGlistX(Glist GL,DataType x,int *mark)  
{    //调用广义表GL所指向的广义表，mark=false,x为查找的元素， 
    //若查找成功，mark=true,p为指向数据域为x的结点  
    if(GL!=NULL) 
    { 
        if(GL->tag==0 && GL->data==x) 
        { 
            *mark=true;  
            return GL;                          
        } 
        else 
            if(GL->tag==1) 
                FindGlistX(GL->slink,x,mark); 
        FindGlistX(GL->link,x,mark); 
    }  
    return NULL; 
}  
 
/*************************************/  
/*          求广义表表头函数         */ 
/*************************************/ 
Glist head(Glist GL) 
{ 
    Glist p; 
    if(GL!=NULL && GL->tag!=0)            //不为空并且不是原子  
    { 
        p=GL->slink; 
        p->link=NULL; 
        return p;                        //返回GL中指向子表的指针     
    } 
    else 
        return NULL;  
}  
 
/*************************************/  
/*          求广义表表尾函数         */ 
/*************************************/ 
Glist tail(Glist GL) 
{ 
    Glist p; 
    if(GL!=NULL && GL->tag!=0)            //表不为空表并且有表尾  
    { 
        p=GL->slink; 
        p=p->link;                        //p指向第二个元素 
        GL->slink=p;                    //删除广义表第一个元素     
    } 
    return p;  
}  
 
/*************************************/  
/*           求广义表深度            */ 
/*************************************/ 
void depth(Glist GL,int *maxdh) 
{ 
    int h; 
    if(GL->tag==0) 
        maxdh=0;                        //说明广义表为单个元素 
    else 
        if(GL->tag==1 && GL->slink==NULL) 
            *maxdh=1;                    //广义表为空表 
        else                            //进行递归求解  
        { 
            GL=GL->slink;                //进入第一层 
            *maxdh=0; 
            do                //循环扫描表的第一层的每个结点，对每个结点求其子表深度  
            { 
                depth(GL,&h); 
                if(h>*maxdh) 
                    *maxdh=h;            //取最大的子表深度 
                GL=GL->link;     
            }while(GL!=NULL); 
            *maxdh=*maxdh+1;                //子表最大深度加1  
        }  
}  
 
/*************************************/  
/*     求广义表的长度(即元素的个数     */ 
/*************************************/ 
//注：GL->slink=NULL 和没有指定空间是不同的。 
int GListLength(Glist GL) 
{ 
    if (GL != NULL) 
        return 1+GListLength(GL->link); 
    else 
        return 0; 
} 
 
/*************************************/  
/*              复制广义表            */ 
/*************************************/ 
void CopyGList(Glist NList,Glist GList) 
{//复制广义表要 
 //将广义表的标记、原子、子表和下一结点复制 
    if (!GList)//原广义表为空 
        NList = NULL; 
    else 
    { 
        NList->tag = GList->tag; 
        if (GList->tag == 0) 
            NList->data = GList->data;//复制广义表的原子结点 
        else if (GList->tag == 1) 
        { 
            if (!(NList->slink = (GLNode *)malloc(sizeof(GLNode)))) 
                printf("存储空间分配失败\n"); 
            CopyGList(NList->slink,GList->slink);//复制广义表的子表 
        } 
            if (!(NList->link = (GLNode *)malloc(sizeof(GLNode)))) 
                    printf("存储空间分配失败\n"); 
            CopyGList(NList->link,GList->link);//复制广义表的下一结点 
        } 
} 
 
/*************************************/  
/*    主函数:广义表基本运算的实现    */ 
/*************************************/ 
int main()                             
{ 
    int xz=1,mark; 
    char x; 
    Glist GL=(GLNode *)malloc(sizeof(GLNode)); 
    Glist GL1,NList;  
    //void CreatGList(Glist GL),PrintGList(Glist GL),depth(Glist GL,int *maxdh); 
    //Glist FindGlistX(Glist GL,DataType x,int *mark),head(Glist GL),tail(Glist GL); 
    while(xz) 
    { 
        printf("*===============================*\n"); 
        printf("*          广义表的运算         *\n"); 
        printf("*===============================*\n"); 
        printf("**********1.建立广义表***********\n"); 
        printf("**********2.广义表查找***********\n"); 
        printf("**********3.求广义表头***********\n"); 
        printf("**********4.求广义表尾***********\n"); 
        printf("**********5.求广义表深度*********\n"); 
        printf("**********6.求广义表长度*********\n"); 
        printf("**********7.输出复制广义表********\n"); 
        printf("**********0.退出表的运算*********\n"); 
        printf("*===============================*\n"); 
        printf("            请 选 择：0-5        \n"); 
        scanf("%d",&xz); 
        getchar(); 
        switch(xz) 
        { 
            case 1: 
                printf("输入广义表："); 
                CreatGList(GL); 
                printf("输出广义表："); 
                PrintGList(GL); 
                printf("\n"); 
                break; 
            case 2: 
                printf("输入要查找的数据值(单个字符): "); 
                scanf("%c",&x); 
                mark=fasle; 
                FindGlistX(GL,x,&mark); 
                if(mark) 
                     printf("要查找的数据存在表中！\n"); 
                 else 
                     printf("要查找的数据不在表中！\n"); 
                 break; 
             case 3: 
                 printf("输入要求表头的广义表："); 
                 CreatGList(GL); 
                 GL1=head(GL); 
                 printf("广义表的表头是："); 
                 PrintGList(GL1); 
                printf("\n"); 
                break; 
            case 4: 
                printf("输入要求表尾的广义表："); 
                CreatGList(GL); 
                GL1=tail(GL); 
                 printf("广义表的表尾是："); 
                 printf("("); 
                 PrintGList(GL1); 
                printf(")"); 
                printf("\n"); 
                GL=NULL; 
                break; 
            case 5: 
                printf("输入要求深度的广义表："); 
                CreatGList(GL); 
                mark=0; 
                depth(GL,&mark); 
                printf("广义表的深度是：%5d\n",mark); 
                break; 
            case 6: 
                printf("输入要求长度的广义表："); 
                CreatGList(GL); 
                mark=0; 
                printf("广义表的长度是：%5d\n",GListLength(GL->slink)); 
                break; 
            case 7: 
                if (!(NList = (GLNode *)malloc(sizeof(GLNode)))) 
                    printf("存储空间分配失败\n"); 
                CopyGList(NList,GL); 
                printf("输出复制广义表:"); 
                PrintGList(NList); 
                break; 
            default: 
                printf("再见！\n"); 
                return 0;   
        }  
    }  
} 
 
  

转载于:https://www.cnblogs.com/luowei010101/archive/2011/09/07/2170220.html

数组和广义表，稀疏矩阵
m0_37976933的博客
04-01 419
考点：广义表的长度和深度，稀疏矩阵的相关操作 广义表：LA=（A1,A2,…,An）,LA为表名，n为表长，其中Ai可以是单个元素，亦可以是广义表，分别称为 原子和子表。A1为表头，（A2,…An）为表尾 1：广义表表长：原子的个数（此时要把最大子表广义归结为原子） 2：广义表深度：括弧的重数，空表深度为1 3：已知广义表A=((a,b,c),(d,e,f))，从表中取e的运算： 分解：tail(...
数据结构—稀疏矩阵和广义表 Ⅹ
Miss Z的博客
08-22 912
数据结构-数组和广义表(第六章)的整理笔记，若有错误，欢迎指正。 特殊矩阵的压缩存储 稀疏矩阵 稀疏矩阵的三元组表示 从一个二维稀疏矩阵创建其三元组表示 三元组元素的赋值 将指定位置的元素值赋给变量 输出三元组 稀疏矩阵转置 稀疏矩阵的十字链表表示 ...
稀疏矩阵构成的广义表
汉南最後の読書人
06-02 880
题目要求： 假设n n的稀疏矩阵A采用三元组表示，设计一个程序exp6-4.cpp实现如下功能：  （1）生成如下两个稀疏矩阵的三元组a和b；  （2）输出a转置矩阵的三元组；  （3）输出a+b的三元组；  （4）输出a b的三元组。 输入代码： #include #include #include using namespace std; #define M 4//稀
稀疏矩阵与广义表的操作（用C写的）
陆珊(网络管理)
05-05 770
该程序有两个菜单：主菜单与副菜单。副菜单有分为A菜单和B菜单，A菜单目录是稀疏矩阵的操作，B菜单目录是广义表的操作运行界面：#include#include#define MAXSIZE 100  typedef struct  {   int i,j; /*  行下标,列下标 */   int e; /*  非零元素值 */ }triple; type
计算机应用专业：稀疏矩阵与广义表概述与填空
在计算机应用专业的数据结构课程中，"数据结构定义.pdf"文件主要探讨了稀疏矩阵和广义表这两种重要的数据结构概念。以下是关于这两个主题的详细知识点： **一、稀疏矩阵** 1. **稀疏矩阵的存储结构** - 在稀疏矩阵...
稀疏矩阵与广义表的存储和运算
本文介绍了矩阵乘法的概念，并重点讲解了稀疏矩阵和广义表的相关知识，包括稀疏矩阵的定义、存储方法和运算。 在矩阵乘法中，两个矩阵A[ M，N]和B[N，T]可以相乘得到矩阵C[M，T]，前提是A的列数N与B的行数N相同。...
稀疏矩阵与广义表的快速转置算法
“本文介绍了稀疏矩阵和广义表的相关算法，包括稀疏矩阵的定义、存储方式和运算，以及广义表的快速转置算法。” 在计算机科学中，稀疏矩阵是一个重要的数据结构，尤其在处理大量数据时，当矩阵中的非零元素远小于零...
数据结构解析：稀疏矩阵与广义表的应用
本资源主要涉及数据结构中的稀疏矩阵和广义表概念，同时给出了相关的数据结构实例解析，以及一个二次多项式的抽象数据类型设计。 在数据结构中，稀疏矩阵是指那些大部分元素为零的矩阵。由于大量的零元素，通常会...
数据结构与算法2稀疏矩阵与广义表
最新发布
ohuojiuwo的博客
01-29 385
8，列下标 j=1,2,…（SWPU-DS）若有 n 阶对称矩阵 A，以行序为主序方式，将其下三角形的元素(包括主对角线上所有元素)依次存放于一维数组B[1..(n(n+1))/2]中，则在 B 中确定 a[i, j]（i
数据结构数组稀疏矩阵及广义表、递归实验报告
12-14
1、掌握各种特殊矩阵如对称矩阵、上、下三角矩阵和对角矩阵的压缩存储方法。掌握稀疏矩阵的各种存储结构以及基本运算实现算法。 2、掌握广义表的定义、存储结构和运算。 3、掌握递归算法的设计，递归算法到非递归算法的转换
稀疏矩阵
weixin_30378311的博客
08-16 194
稀疏矩阵处理方法： （1） 数据平滑技术，如设定缺省值，将为评分项设为平均分或众数，回归填补法，随机填补法；聚类平滑技术，将未评分项使用聚类中心的数据经行填充。 （2） 降维技术，主成分分析（ PCA）和奇异值分解（SVD） （3）对已有相似度计算模型进行局部加权处理。如基于时间的加权，基于共现次数的线性加权，类似于Jaccard系数的加权方法。 转载于:https://w...
数据结构与算法 ~ 数组和广义表 ~ 稀疏矩阵的传统转置
cskmyjy的博客
10-29 222
数据结构与算法中数组和广义表的 稀疏矩阵的传统转置 #include<stdlib.h> #include<stdio.h> #define MAXSIZE 100 typedef struct{ int row ,col ;/*该非零元的行下标和列下标*/ int data ; } Triple; typedef struct{ Triple d...
数据结构-稀疏矩阵
fate_heaven的博客
12-06 824
#include <map> #include <set> #include <queue> #include <stack> #include <vector> #include <cstdio> #include <cstdlib> #include <cstring> #include <iostream> #include <algorithm>using namespace std;con
稀疏矩阵的运算——矩阵相加
热门推荐
qq_45767547的博客
04-13 1万+
南昌航空大学实验报告 课程名称： 数据结构A 实验名称： 实验五 稀疏矩阵运算 班 级： XXX 学生姓名： XXX 学号： XXXXX 指导教师评定： XXX 签 名: XXX 一、实验目的 数组是一种常用的数据类型，本实验是有关两个稀疏矩阵进行相加的应用。 通过对本实验的学习，可以理解矩阵的相关操作方法。 二、实验内容 在本...
数据结构基础系列(5)：数组与广义表
10-07
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第5部分串，介绍数组的基本概念，特殊矩阵的压缩存储及基本运算的实现，以及广义表及其存储和相关的算法。
稀疏矩阵和广义表 C语言实现
WTF
11-29 4596
1、稀疏矩阵概念 稀疏矩阵是矩阵中的一种特殊情况，其非零元素个数远小于零元素个数。 如下图为一个稀疏矩阵 2、稀疏矩阵的存储结构 稀疏矩阵的存储结构分为顺序存储和链接存储，链接存储又分为带行指针向量的链接存储与十字链接存储。 a.顺序存储 稀疏矩阵顺序存储结构示意图： 其定义如下：（注意：为方便，下面的下标都从1使用） struct Triple /
4.（数据结构）广义表和多重链表和稀疏矩阵
weixin_45386223的博客
10-14 490
1.广义表：线性表的一种推广。 对于线性表而言，n个元素都是基本的单元素；广义表中，这些元素还可以是另一个广义表。 二元多项式可以等价变形后写成 ax^n1+bx^n2+cx^n3的形式，其中的系数不是常数，是一元多项式 因此它可以用复杂的链表表示：把原来表示常数的位置变成指针 。 广义表一般形式如下： typedef struct GNode *GList; struct GNode{ int...
5.1数组的定义与顺序存储
WithoutEndFree的博客
06-06 2549
5.1数组的定义与顺序存储——讲义 1、数组的定义和运算 数组是我们十分熟悉的结构,高级语言一般都支持数组这种数据类型。 ( 1 )数组的定义 从逻辑结构上,数组可以看成是一般线性表的扩充。 一维数组即为线性表, 而二维数组可以定义为“其数据元素为一维数组(线性表)”的线性表。依此类推, 即可得到多维数组的定义。 以二维数组为例,如下图所示。 可以把二维数组看成是一个线性表: A =(α1 ,α2 ,…,αn),其中αj( 1 ≤ j ≤ n)本身也是一个线性表,称为列向量,即αj=（a1j，a2j，…
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值