精华内容
下载资源
问答
  • 本博客的数据和要求是我的数据挖掘课老师提供的,代码是个人原创的。联系方式vx:qczsbwjzjn,如果想要数据可以找我。另外安利一下Matlab用于查询函数用法的官网https://ww2.mathworks.cn/help/matlab/ 一、要求 ...

    本博客的数据和要求是我的数据挖掘课老师提供的,代码是个人原创的。联系方式vx:qczsbwjzjn,如果想要数据可以找我。另外安利一下Matlab用于查询函数用法的官网https://ww2.mathworks.cn/help/matlab/

    一、要求

    给定2013,2014,2015,2016,2017的福彩双色球数据,共767期数据
    (1) 使用一种编程语言实现FP-tree的建树算法,并应用于此数据构建FP-tree;
    (2) 统计所建FP-tree中的节点数目,包括根节点;
    (3) 通过使用一个算法给出从根到叶子的节点数最多一条路径,并显示其中除根以外每个节点上的支持度计数;
    (4) 给出关于根到叶子的节点一条路径,且该路径上所有节点的支持度计数之和最大,显示每个节点上的支持度计数及总和。

    二、数据格式

    示例:

    期号       红球1    红球2    红球3    红球4    红球5    红球6

    2013001    6          8           14         15          24         25
    2013002    1         16          18         22          28         30
    2013003    22       23          26         27          28         33
    2013004    6         10          16         20          27         32

    三、数据结构

    用一个1*n的cell来存放一个节点的信息

    cell{1,1}储存当前节点所对应的球编号,cell{1,2}储存当前节点的支持度计数,cell{1,m}(2<m<=n)指向该节点下的子节点

    如图所示为根节点的节点信息

    四、Matlab代码

    main.m 主函数 

    clear
    %% 主程序
    %% 读取数据
    ball=importdata('作业01-双色球数据ssq2013_2017.txt');
    ball=ball.data(:,2:end);%提取有效数据 得到767*6的矩阵
    %% 
    f=tabulate(ball(:));
    f=sortrows(f,-2);%按支持度降序排列
    %项头表,第一列是球编号,第二列是支持度,第三列是占总体的比例
    %% 设置支持度阈值
    max=f(1,2);%支持度最大值
    threshold=max*0.8;%支持度阈值
    d=f(f(:,2)<=threshold,1);%提取出支持度低于阈值的球编号至d
    f(f(:,2)<=threshold,:)=[];%删去支持度低于阈值的球编号
    order=f(:,1);%排列顺序
    for i=1:length(ball)
        [~,index]=ismember(ball(i,:),order);
        temp=[ball(i,:);index];
        temp(:,temp(2,:)==0)=NaN;
        temp=sortrows(temp',2)';
        ball(i,:)=temp(1,:);
    end
    %% 初始化根节点
    T{1,1}=NaN;
    T{1,2}=0;
    %% 建立FP树
    for i=1:length(ball)
        temp=ball(i,:);%temp为当第i行数据
        temp=temp(~isnan(temp));%删去NaN
        if ~isempty(temp)%temp不空,向T中插入temp
            T=insertChild(T,temp,1);
        end
    end
    %% 统计节点数目,包括根节点
    Node_number=nodenumber(T);
    
    %% 统计节点最多的路径,并记录其每个节点的支持度
    % 第一行为球的编号 第二行为编号对应的支持度
    % 编号NaN表示根节点
    Node_max=nodemax(T);
    %% 节点支持度之和最大的路径
    Node_support=supportmax(T);

    insertChild.m 【递归】插入子树 

    function cell=insertChild(cell,num,k)
        loc=isChild(cell,num(k));
        if loc~=0%该元素是子树
            cell{1,loc}{1,2}=cell{1,loc}{1,2}+1;
            if k~=length(num)
                cell{1,loc}=insertChild(cell{1,loc},num,k+1);
            end
        else %该元素非子树
            if k==length(num)
                child{1,1}=num(k);
                child{1,2}=1;
                cell{1,length(cell)+1}=child;
            else
                len=length(cell);
                cell{1,len+1}{1,1}=num(k);
                cell{1,len+1}{1,2}=1;
                cell{1,len+1}=insertChild(cell{1,len+1},num,k+1);
            end
        end
    end

     isChild.m 判断该节点是否是子树,并返回位置

    function loc=isChild(cell,num)
        %loc表示该元素在cell中的位置
        loc=0;
        if length(cell)>2
            for i=3:length(cell)
                if isempty(cell{1,i})
                    break
                elseif cell{1,i}{1,1}==num
                    loc=i;
                    break;
                end
            end
        end
    end

     nodenumber.m文件 【递归】寻找当前树的叶子节点个数

    function y=nodenumber(T)
        len=length(T);
        if len==2%当前节点为叶子节点
            y=1;
        else
            y=1;
            for i=3:len
                y=y+nodenumber(T{1,i});
            end
        end
    end

     nodemax.m函数  【递归】寻找节点数最多的路径

    function y=nodemax(T)
        len=length(T);
        if len==2%当前节点为叶子节点
            y=[T{1,1};T{1,2}];
        else
            k=[T{1,1};T{1,2}];
            max=1;
            for i=3:len
                temp=[k nodemax(T{1,i})];
                if length(temp)>max
                    max=length(temp);
                    y=temp;
                end
            end
        end
    end

    supportmax.m函数 【递归】寻找支持度最大的路径

    function y=supportmax(T)
        len=length(T);
        if len==2%当前节点为叶子节点
            y=[T{1,1};T{1,2}];
        else
            k=[T{1,1};T{1,2}];
            max=0;
            for i=3:len
                temp=[k supportmax(T{1,i})];
                if sum(temp(2,:))>max
                    max=sum(temp(2,:));
                    y=temp;
                end
            end
        end
    end

    demo 简短的方便查看结果的样例代码 

    ball=[2 7 5;
          3 6 1;        
          7 5 3;          
          6 2 3;          
          7 4 5];
    threshold=2;%支持度阈值
    f=tabulate(ball(:));        %编号  支持度
    f=sortrows(f,-2);           %  3      3
    d=f(f(:,2)<threshold,1);    %  5      3
    f(f(:,2)<threshold,:)=[];   %  7      3
    order=f(:,1);               %  2      2
                                %  6      2
                                %  1      1    (低于阈值)
                                %  4      1    (低于阈值)
    %% 
    for i=1:length(ball)                    % 去除支持度低于2的元素后,按支持度对每行ball重排
        [~,index]=ismember(ball(i,:),order);% [5,7,2;
        temp=[ball(i,:);index];             %  3,6,NaN;
        temp(:,temp(2,:)==0)=NaN;           %  3,5,7;
        temp=sortrows(temp',2)';            %  3,2,6;
        ball(i,:)=temp(1,:);                %  5,7,NaN]
    end
    %% 初始化根节点
    T{1,1}=NaN;
    T{1,2}=0;
    %% 建立FP树                                   %%      所得树
    for i=1:length(ball)                              %         NaN
        temp=ball(i,:);%temp为当第i行数据              %        /  \
        temp=temp(~isnan(temp));%删去NaN              %       5    3
        if ~isempty(temp)%temp不空,向T中插入temp      %       |  / | \
            T=insertChild(T,temp,1);                 %       7 6  5  2
        end                                          %       |    |  |
    end                                              %       2    7  6
    %% 结果输出
    %统计节点数目,包括根节点
    Node_number=nodenumber(T);
    % 统计节点最多的路径,并记录其每个节点的支持度
    % 第一行为球的编号 第二行为编号对应的支持度
    % 编号NaN表示根节点
    Node_max=nodemax(T);
    % 节点支持度之和最大的路径
    Node_support=supportmax(T);

     

    展开全文
  • 该软件包包含以下常见数据结构的基于MATALB类的实现: 1)数组 2)二进制搜索 3)哈希表 4)堆 5)列表 6)队列 7)红黑 8)堆栈 编写代码的方式很容易将其翻译成其他语言。 完整资料领取:...

    数据结构

    该软件包包含以下常见数据结构的基于MATALB类的实现:

    1)数组
    2)二进制搜索树
    3)哈希表
    4)堆
    5)列表
    6)队列
    7)红黑树
    8)堆栈

    编写代码的方式很容易将其翻译成其他语言。

    完整资料领取:https://ai.52learn.online/9669

    展开全文
  • 决策实现原理与matlab代码

    万次阅读 多人点赞 2016-10-23 10:55:09
    很久不写博客了,感觉很长一段时间只是一味的看书,疏不知一味地看书、写代码会导致自己的思考以及总结能力变得衰弱。...决策是一种对实例分类的结构中包含叶子节点与内部节点。内部节点主要是数据中的某一特

    很久不写博客了,感觉很长一段时间只是一味的看书,疏不知一味地看书、写代码会导致自己的思考以及总结能力变得衰弱。所以,我决定还是继续写博客。废话不多说了,今天想主要记录数据挖掘中的决策树。希望能够将自己的理解写得通俗易懂。

    决策树是一种对实例分类的树形结构,树中包含叶子节点与内部节点。内部节点主要是数据中的某一特性,叶子节点是根据数据分析后的最后结果。

    先看一组数据:


    这组数据的特性包含年龄、工作与否、是否有房、信贷情况以及最终分类结果贷款是否成功,共包含15组样例。

    构建数的形状可以有多种,如下:

            

    如果随意构建树,那将会导致有的构建树比较庞大,分类时代价比较大,有的构建树比较小,分类代价小。

    比如针对是否有房这一列,发现如果样本有房这一列为是,最终分类结果便是可以贷款,而不需要判断其他的特性,便可以获得最终部分分类结果。

    因此,构建树需要以最小的代价实现最快的分类。根据何种标准进行判别呢?

    在信息论与概率统计中,熵是表示随机变量不确定的量度,设x是一个取有限个值的离散随机变量,其概率分布为:

    则随机变量x的熵定义为


    熵越大,其不确定性越大。

    随机变量x在给定条件y下的条件熵为H(y|x);

    信息增益表示得知特征x的信息而使得y类信息的不确定减少的程度。

    因此,特征A对训练集D的信息增益g(D,A),定义为集合D的熵H(D)与特征A给定条件下D的条件熵H(D|A)之差,即


    对表5.1给定的训练数据集D,计算各特征对其的信息增益,分别以A1,A2,A3,A4表示年龄,有工作,有自己的房子和信贷情况四个特征,则

    (1)


    (2)



    这里D1,D2,D3分别是D中A1取为青年、中年、老年的样本子集,同理,求得其他特征的信息增益:




    接下来根据之前的信息增益,对决策树进行生成,这里主要使用ID3算法,C4.5算法与之类似,只是将信息增益衡量转为信息增益比衡量。

    主要方法如下:

    从根节点开始,对节点计算所有可能的特征的信息增益,选择信息增益最大的特征作为该节点的特征,由该特征的不同取值建立子节点,再对子节点递归调用以上方法,构建决策树。

    那么递归何时停止呢?当训练集中所有实例属于同一类时,或者所有特征都选择完毕时,或者信息增益小于某个阈值时,则停止递归,。

    举例来说,根据之前对表5.1的熵的计算,由于A3(是否有自己的房子)信息增益最大,所以以A3为决策树的根节点的特征,它将数据集分为两个子集D1(A3取是)和D2(A3取否),由于D1的分类结果都是可以贷款,所以它成为叶节点,对于D2,则从特征A1,A2,A4这三个特征中重新选择特征,计算各个特征的信息增益:


    因此选择A2作为子树节点,针对A2是否有工作这个特征,根据样本分类结果发现有工作与无工作各自的样本都属于同一类,因此将有工作与无工作作为子树的叶节点。这样便生成如下的决策树:


    决策树生成算法递归的产生决策树,往往对训练数据分类准确,但对未知数据却没那么准确,即会出现过拟合状况。解决这个问题可以通过决策树的剪枝,让决策树简化。本文暂不对决策树的剪枝进行详细描述。

    接下来,即对决策树实现的matlab代码:

    1、首先,定义决策树的数据结构

    tree

    {

    int pro    //是叶节点(0表示)还是内部节点(1表示)

    int value //如果是叶节点,则表示具体的分类结果,如果是内部节点,则表示某个特征

    int parentpro //如果该节点有父节点,则该值表示父节点所表示特征的具体属性值

     tree  child[]  //表示该节点的子树数组

    }

    2、根据训练集数据通过递归形成树:

    function tree = maketree(featurelabels,trainfeatures,targets,epsino)
    tree=struct('pro',0,'value',-1,'child',[],'parentpro',-1);
    [n,m] = size(trainfeatures); %where n represent total numbers of features,m represent total numbers of examples
    cn = unique(targets);%different classes
    l=length(cn);%totoal numbers of classes
    if l==1%if only one class,just use the class to be the lable of the tree and return
        tree.pro=0;%reprensent leaf
        tree.value = cn;
        tree.child=[];
        return
    end
    if n==0% if feature number equals 0
        H = hist(targets, length(cn)); %histogram of class
       [ma, largest] = max(H); %ma is the number of class who has largest number,largest is the posion in cn
       tree.pro=0;
       tree.value=cn(largest);
       tree.child=[];
       return
    end


    pnode = zeros(1,length(cn));
    %calculate info gain
    for i=1:length(cn)
        pnode(i)=length(find(targets==cn(i)))/length(targets);
    end
    H=-sum(pnode.*log(pnode)/log(2));
    maxium=-1;
    maxi=-1;
    g=zeros(1,n);
    for i=1:n
        fn=unique(trainfeatures(i,:));%one feature has fn properties
        lfn=length(fn);
        gf=zeros(1,lfn);
        fprintf('feature numbers:%d\n',lfn);
        for k=1:lfn
            onefeature=find(fn(k)==trainfeatures(i,:));%to each property in feature,,calucute the number of this property
            for j=1:length(cn)
                oneinonefeature=find(cn(j)==targets(:,onefeature));
                ratiofeature=length(oneinonefeature)/length(onefeature);
                fprintf('feature %d, property %d, rationfeature:%f\n',i, fn(k),ratiofeature);
                if(ratiofeature~=0)
                    gf(k)=gf(k)+(-ratiofeature*log(ratiofeature)/log(2));
                end
            end  
            ratio=length(onefeature)/m;
            gf(k)=gf(k)*ratio;
        end
        g(i)=H-sum(gf);
        fprintf('%f\n',g(i));
        if g(i)>maxium
            maxium=g(i);
            maxi=i;
        end
    end


    if maxium<epsino
        H = hist(targets, length(cn)); %histogram of class
       [ma, largest] = max(H); %ma is the number of class who has largest number,largest is the posion in cn
       tree.pro=0;
       tree.value=cn(largest);
       tree.child=[];
       return
    end


    tree.pro=1;%1 represent it's a inner node,0 represents it's a leaf
    tv=featurelabels(maxi);
    tree.value=tv;
    tree.child=[];
    featurelabels(maxi)=[];


    %split data according feature
    [data,target,splitarr]=splitData(trainfeatures,targets,maxi);
    %tree.child=zeros(1,length(data));
    %build child tree;
    fprintf('split data into %d\n',length(data));
    for i=1:length(data)
       disp(data(i));
       fprintf('\n');
       disp(target(i));
       fprintf('\n');
    end
    fprintf('\n');


    for i=1:size(data,1)
        result = zeros(size(data{i}));
        result=data{i};
        temptree=maketree(featurelabels,result,target{i},0);
        tree.pro=1;%1 represent it's a inner node,0 represents it's a leaf
        tree.value=tv;
        tree.child(i)=temptree;
        tree.child(i).parentpro = splitarr(i);
        fprintf('temp tree\n');
        disp(tree.child(1));
        fprintf('\n');
    end
    disp(tree);
    fprintf("now root tree,tree has %d childs\n",size(tree.child,2));
    fprintf('\n');
    for i=1:size(data,1)
        disp(tree.child(i));
        fprintf('\n');
    end
    fprintf('one iteration ends\n');
    end

    3、根据某个特征,将数据集分成若干子数据集

    function [data,target,splitarr]=splitData(oldData,oldtarget,splitindex)
    fn=unique(oldData(splitindex,:));
    data=cell(length(fn),1);

    target=cell(length(fn),1);
    splitarr=zeros(size(fn));
    for i=1:length(fn)
        fcolumn=find(oldData(splitindex,:)==fn(i));
        data(i) =oldData(:,fcolumn);
        target(i) = oldtarget(:,fcolumn);
        data{i}(splitindex,:)=[];
        splitarr(i)=fn(i);
    end    
    end

    4、打印决策树

    function printTree(tree)
    if tree.pro==0
        fprintf('(%d)',tree.value);
        if tree.parentpro~=-1
            fprintf('its parent feature value:%d\n',tree.parentpro);
        end
        return
    end
    fprintf('[%d]\n',tree.value);
    if tree.parentpro~=-1
        fprintf('its parent feature value:%d\n',tree.parentpro);
    end
    fprintf('its subtree:\n');
    childset = tree.child;
    for i=1:size(childset,2)
        printTree(childset(i));
    end
    fprintf('\n');
    fprintf('its subtree end\n');
    end

    5、对某个具体的样本进行结果预测

    function result=classify(data, tree)
    while tree.pro==1
        childset=tree.child;
        v=tree.value;
        for i=1:size(childset,2)
            child = childset(i);
            if child.parentpro==data(v);
                tree=child;
                break;
            end
        end
    end
    result=tree.value;
    end

    接下来对数据用代码进行测试

    clear all; close all; clc
    featurelabels=[1,2,3,4];
    trainfeatures=[1,1,1,1,1,2,2,2,2,2,3,3,3,3,3;%each row of trainfeature represent one feature and each column reprensent each examples 
                    0,0,1,1,0,0,0,1,0,0,0,0,1,1,0;
                    0,0,0,1,0,0,0,1,1,1,1,1,0,0,0;
                    1,2,2,1,1,1,2,2,3,3,3,2,2,3,1
                    ];
    targets=[0,0,1,1,0,0,0,1,1,1,1,1,1,1,0];%represent classification results according to trainfeatures
    tree=maketree(featurelabels,trainfeatures,targets,0);
    printTree(tree);
    data=[2,0,0,1];
    result=classify(data,tree);
    fprintf('The result is %d\n',result);

    关于决策树的原理构建大概就结束了,后期可以继续完成对决策树的剪枝或者将决策树由多叉树转化为二叉树,让决策树更加高效矮小。源码地址:https://github.com/summersunshine1/datamining。






    展开全文
  • (http://blog.csdn.net/chenyusiyuan/archive/2007/11/16/1888968.aspx)一个多星期过去了,我根据自己对算法的理解,编写出EZW算法的Matlab程序,可以实现图像的任意级别的小波分解和重构、以及任意精度的EZW编...

     

    前段时间,我们讨论了嵌入式小波零树算法的基本原理。(http://blog.csdn.net/chenyusiyuan/archive/2007/11/16/1888968.aspx)一个多星期过去了,我根据自己对算法的理解,编写出EZW算法的Matlab程序,可以实现图像的任意级别的小波分解和重构、以及任意精度的EZW编解码过程。下面,我们以一幅16*16Lena局部图像经过3级小波分解后的小波数据为例详细的说明EZW算法的编解码过程,并给出相应的Matlab代码。原始图像如下

     

     

    分解后的小波图像数据为:

     

     

    一、在开始编码之前,首先要求出初始阈值T1
     
                 MaxDecIm=max(max(abs(DecIm)));         
                 T=zeros(1,codeDim);         
                 T(1)=2^flor(log2(MaxDecIm));  
     
    二、然后是建立小波树结构,构建扫描次序表。这个扫描次序表非常重要,后面的编码、解码过程都要按照扫描次序表逐个处理数据矩阵的各个元素。构建过程如下:用(rc)表示数据矩阵上各元素的位置。rowcol作为全局变量,表示数据矩阵的行、列数。
    1、小波树结构的特点:
    1)对于LL-N低频子带的点(r,c),有3个孩子:(r,c+W)(r+H,c)(r+H,c+W),其中WH分别是LL-N子带的宽和高;
    2)第N~2高频子带(LHHLHH)的点都有4个孩子,即: tp=[2*r-1,2*c-1;2*r-1,2*c;2*r,2*c-1;2*r,2*c];
    3)第1高频子带的点没有孩子。根据小波树的这个特点,可编写如下小波树函数treeMat(),输入矩阵内任一点的位置(rc),给出该点的子孙列表cp
     
    function cp=treeMat(r,c)    %这个函数是一个递归函数
    global row col dim      % dim是小波分解级数
    HLL=row/2^dim;
    WLL=col/2^dim;
    if (r<=HLL)&&(c<=WLL)
         tp1=[r,c+WLL;r+HLL,c;r+HLL,c+WLL];
         cP=[tp1;treeMat(r,c+WLL);treeMat(r+HLL,c);treeMat(r+HLL,c+WLL)];
    elseif (r>row/2)||(c>col/2)
         cP=[];
    else
         tp=[2*r-1,2*c-1;2*r-1,2*c;2*r,2*c-1;2*r,2*c];
         tm1=[];tm2=[];tm3=[];tm4=[];
         if (tp(4,1)<=row/2)&&(tp(4,2)<=col/2)
             t1=treeMat(tp(1,1),tp(1,2));
             tm1=[tm1;t1];
             t2=treeMat(tp(2,1),tp(2,2));
             tm2=[tm2;t2];
             t3=treeMat(tp(3,1),tp(3,2));
             tm3=[tm3;t3];
             t4=treeMat(tp(4,1),tp(4,2));
             tm4=[tm4;t4];
         end
         cP=[tp;tm1;tm2;tm3;tm4];
    end  
    示例,当row=8col=8dim=2时,LL-N低频子带的点(1,1) (1,2) (2,1) (2,2) 的子孙分布如下:
     

    由这个小波树列表tree_p,我们可以进一步构建函数childMat(),给出矩阵数据Mat和矩阵任一点的位置(rc),返回该点的子孙数据列表chMat
     
    function chMat=childMat(Mat,chRows,chCols)
    global row col dim
     
    chPoint=treeMat(chRows,chCols);
    chMat=[];
    [mRows,mCols]=size(chPoint);
    for iRows=1:mRows
       chMat=[chMat;chPoint(iRows,1),chPoint(iRows,2),Mat(chPoint(iRows,1),chPoint(iRows,2))];
    end
     
    2、构建扫描次序表
     
    本文EZW算法的扫描次序为Morton式,其特征是从(11)开始,每4个点组成一个“Z”型扫描单元,从微观到宏观上都是严格的“Z”型结构,可以用递归方法来构建扫描次序表。扫描次序表scanlist由两部分组成,一个是将数据矩阵Mat按照morton扫描次序转换成数据列表matlist,一个是按照扫描次序组成的矩阵各点位置的(rc)列表lsorder
     
    function scanlist=morton(Mat)
    global row col
     
    matlist=mat2list(Mat);
    scanorder=listorder(row,col,1,1);
    scanlist=[];
    for i=1:row*col
         scanlist=[scanlist;i scanorder(i,:) matlist(i)];
    end
     
     
    function mls=mat2list(Mat)      % 该函数为递归函数 
    [r,c]=size(Mat);
    if (r==2)&&(c==2)
         mls=[Mat(1,1);Mat(1,2);Mat(2,1);Mat(2,2)];
    else
         M1=Mat(1:r/2,1:c/2);
         M2=Mat(1:r/2,c/2+1:c);
         M3=Mat(r/2+1:r,1:c/2);
         M4=Mat(r/2+1:r,c/2+1:c);
         lt1=mat2list(M1);
         lt2=mat2list(M2);
         lt3=mat2list(M3);
         lt4=mat2list(M4);
         mls=[lt1;lt2;lt3;lt4];
    end  
     
     
    function lsorder=listorder(mr,mc,pr,pc)      % 该函数为递归函数
    lso=[pr,pc;pr,pc+mc/2;pr+mr/2,pc;pr+mr/2,pc+mc/2];
    mr=mr/2;mc=mc/2;
    lm1=[];lm2=[];lm3=[];lm4=[];
    if (mr>1)&&(mc>1)
         ls1=listorder(mr,mc,lso(1,1),lso(1,2));
         lm1=[lm1;ls1];
         ls2=listorder(mr,mc,lso(2,1),lso(2,2));
         lm2=[lm2;ls2];
         ls3=listorder(mr,mc,lso(3,1),lso(3,2));
         lm3=[lm3;ls3];
         ls4=listorder(mr,mc,lso(4,1),lso(4,2));
         lm4=[lm4;ls4];
    end
    lsorder=[lso;lm1;lm2;lm3;lm4];
    len=length(lsorder);
    lsorder=lsorder(len-mr*mc*4+1:len,1:2);                  
     
     

    展开全文
  • 使用本机数据结构Matlab提供了强大而有效的图形算法。 本代码填补了Matlab算法套件中的一个空白。即,它提供了一组丰富的算法来处理图,就像在图论图中一样。MatlabBGL软件包使用Matlab的本机稀疏矩阵类型作为...
  • 上一篇文章我们讨论了SPIHT算法与EZW算法的关系,介绍了SPIHT算法的树结构、分集规则和有序表的构建。在此基础上,我们接下来讨论算法的编码原理。下文给出了比较详细的数学描述,吃透了这一过程,就比较容易写出...
  • 随机森林原理及其用于分类问题的matlab实现

    万次阅读 热门讨论 2018-11-16 22:03:33
    随机森林 ...1.用结构体的嵌套实现树结构。 2.makerandomtree递归的创建。 3.可自动适应不同的类别标签,不同的属性个数和不同的类别个数。 4.函数ent(D)返回D的信息熵。 代 码 的主体: f...
  • 学习记录-基于采样的路径规划算法内容来源RRT主要步骤动态效果展示优缺点:自己进行的改进尝试...树结构 x, y记录此节点位置 xPrev, yPrev记录父节点位置 dist记录此节点到起点的距离(与作业源码不符,我自己进行了修改
  • 本文代码均已在 MATLAB R2019b 测试通过,如有错误,欢迎指正。 (一)决策生成算法的基本原理 决策是一种典型的分类方法,首先对数据进行处理,利用归纳算法生成可读的规则和决策,然后使用决策对新数据...
  • 前言在学习西瓜书的时候,由于书本讲的大多是概念,所以打算用C++实现它的算法部分(至于python和matlab实现,实现简单了很多,可以自己基于C++代码实现)。至于测试数据,采用了书中关于西瓜的数据集。什么是决策...
  • Matlab实现决策C4.5算法并执行 作者:William_Dong  最后分析了tree的结构,只是初步理解,之后会运用新的样本集。   (高亮!!!!啊啊啊啊,疯了,这个C4.5的程序是错误的,  具体是连续属性那里分裂...
  • matlab学习之simulink

    2019-08-17 10:15:16
    simulink中模块是按照树结构存放的。 可以把左侧的列表值看作一个文件夹,打开文件夹后如下图所示。 下图中的support package起到连接作用,可以把上面介绍的模块与下面固件库的模块组合使用,同时实现代码生成...
  • 基于MFC的产品结构树管理系统的实现.pdf 基于MFC的代码编辑器设计方法.pdf 基于MFC的加密解密工具的开发.pdf 基于MFC的动态链接库的创建和调用方法研究.pdf 基于MFC的工程软件界面设计.pdf 基于MFC的平板式悬架参数...
  • 基于MFC的产品结构树管理系统的实现.pdf 基于MFC的代码编辑器设计方法.pdf 基于MFC的加密解密工具的开发.pdf 基于MFC的动态链接库的创建和调用方法研究.pdf 基于MFC的工程软件界面设计.pdf 基于MFC的平板式悬架参数...
  • 基于MFC的产品结构树管理系统的实现.pdf 基于MFC的代码编辑器设计方法.pdf 基于MFC的加密解密工具的开发.pdf 基于MFC的动态链接库的创建和调用方法研究.pdf 基于MFC的工程软件界面设计.pdf 基于MFC的平板式悬架参数...
  • 基于MFC的产品结构树管理系统的实现.pdf 基于MFC的代码编辑器设计方法.pdf 基于MFC的加密解密工具的开发.pdf 基于MFC的动态链接库的创建和调用方法研究.pdf 基于MFC的工程软件界面设计.pdf 基于MFC的平板式悬架参数...
  • 11.1 与MATLAB/Octave交换信息 256 11.2 Installing rpy2安装rpy2 257 11.3 连接R 257 11.4 为Java传递NumPy数组 260 11.5 集成SWIG和NumPy 261 11.6 集成Boost和Python 264 11.7 通过f2py使用Fortran代码 266...
  • SHOGUN 的核心由C++实现,提供 Matlab、 R、 Octave、 Python接口。主要应用在linux平台上。 项目主页: http://www.shogun-toolbox.org/ 5. MDP The Modular toolkit for Data Processing (MDP) ,用于数据处理...
  • 2、 在计算机技术领域拥有扎实的技术功底,尤其在数据结构、算法和代码、软件设计方面功力深厚; 对数据结构有一定的研究基础如链表、堆杖、等,熟悉数据库编程; 3、 出色的算法分析能力,对某一特定算法可以做...
  • 3.5 基于Matlab的指纹识别系统 92 3.5.1 主界面程序 93 3.5.2 指纹中心计算程序 115 3.5.3 计算有效区域 117 3.5.4 二维Gabor变换 118 3.5.5 归一化扇区 119 3.5.6 读取图像 120 3.5.7 旋转角度计算 ...
  • C++ B-tree :基于B数据结构实现命令内存容器的模板库。 Colony:无序的”bag“型容器,在高度修改的情况下,其性能优于标准容器。同时,无论插入还是擦除,其都能始终保持指向未擦除元素的永久指针。 dynamic...
  • 分支结构的应用场景 - 条件 / 缩进 / 代码块 / 流程图 if语句 - 简单的if / if-else结构 / if-elif-else结构 / 嵌套的if 应用案例 - 用户身份验证 / 英制单位与公制单位互换 / 掷骰子决定做什么 / 百分制成绩转等级...
  • 除正常应免费赠送的软件与资料电子光盘外,另有自编译相关著名GIS软件二次开发手册、编译代码、相关项目开发文档、并提供可与Google earth数据交换的网上建筑三维建模共享软件、GIS软件在相关专业的中文操作使用手册...

空空如也

空空如也

1 2
收藏数 25
精华内容 10
关键字:

matlab树结构代码实现

matlab 订阅