矩阵数据_树数据结构

已于 2023-10-24 14:39:14 修改
阅读量477 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 矩阵 数据结构 java 1024程序员节
于 2022-08-03 00:07:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38637558/article/details/126131951
版权

文章目录

1、前言

  1. 我不确定是否是矩阵数据, 烦请各位留言指正. 但该数据的处理方案自我觉得确实可以记录为一篇博客

  2. 矩阵数据 转换为 树数据结构

  3. 代码地址

2、预处理数据

  1. 多个json数组
  2. 不确定的: key, value, sort值不固定, 数组长度不固定
  3. 确定的: json数组的key值固定, sort值固定. 第一个json数组sort=1, key=充值类型, 第二个json数组sort=1, key=充值类型
[{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送QQ会员"}],
[{"key":"充值类型","sort":1,"value":"钻石会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送网易会员"}],
[{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送腾讯会员"}],
[{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送京东会员"}],
[{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"4个月"},{"key":"套餐","sort":3,"value":"赠送酷狗会员"}],
[{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"2个月"},{"key":"套餐","sort":3,"value":"赠送微信会员"}],
[{"key":"充值类型","sort":1,"value":"钻石会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送腾讯会员"}],
[{"key":"充值类型","sort":1,"value":"钻石会员"},{"key":"时间","sort":2,"value":"2个月"},{"key":"套餐","sort":3,"value":"赠送微信会员"}]

3、期望得到数据结构

  1. 转换为树数据结构
  2. (sort排序, value相同的去重, 对应的 sort+1 数据做子数据, 子数据绑定对应的父级) 循环该操作, 直至所有数据处理完毕
[{
	"mark": "充值类型",
	"name": "铂金会员",
	"saleAttributeVOList": [{
		"mark": "时间",
		"name": "3个月",
		"saleAttributeVOList": [{
			"mark": "套餐",
			"name": "赠送QQ会员",
			"sort": 3
		}, {
			"mark": "套餐",
			"name": "赠送腾讯会员",
			"saleAttributeVOList": [],
			"sort": 3
		}, {
			"mark": "套餐",
			"name": "赠送京东会员",
			"saleAttributeVOList": [],
			"sort": 3
		}],
		"sort": 2
	}, {
		"mark": "时间",
		"name": "4个月",
		"saleAttributeVOList": [{
			"mark": "套餐",
			"name": "赠送酷狗会员",
			"saleAttributeVOList": [],
			"sort": 3
		}],
		"sort": 2
	}, {
		"mark": "时间",
		"name": "2个月",
		"saleAttributeVOList": [{
			"mark": "套餐",
			"name": "赠送微信会员",
			"saleAttributeVOList": [],
			"sort": 3
		}],
		"sort": 2
	}],
	"sort": 1
}, {
	"mark": "充值类型",
	"name": "钻石会员",
	"saleAttributeVOList": [{
		"mark": "时间",
		"name": "3个月",
		"saleAttributeVOList": [{
			"mark": "套餐",
			"name": "赠送网易会员",
			"sort": 3
		}, {
			"mark": "套餐",
			"name": "赠送腾讯会员",
			"saleAttributeVOList": [],
			"sort": 3
		}],
		"sort": 2
	}, {
		"mark": "时间",
		"name": "2个月",
		"saleAttributeVOList": [{
			"mark": "套餐",
			"name": "赠送微信会员",
			"saleAttributeVOList": [],
			"sort": 3
		}],
		"sort": 2
	}],
	"sort": 1
}]

4、几个难点

1. 如何将这个未知数据处理完毕
2. 如何获取上一级数据
3. 如何获取下一级数据
4. 如何赋值给上一级

5、示列代码

  1. 示列数据可至博客地址获取, 贴上来太长了:https://gitee.com/xmaxm/test-code/blob/master/chaim-special-data/src/main/java/com/chaim/chaimspecialdata/matrix/MatrixData.java
package com.chaim.chaimspecialdata.matrix;

import com.alibaba.fastjson.JSONObject;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

//@formatter:off
/**
 * 处理矩阵数据
 *
 * 源数据(key, value不固定, 规格不固定, 可能更多):
 *      [{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送QQ会员"}],
 *      [{"key":"充值类型","sort":1,"value":"钻石会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送网易会员"}],
 *      [{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送腾讯会员"}],
 *      [{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送京东会员"}],
 *      [{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"4个月"},{"key":"套餐","sort":3,"value":"赠送酷狗会员"}],
 *      [{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"2个月"},{"key":"套餐","sort":3,"value":"赠送微信会员"}],
 *      [{"key":"充值类型","sort":1,"value":"钻石会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送腾讯会员"}],
 *      [{"key":"充值类型","sort":1,"value":"钻石会员"},{"key":"时间","sort":2,"value":"2个月"},{"key":"套餐","sort":3,"value":"赠送微信会员"}]
 *
 * 期望类型(sort相同进行过滤去重, 子集做子数据, 已树形结构展示):
 *      [
 *      {"mark":"充值类型","name":"铂金会员","saleAttributeVOList":[
 *              {"mark":"时间","name":"3个月","saleAttributeVOList":[
 *                      {"mark":"套餐","name":"赠送QQ会员","sort":3},
 *                      {"mark":"套餐","name":"赠送腾讯会员","sort":3},
 *                      {"mark":"套餐","name":"赠送京东会员","sort":3}
 *              ],"sort":2},
 *              {"mark":"时间","name":"4个月","saleAttributeVOList":[
 *                      {"mark":"套餐","name":"赠送酷狗会员","sort":3}
 *               ],"sort":2},
 *              {"mark":"时间","name":"2个月","saleAttributeVOList":[
 *                      {"mark":"套餐","name":"赠送微信会员","sort":3}],"sort":2}
 *              ],"sort":1},
 *       {"mark":"充值类型","name":"钻石会员","saleAttributeVOList":[
 *             {"mark":"时间","name":"3个月","saleAttributeVOList":[
 *                      {"mark":"套餐","name":"赠送网易会员","sort":3},
 *                      {"mark":"套餐","name":"赠送腾讯会员","sort":3}
 *             ],"sort":2},
 *             {"mark":"时间","name":"2个月","saleAttributeVOList":[
 *                      {"mark":"套餐","name":"赠送微信会员","sort":3}],"sort":2}
 *             ],"sort":1}
 *     ]
 *
 * @author Chaim
 * @date 2022/7/30 23:36
 * @Description
 */
public class MatrixData {
    /**
     * 几个点:
     *      1. 如何将这个未知数据处理完毕
     *      2. 如何获取上一级数据
     *      3. 如何赋值给上一级
     *      4. 注释(saleAttributeVO != null)内外的没有联系, 大致逻辑差不多可以参考
     * 处理逻辑
     * 注释逻辑为列: [{"key":"充值类型","sort":1,"value":"铂金会员"},{"key":"时间","sort":2,"value":"3个月"},{"key":"套餐","sort":3,"value":"赠送QQ会员"}]
     *
     * @param args
     */
//@formatter:on
    public static void main(String[] args) {
        // 模拟数据
        List<SaleAttributeBO> saleAttributeBOList = getData();

        // 最终类型
        List<SaleAttributeVO> resultList = new ArrayList<>();
        for (SaleAttributeBO saleAttributeBO : saleAttributeBOList) {
            // 待处理数据
            List<SaleAttributeBO.SaleAttribute> saleAttributeList = saleAttributeBO.getSaleAttributeBO();
            saleAttributeList.sort(Comparator.comparing(SaleAttributeBO.SaleAttribute::getSort));

            // 待处理数据第一条. 第一条数据的处理方式会不一样, 他会涉及到一个类似初始化的过程    ({"key":"充值类型","sort":1,"value":"铂金会员"})
            SaleAttributeBO.SaleAttribute saleAttribute = saleAttributeList.get(0);
            // 第一条的数据值  ("value":"铂金会员")
            String value = saleAttribute.getValue();
            // 判断第一条数据值是否已经初始化过, 或者返回数据中是否已经记录了该数据, 存在就忽略该数据
            SaleAttributeVO saleAttributeVO = resultList.stream().filter(versionVO -> value.equals(versionVO.getName())).findAny().orElse(null);
            if (saleAttributeVO != null) {
                // 开始处理子数据, 从第二个数据开始处理
                for (int i = 1; i < saleAttributeList.size(); i++) {
                    // 当前待处理数据. 比如当前待处理数据 ({"key":"套餐","sort":3,"value":"赠送QQ会员"})
                    SaleAttributeVO recursion = getRecursion(saleAttributeList.get(i));
                    // 初始化: 初始化数据的第一层数据. 递归赋值当前数据上层数据 (while之后的数据{"mark": "时间", "name": "3个月", "saleAttributeVOList": []})
                    List<SaleAttributeVO> saleAttributeVOList = saleAttributeVO.getSaleAttributeVOList();
                    // while结束条件, 做递归操作, 一直获取最低程的子数据
                    int j = i;
                    // 获取上一层数据的条件
                    int n = 1;
                    // 下面初始化数据有注释
                    while (j > 1) {
                        // 当前待处理数据的上一层数据, ({"key":"时间","sort":2,"value":"3个月"})
                        SaleAttributeVO recursionReturn = getRecursion(saleAttributeList.get(n));
                        // 判断待处理的上一层数据是否已经在树中存在
                        SaleAttributeVO versionVO = saleAttributeVOList.stream().filter(vo -> recursionReturn.getName().equals(vo.getName())).findAny().orElse(null);
                        // null的情况不需要处理, 因为你的数据不可能存在: 一级二级三级数据中没有二级数据的情况
                        if (versionVO != null) {
                            // 存在就将上一层的数据的子级数据重新赋值给 saleAttributeVOList , 只有这样才能处理如何获取上一级数据, 并做赋值操作
                            saleAttributeVOList = versionVO.getSaleAttributeVOList();
                        }
                        j--;
                        n++;
                    }

                    // 判断当前待处理数据是否存在子级数据中, 不存在就做子级数据赋值
                    SaleAttributeVO versionVO = saleAttributeVOList.stream().filter(vo -> recursion.getName().equals(vo.getName())).findAny().orElse(null);
                    if (versionVO == null) {
                        // 用于处理子级数据为null导致空指针
                        recursion.setSaleAttributeVOList(new ArrayList<>());
                        saleAttributeVOList.add(recursion);
                    }
                }
                continue;
            }

            // 初始化数据
            SaleAttributeVO attributeVO = new SaleAttributeVO();
            attributeVO.setSort(saleAttribute.getSort());
            attributeVO.setMark(saleAttribute.getKey());
            attributeVO.setName(saleAttribute.getValue());
            // 处理的第一条数据没有初始化过, 证明该数据的子集都可以直接做成子数据
            for (int i = 1; i < saleAttributeList.size(); i++) {
                // 待处理子数据
                SaleAttributeVO recursionReturn = getRecursion(saleAttributeList.get(i));
                List<SaleAttributeVO> saleAttributeArrayList = new ArrayList<>();
                // 第一条数据的子数据赋值, 用于递归处理
                // 注: attributeVO该值是已经持久化到attributeVO, 136行
                SaleAttributeVO versionVO = attributeVO;
                // while结束条件, 做递归操作, 一直获取最低程的子数据
                int j = i;
                // j = i; j > 1.
                // 我们需要的是一个树形数据, 列:
                // 当j=1时, recursionReturn是第一层数据("key":"时间"), 故while条件不成立, 可直接赋值给父级, 做树二级
                // 当j=2时, j--; while最终是执行一次, recursionReturn是第二层数据("key":"套餐"), 获取的上一级数据是第二层("key":"时间"), 做树三级
                while (j > 1) {
                    // 获取上一条数据的子集, 从新赋值,
                    // 初始化数据所以都是get(0)
                    versionVO = versionVO.getSaleAttributeVOList().get(0);
                    j--;
                }
                // 子数据加入父级
                saleAttributeArrayList.add(recursionReturn);
                versionVO.setSaleAttributeVOList(saleAttributeArrayList);
            }
            resultList.add(attributeVO);
        }
        System.out.println(JSONObject.toJSONString(resultList));
    }

    /**
     * 装换数据
     *
     * @param saleAttributeBO
     * @return
     */
    public static SaleAttributeVO getRecursion(SaleAttributeBO.SaleAttribute saleAttributeBO) {
        SaleAttributeVO vo = new SaleAttributeVO();
        vo.setMark(saleAttributeBO.getKey());
        vo.setName(saleAttributeBO.getValue());
        vo.setSort(saleAttributeBO.getSort());
        return vo;
    }

    /**
     * 生成模拟数据
     *
     * @return
     */
    public static List<SaleAttributeBO> getData() {
        List<SaleAttributeBO> skuStockClientVOList = new ArrayList<>();

        /**
         * 贴上来太长了, 而且这个示列数据也不重要
         * 示列数据可至博客地址获取:
         * https://gitee.com/xmaxm/test-code/tree/master/chaim-special-data/src/main/java/com/chaim/special/data/matrix
         */
        SaleAttributeBO saleAttributeBO8 = new SaleAttributeBO();
        List<SaleAttributeBO.SaleAttribute> attributeArrayList8 = new ArrayList<>();
        SaleAttributeBO.SaleAttribute saleAttributeEight = new SaleAttributeBO.SaleAttribute();
        saleAttributeEight.setKey("充值类型");
        saleAttributeEight.setValue("钻石会员");
        saleAttributeEight.setSort(1);
        attributeArrayList8.add(saleAttributeEight);
        SaleAttributeBO.SaleAttribute saleAttributeEight2 = new SaleAttributeBO.SaleAttribute();
        saleAttributeEight2.setKey("时间");
        saleAttributeEight2.setValue("2个月");
        saleAttributeEight2.setSort(2);
        attributeArrayList8.add(saleAttributeEight2);
        SaleAttributeBO.SaleAttribute saleAttributeEight3 = new SaleAttributeBO.SaleAttribute();
        saleAttributeEight3.setKey("套餐");
        saleAttributeEight3.setValue("赠送微信会员");
        saleAttributeEight3.setSort(3);
        attributeArrayList8.add(saleAttributeEight3);
        SaleAttributeBO.SaleAttribute saleAttributeEight4 = new SaleAttributeBO.SaleAttribute();
        saleAttributeEight4.setKey("爆率");
        saleAttributeEight4.setValue("30%");
        saleAttributeEight4.setSort(4);
        attributeArrayList8.add(saleAttributeEight4);
        SaleAttributeBO.SaleAttribute saleAttributeEight5 = new SaleAttributeBO.SaleAttribute();
        saleAttributeEight5.setKey("武器类型");
        saleAttributeEight5.setValue("传奇");
        saleAttributeEight5.setSort(5);
        attributeArrayList8.add(saleAttributeEight5);
        saleAttributeBO8.setSaleAttributeBO(attributeArrayList8);

        skuStockClientVOList.add(saleAttributeBO);
        skuStockClientVOList.add(saleAttributeBO2);
        skuStockClientVOList.add(saleAttributeBO3);
        skuStockClientVOList.add(saleAttributeBO4);
        skuStockClientVOList.add(saleAttributeBO5);
        skuStockClientVOList.add(saleAttributeBO6);
        skuStockClientVOList.add(saleAttributeBO7);
        skuStockClientVOList.add(saleAttributeBO8);

        return skuStockClientVOList;
    }
}

6、备注

  1. 处理起来可能还是稍微有点点复杂, 需要对数据整体的结构有一个很清晰的认知
  2. 如果只是处理两层, 三层, 或者说固定长度数据, 到确实简单, 但是当其长度不确定的时候, 就会稍微复杂一些了
  3. 可能对对象的赋值, 内存结构有了更深的认知吧
Chaim_chen
关注
专栏目录
矩阵数据
qq_43533498的博客
03-08 932
一.元组，小括号 1.一维数组 In [4]: a Out[4]: array([0, 1, 2, 3, 4]) In: a.shape Out: (5,) 正如你所看到的，这是一个包含5个元素的向量，取值分别为0~4的整数。数组的shape属性 返回一个元组（tuple），元组中的元素即为NumPy数组每一个维度上的大小。上面例子中的数组 是一维的，因此元组中只有一个元素。 In: m = ...
数据结构----对称矩阵压缩存储中下标的计算
SWEENEY_HE的博客
01-06 1万+
一.压缩存储的概念: 首先看一个对称矩阵： 以深灰色为对称轴，由于矩阵内数据对称，因此只需将任意一边的数据存储起来即可。 考虑到存储单元的线性结构，我们可以以一维数组的形式将其存储起来。 需要存储的元素为： 各个元素对应在一维数组中的位置示意图（按行优先存储）： 由图可见：元素在一维数组中的下标就是它矩阵左半部分中按行优先存储的序号。 二. 二维坐标转一维下标的方法： ...
矩阵数据操作
lildn的博客
11-15 207
reshape（更改行列数） import numpy as np X=np.array([6, 9, 6, 1, 1, 2, 8, 7, 3, 5, 6, 3, 5, 3, 5, 8, 8, 2, 8, 1, 7, 8,7, 2, 1, 2 , 9, 9, 4, 9]) X=X.reshape(-1,3) 判断语句给数据重新赋值 for i in range(10): if X[i][2]<=3: X[i][2]=0 elif X[i][2]
数据结构与算法——矩阵
最新发布
m0_58683132的博客
08-02 1878
矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合，它是一个二维的数据结构，由行和列组成，通常用来表示二维的数据集合。在数学中，矩阵最早来自于方程组的系数及常数所构成的方阵，这一概念由19世纪英国数学家凯利首先提出。在数据结构中，矩阵主要讨论如何在节省存储空间的前提下，正确高效地运算矩阵。
九大数据分析方法：矩阵分析法
weixin_38754337的博客
09-28 683
来源：码工小熊 作者：小熊妹天继续分享九大数据分析方法系列：矩阵分析法。矩阵分析法是在各路数据分析文章中，出现频率最高的词。甚至有不懂行的小白把它捧到“核心思维”，“底层逻辑”...
nenmen.zip_二维距离_矩阵聚类_聚类树_距离矩阵聚类
07-13
这种数据结构在构建聚类树时非常有效，它以随机选择的中心点为基础，逐步添加数据点，形成树状结构。这种方法通常用于大数据集，因为它既快速又节省内存。 4. **聚类树**（Dendrogram）： 聚类树是一种可视化工具...
最小生成树_prim_数据结构_课设_最小生成树_
10-04
基本要求：1、城市间的距离网采用邻接矩阵表示，邻接矩阵的存储结构定义采用课本中给出的定义，若两个城市之间不存在道路，则将相应边的权值设为自己定义的无穷大值。要求在屏幕上显示得到的最小生成树中包括了哪些...
数据结构_基于C++数据结构源码_数据结构_silent2pg_
09-29
"silent2pg"可能是这个项目或者作者的代号，而"基于C++数据结构源码_数据结构_silent2pg_"这个标题暗示了这是一个包含C++实现的各种数据结构的代码库。 在C++中，常见的数据结构包括数组、链表、栈、队列、树、图等...
数据结构_树
weixin_44342705的博客
04-25 136
树 树和二叉树 元素 父节点 孩子节点 兄弟节点 特殊形式 满二叉树 满二叉树的每一个分支都是满的 完全二叉树 顺序和位置都对应的 满二叉树的一部分 实现 链式存储实现 struct tree { int data; struct tree* left; struct tree* right; }; 数组实现 父子的下标关系： leftchild=2×parent+1; rightchild=2×parent+2; parent=(leftchild-1)/2;
MatrixDG.zip_数据结构_Java__数据结构_Java_
08-09
在IT领域，数据结构是计算机科学的基础，它研究如何有效地组织和存储数据，以便于算法的执行。Java作为一种广泛使用的编程语言，提供了丰富的库来支持数据结构的实现。本话题聚焦于“有向图”的数据结构及其在Java中...
数据结构——矩阵及其常用操作
wardseptember的博客
12-19 3771
/************************ author's email:wardseptember@gmail.com date:2017.12.19 ************************/ //矩阵常用操作 #include<iostream> using namespace std; #define maxSize 4 void trsmat(int A[][maxSize
数据结构--矩阵
m0_62476845的博客
10-22 2240
数组和广义表，可看成是线性表的扩展。即线性表中的数据元素既可以是单个元素，也可以是一个线性结构。数组中的每个数据元素可用类型相同的数组来表示；广义表则比较灵活，每个数据元素可以是不在分的原子类型，也可以是子表。数组和广义表都是常用的数据结构，在相关领域有着广泛的应用。数组是一种很多高级语言都支持的、应用广泛的数据类型，可以看作线性表的推广。数组作为一种数据类型。从逻辑结构上看，数组可以看成是一般线性表的特殊形式；二维数组可以看成是线性表的线性表。
数据结构-矩阵
sinat_41752325的博客
12-22 1855
导言 数据结构中，主要讨论如何在节省存储空间的情况下使矩阵的各种运算能高效地进行。 有些矩阵存在很多值相同的元素或者0元素，这时为了节省空间，就可以对这种矩阵进行压缩。压缩的原则是：为多个值相同的元素只分配一个存储单元，0元素不分配存储单元。 用于压缩的矩阵有特殊矩阵和稀疏矩阵 一、特殊矩阵 如果矩阵中的元素的分布有一定规律，称之为特殊矩阵。 常见的特殊矩阵有对称矩阵、三角矩阵、对角矩阵。 1.1 对称矩阵 若矩阵An*n中的元素特点是a[ij]=a[ji]，则称之为n阶对称矩阵。 对..
Java数组转树(listToTree), 树转数组(treeToList)的正确姿势, 写成接口方式
weixin_36597302的博客
02-09 3414
Java数组转树(listToTree), 树转数组(treeToList)的正确姿势, 写成接口方式 直接上代码: package cn.mandy.sysadmin.common.util; import java.io.*; import java.util.ArrayList; import java.util.List; // MandyTree 实现 deepClone, 需要 ...
数据结构实验：用邻接矩阵存储，并按Prim算法求最小生成树
10-10
根据书P262习题3给定的无向带权图，用邻接矩阵作为存储结构，用prim算法构造其最小生成树。 对图G(V,E)设置集合S，存放已访问的顶点，然后每次从集合V-S中选择与集合S的最短距离最小的一个顶点(记为u)，访问并加入...
常用的矩阵数据处理命令（Matlab）
mmm305658979的博客
06-25 4899
resp = fig2plotly() %把m列1行的矩阵A复制成m列n行 A=repmat(A,n,1); %自带函数绘制ROC曲线,a为1*n表示样本实际标签，b为1*n表示样本预测为1的概率 plotroc(a,b) %把m行n列的矩阵转为mn *1 的向量 B = A(:); %把向量A转换为3维的n*n*n向量 B= reshape(A,n,n,n...
OpenCV—矩阵数据类型转换cv::convertTo
热门推荐
iracer的博客
10-17 6万+
矩阵数据类型转换函数convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) 的使用方法及示例
数据挖掘中的矩阵基础（1）
数据挖掘纵横谈
08-08 1596
先有矩阵，然后有行列式。矩阵常有，而行列式不常有。 矩阵是存储数据的，单独的一个数，从本质来讲，也是矩阵，不过是1行1列的。行列式的意义在于发现矩阵中数据的特征。 矩阵存储数据，因而，如果加以某种运算，矩阵是可以作用到其他矩阵上的，并且可以改变原矩阵。例如，2、5同是1行1列矩阵，2*5=10，矩阵2，通过矩阵5的作用，变成了矩阵10。将这种性质扩展到多维空间中，便是矩阵变化，也就是说，矩阵也可
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值