精华内容
下载资源
问答
  • 一、存储矩阵用一个二维数组即可; 二、什么是对称矩阵: 设一个N*N的方阵A,A中...对称矩阵和压缩存储的对应关系:下三角存储i>=j, SymmetricMatrix[i][j] ==Array[i*(i+1)/2+j] 四、代码实现 #include<iostre
  • 对称矩阵 n阶矩阵中任意一个元素aij都有aij=aji,则为对称矩阵存储主对角线+下三角区(按行优先存储在一维数组中) 数组大小:(1+n)*n/2 三角矩阵 三对角矩阵 稀疏矩阵 三元表(行,列,值) 十字链表...

    对称矩阵

    n阶矩阵中任意一个元素aij都有aij=aji,则为对称矩阵

    只存储主对角线+下三角区按行优先存储在一维数组中)

    数组大小(1+n)*n/2

    在这里插入图片描述

    三角矩阵

    在这里插入图片描述

    三对角矩阵

    在这里插入图片描述


    在这里插入图片描述

    稀疏矩阵

    1. 三元表(行,列,值)

    2. 十字链表

      在这里插入图片描述

    展开全文
  • // 对称矩阵的输入 void Symmetric_input(int **A, int n, int B[]) { int i, j, k = 0; // 将对称元素及对称轴的元素存入数组B for (i = 0; i < n; i++) for (j = 0; j < i + 1; j++)
    #include <math.h>
    #include <stdio.h>
    #define M 3
    #define N 3
    
    // 对称矩阵的输入
    void Symmetric_input(int **A, int n, int B[])
    {
        int i, j, k = 0;
    
        // 将对称元素及对称轴上的元素存入数组B
        for (i = 0; i < n; i++)
            for (j = 0; j < i + 1; j++)
                B[k++] = *(*(A + i) + j);
    }
    
    // 对称矩阵的输出
    void Symmetric_output(int B[], int length)
    {
        int i, j, k = 0;
        int n = (sqrt(1 + 8 * length) - 1) / 2; //计算矩阵的阶数
        int A[n][n];
    
        // 恢复对称矩阵A
        for (i = 0; i < n; i++)
            for (j = 0; j < i + 1; j++)
                A[i][j] = A[j][i] = B[k++];
    
        // 输出对称矩阵
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
                printf("%d ", A[i][j]);
    
            printf("\n");
        }
    }
    
    // 下三角矩阵的输入
    void Lower_triangular_input(int **A, int n, int B[])
    {
        int i, j, k = 1;
    
        B[0] = *((*A) + (n - 1)); //存储常量到数组B的第一个位置
    
        // 将下三角元素存入数组B
        for (i = 0; i < n; i++)
            for (j = 0; j < i + 1; j++)
                B[k++] = *(*(A + i) + j);
    }
    
    // 下三角矩阵的输出
    void Lower_triangular_output(int B[], int length)
    {
        int i, j, k;
        int n = (sqrt(1 + 8 * length) - 1) / 2; //计算矩阵的阶数
    
        for (k = 0; k < n; k++)
        {
            // 输出下三角元素
            for (i = 0; i < (k + 1); i++)
                printf("%d ", B[k * (k + 1) / 2 + i + 1]);
    
            // 输出常数
            for (j = 1; j < n - k; j++)
                printf("%d ", B[0]);
    
            printf("\n");
        }
    }
    
    // 上三角矩阵的输入
    void Upper_triangular_input(int **A, int n, int B[])
    {
        int i, j, k = 0;
    
        // 将上三角元素存入数组B
        for (i = 0; i < n; i++)
            for (j = i; j < n; j++)
                B[k++] = *(*(A + i) + j);
    
        B[k] = **(A + (n - 1)); //存储常量到数组B的最后一个位置
    }
    
    // 上三角矩阵的输出
    void Upper_triangular_output(int B[], int length)
    {
        int i, j, k;
        int n = (sqrt(1 + 8 * length) - 1) / 2; //计算矩阵的阶数
    
        for (k = 0; k < n; k++)
        {
            // 输出常数
            for (j = 0; j < k; j++)
                printf("%d ", B[length - 1]);
    
            // 输出上三角元素
            for (i = 0; i < n - k; i++)
                printf("%d ", B[k * (n + (n - k + 1)) / 2 + i]);
    
            printf("\n");
        }
    }
    
    // 输出数组
    void echo(int *B, int length)
    {
        for (int i = 0; i < length; i++)
            printf("%d,", B[i]);
        printf("\n");
    }
    
    int main(int argc, char const *argv[])
    {
        int Symmetric[M][N] = {
            {1, 2, 3},
            {2, 1, 3},
            {3, 3, 1}};
    
        int Lower_triangular[M][N] = {
            {1, 0, 0},
            {2, 1, 0},
            {3, 3, 1}};
    
        int Upper_triangular[M][N] = {
            {1, 2, 3},
            {0, 1, 3},
            {0, 0, 1}};
    
        int *p[3];
        int length = N * (N + 1) / 2;
    
        int B[length];
    
        p[0] = Symmetric[0];
        p[1] = Symmetric[1];
        p[2] = Symmetric[2];
    
        Symmetric_input(p, N, B);
        printf("对称矩阵:\n");
        Symmetric_output(B, length);
        printf("\n压缩后:\n");
        echo(B, length);
        printf("\n");
    
        length = N * (N + 1) / 2 + 1;
    
        p[0] = Lower_triangular[0];
        p[1] = Lower_triangular[1];
        p[2] = Lower_triangular[2];
        Lower_triangular_input(p, N, B);
        printf("下三角矩阵:\n");
        Lower_triangular_output(B, length);
        printf("\n压缩后:\n");
        echo(B, length);
        printf("\n");
    
        p[0] = Upper_triangular[0];
        p[1] = Upper_triangular[1];
        p[2] = Upper_triangular[2];
        Upper_triangular_input(p, N, B);
        printf("上三角矩阵:\n");
        Upper_triangular_output(B, length);
        printf("\n压缩后:\n");
        echo(B, length);
    
        return 0;
    }
    
    展开全文
  • 上三角矩阵是矩阵在对角线以下的元素...上三角或下三角矩阵也有大部份的元素不储存值(为0),我们可以将它们使用一维阵列来储存以节省储存空间,而对称矩阵因为对称于对角线,所以可以视为上三角或下三角矩阵来储存
  • 对称矩阵存储方式

    千次阅读 2016-04-19 11:11:15
    对于N*N的矩阵A,对于任意i和j(N-1>i>=0 && N-1>j>=0),如果Aij=Aji那么,就称矩阵A是对称矩阵。以矩阵对角线为分界线,矩阵A分为三角和下三角。...对称矩阵和压缩存储的对应关系:下三角存储i>=j, SymmetricMat

    对于N*N的矩阵A,对于任意i和j(N-1>i>=0 && N-1>j>=0),如果Aij=Aji那么,就称矩阵A是对称矩阵。以矩阵对角线为分界线,矩阵A分为上三角和下三角。

    如下图:

    由对称矩阵的性质,存储对称矩阵时,只需要存储对称矩阵的上三角或下三角就可以了(压缩存储),最多存储N*(N+1)/2个数据。

    对称矩阵和压缩存储的对应关系:下三角存储i>=j,  SymmetricMatrix[i][j] == Array[i*(i+1)/2+j]


    步骤分析:

    (1)存储

    定义一个一维数组_a,开辟N*(N+1)/2个空间,遍历矩阵,若i>=j,说明元素在矩阵的下三角位置,按顺序存入_a;  若i<j,则不存储,继续遍历矩阵的下一个元素。

    (2)访问矩阵元素

    要访问压缩存储的矩阵元素,我们可以根据对称矩阵和压缩存储的对应关系: SymmetricMatrix[i][j] == Array[i*(i+1)/2+j]

    来访问矩阵元素。


    实现方法:

    #pragma once
    
    #include<iostream>
    using namespace std;
    
    template<class T>
    class SymmetricMatrix
    {
    public:
    	SymmetricMatrix(const T* a, size_t size, size_t n)//构造函数,压缩存储矩阵元素
    	:_a(new T[n*(n + 1) / 2])//开辟空间,下三角元素一共有(n*(n + 1) / 2)个
    	, _size(n*(n + 1) / 2)//设置一维数组大小
    	, _n(n)//矩阵大小(维数)
    	{
    		int index = 0;
    		for (size_t i = 0; i < n; i++)
    		{
    			for (size_t j = 0; j < n; j++)//遍历
    			{
    				if (i >= j)   //若为下三角元素
    					_a[index++] = a[i*n + j];//存储
    				else;         //若不是下三角元素
    					break      //直接跳出循环(此步骤优化,若不是下三角元素,则该行剩余元素一定也不是下三角元素)
    			}
    		}
    	}
    	~SymmetricMatrix()//析构函数
    	{
    		if (_a)
    			delete[] _a;
    	}
    	T& Access(int i,int j)//访问元素
    	{
    		if (i < j)
    			swap(i, j);
    		return _a[i*(i + 1) / 2 + j];//根据对称矩阵和压缩存储的对应关系访问元素
    	}
    	void display()//还原打印矩阵
    	{
    		for (size_t i = 0; i < _n; i++)
    		{
    			for (size_t j = 0; j < _n; j++)
    			{
    				if (i >= j)//若要打印下三角元素,则直接根据对称矩阵和压缩存储的对应关系访问元素,打印
    					cout << _a[i*(i + 1) / 2 + j] << " ";
    				else      //若打印上三角元素,则交换元素行列(根据对称矩阵性质),就可以看做该元素是下三角元素并打印
    					cout << _a[j*(j + 1) / 2 + i] << " ";
    			}
    			cout << endl;
    		}
    	}
    protected:
    	T* _a;
    	size_t _size;
    	size_t _n;
    };

    测试代码:

    #include "SymmetricMatrix.hpp"
    void TestSymmetricMatrix()
    {
    	int a[4][4] = {
    		{0,1,2,3},
    		{1,0,3,4},
    		{ 2, 3, 0, 5 },
    		{ 3, 4, 5, 0 }
    	};
    	size_t size = sizeof(a) / sizeof(a[0][0]);
    	SymmetricMatrix<int> matrix((int *)a, size, 4);
    	matrix.display();
    	cout << matrix.Access(2,3) << endl;
    }
    int main()
    {
    	TestSymmetricMatrix();
    	getchar();
    	return 0;
    }

    

    展开全文
  • 上三角三角对称矩阵

    千次阅读 2018-05-03 12:34:41
    /*上三角三角对称矩阵 说明: 上三角矩阵是矩阵在对角线以下的元素均为0,即A ij = 0,i > j,例如: 1 2 3 4 5 0 6 7 8 9 0 0 10 11 12 0 0 0 13 14 0 0 0 0 15 下三角矩阵是矩阵在对角线以上的元素均为0,即A...

     

     

    /*
    上三角下三角对称矩阵
    
    说明:
    上三角矩阵是矩阵在对角线以下的元素均为0,即A ij = 0,i > j,例如:
    1 2 3     4     5     
    0 6 7     8     9
    0 0 10     11     12
    0 0 0     13     14
    0 0 0     0     15
    下三角矩阵是矩阵在对角线以上的元素均为0,即A ij = 0,i < j,例如:
    1 0 0     0     0
    2 6 0     0     0
    3 7 10     0     0
    4 8 11     13     0
    5 9 12     14  15
    对称矩阵是矩阵元素对称于对角线,例如:
    1 2 3     4     5
    2 6 8     8     9
    3 7 10     11    12
    4 8 11     13  14
    5 9 12     14  15
    上三角或下三角矩阵也有大部份的元素不储存值(为0),我们可以将它们使用一维阵列来储存以节省储存空间,而对称矩阵因为对
    称于对角线,所以可以视为上三角或下三角矩阵来储存。
    
    解法:
    假设矩阵为nxn,为了计算方便,我们让阵列索引由1开始,上三角矩阵化为一维阵列,若以列为主,其公式为:
    loc = n*(i-1) - i*(i-1)/2 + j化为以行为主,其公式为:loc = j*(j-1)/2 + i
    
    下三角矩阵化为一维阵列,若以列为主,其公式为:loc = i*(i-1)/2 + j
    
    若以行为主,其公式为:loc = n*(j-1) - j*(j-1)/2 + i
    公式的导证其实是由等差级数公式得到,您可以自行绘图并看看就可以导证出来,对于C/C++或Java等索引由0开始的语言来说,只要
    将i与j各加1,求得loc之后减1即可套用以上的公式
    */
    
    #include<stdio.h>
    #include<stdlib.h>
    
    #define N 5
    
    int main(void){
        int arr1[N][N] = {
            {1,2,3,4,5},
            {0,6,7,8,9},
            {0,0,10,11,12},
            {0,0,0,13,14},
            {0,0,0,0,15}
        };
        int arr2[N*(1+N)/2] = {0};
        int i, j, loc = 0;
        
        printf("原二维矩阵: \n");
        for(i = 0; i < N; i++){
            for(j = 0; j < N; j++){
                printf("%4d", arr1[i][j]);
            }
            printf("\n");
        }
        
        printf("\n以列为主: ");
        for(i = 0; i < N; i++){
            for(j = 0; j < N; j++){
                if(arr1[i][j] != 0){
                    arr2[loc++] = arr1[i][j];
                }
            }
        }
        for(i = 0; i < N*(1+N)/2; i++){
            printf("%d ", arr2[i]);
        }
        
        printf("\n输入索引(i, j): ");
        scanf("%d %d", &i, &j);
        loc = N * i - i * (i + 1) / 2 + j;
        printf("(%d, %d) = %d", i, j, arr2[loc]);
        printf("\n");
        
        return 0;
    }

     

    运行结果:

     

    展开全文
  • 二维数组的地址计算 (m*n的矩阵) 行优先 设每个元素的大小是size,首元素的地址是a[1][1],则a[i][j]? 分析:a[i][j]位于第i行,第j列。它之前有i-1行,在第i行它之前有j-1个元素。 即a[i][j] = a[1][1] + [n*(i-1) ...
  • 数组与矩阵的压缩存储
  • 4上三角、下三角对称矩阵

    千次阅读 2014-10-16 09:09:55
    上三角矩阵矩阵在对角线以下的元素均为0,即Aij = 0,i > j,例如: 1 2 3 4   5 0 6 7 8   9 0 0 10   ...
  • 一、特殊矩阵(方阵) 方阵:是指行数与列数相同的矩阵 一些常用的特殊方阵如下: 对角矩阵:M是一个对角矩阵,当且仅当i!... 上三角矩阵:M是一个上三角矩阵,当且仅当i>j时,M(i,j)=0 对...
  • 48.Algorithm Gossip: 上三角、下三角对称矩阵 说明 上三角矩阵是矩阵在对角线以下的元素均为0,即Aij = 0,i > j,例如: 1 2 3 4 5 0 6 7 8 9 0 0 10 11 12 0 0 0 13 14 0 0 0 0 15 下三角矩阵是矩阵在对角...
  • 对称矩阵的压缩存储

    千次阅读 2020-07-08 20:48:57
    实验内容:对于n×n阶的对称矩阵,其元素分布的特点是a[i][j]=a[j][i],在存储时,只需压缩存储对称矩阵上三角或下三角元素,但两个对称矩阵相乘的结果不一定是对称矩阵。 实验要求: (1)创建名为kcsj14.cpp的...
  • 对称矩阵存储及转置算法

    千次阅读 2016-09-23 22:42:11
    2.对称矩阵的压缩存储 如果把矩阵中的每个元素都存储起来,那么就会显得浪费空间,因为每两个关于对角线对称的元素相等,因此就可以将矩阵压缩存储到一个数组Array中,即:将对称的两个元素存一份
  • 实现对称矩阵以及压缩存储

    千次阅读 2017-04-20 17:18:27
    压缩矩阵:对称矩阵存储时只需要存储上三角或下三角的数据,所以最多存储 n*(n+1)/2个数据。 在存数据的 时候我们只需要将一半的数据存入一个一维数组中: 当然包含对角线元素 如果我们想要通过保存的这个一维...
  • 这篇文章是主要讲述对称矩阵的压缩存储、访问和还原的。  首先,何为对称矩阵?  首先,对称矩阵是一个二维数组,也是一个方阵。它的行列对应的列列行的数据相等,即arr[i][j]==arr[j][i];如下:    那么我们...
  • 34-对称矩阵的压缩存储

    千次阅读 2018-06-26 20:11:26
    对于矩阵这样由n行n列构成的数据集合,可以通过二维数组来进行...1. 对称矩阵的压缩存储 若一个n阶方阵A[n][n]中的元素满足aij=aji(0≤i,j≤n-1),则称其为n阶对称矩阵对称矩阵的压缩存储的策略: 存储...
  • 对称矩阵如上图, 红色三角区域就是我们要存储的区域。 我们采用的存储方式是按行存储。采用的存储方式不同,定位元素时的公式会不同。 代码实现以及测试结果: #include<stdio.h> #include<stdlib.h&...
  • 1.对称矩阵:设一个N*N的方阵A,A中任意元素Aij,当且仅当Aij == Aji(0 ...3.对称矩阵和压缩存储的对应关系:下三角存储i>=j, SymmetricMatrix[i][j] == Array[i*(i+1)/2+j]。 4.这就是一个对称矩阵
  • 本次练习的内容是对称矩阵的压缩储存以及各种配套函数的实现,先放一下对称矩阵的定义: 对于一个方阵A,若其中的元素满足,则称其为对称矩阵。通俗地理解,对称矩阵就是沿着主对角线(“\”这样的是主对角线)将...
  • 第 1 章之:下三角矩阵元素存储位置计算

    千次阅读 多人点赞 2020-02-02 17:43:58
    声明:文章为博主原创,转载请联系博主。文章若有错误和疏漏之处,还望大家不吝赐教! 第一章:数据结构与算法基础===============================...1.数据结构基础与线性表:下三角矩阵元素存储位置计算、队列的...
  • 本篇博客会较为详细地讲一下我个人对三角矩阵压缩存储公式的理解,希望能给后面的朋友们带来一些帮助。
  • 对于对称矩阵,用一维数组只存储上三角或者下三角。本文只实现了存储三角,如果只存储上三角,道理是一样的。 存储三角时,又分为按行优先存储和按列优先存储 按行优先存储:把下三角一行一行的存储到一维数组中...
  • 以打包格式存储对称矩阵仅占用(大约)存储完整存储空间所需的一半内存; 此外,逐元素算术运算只在矩阵的非冗余下三角部分或上三角部分进行,矩阵转置等运算的成本为零。 这个包增加了对以打包格式存储到 ...
  • 根据对称矩阵的性质,我们可以在存储时只存储矩阵的上三角或下三角,最多存储N*(N+1)/2个数据,在数据较多的情况下,会节省很多的空间。也就是说,压缩存储称矩阵存储时只需要存储上三角/下三角的数据,所以最多存储...
  • 对称矩阵的压缩储存

    千次阅读 2017-04-18 18:11:25
    一、存储矩阵用一个二维数组即可; 二、什么是对称矩阵: 设一个N*N的方阵A,A中任意...三、对称矩阵的压缩储存: 压缩存储称矩阵存储时只需要存储上三角/下三角的数据,所以最多存储n(n+1)/2个数据(相当于1+2+

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,322
精华内容 2,128
关键字:

对称矩阵上三角存储