实验 树的表示

最新推荐文章于 2024-07-25 20:40:59 发布
最新推荐文章于 2024-07-25 20:40:59 发布
阅读量1.2k 收藏 28
点赞数 16
分类专栏： 数据结构 文章标签： 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51297067/article/details/121044460
版权

实验 树的表示

实验内容

实验指导书

实验 树的表示 (对应毕业要求：2.3)

预习要求：复习相关知识，熟悉树的存储与遍历方法。

实验方式：学生通过编写程序调试算法。

实验要求：学生应调试程序能得到正确的执行结果，并能回答与具体实验题目相关的问题。

内容： 从输入文件读入数据，在内存中分别构建树的 “双亲表示”、“孩子兄弟表示”，并在屏幕上输出“凹凸表示”，在输出文件输出“括号表示”

输入文件格式，input.txt

- - - - - - - - - - - - - - - -

25

1,23

2,22

…

- - - - - - - - - - - - - - - -

说明：第一行为顶点数目N，顶点名为1 到 N，且1为root顶点

后面的N-1行，每行表示一条边的两个顶点

屏幕输出，例

1

​ 5

​ 6

​ 7

​ 12

​ 13

​ 15

​ 8

​ 20

…

文件输出，output.txt

(1,（5，（6）（7，（12，13，15））），（8，（20））

程序要点：

1、顶点结构、边结构

Struct vertex{

Int name;

}

Struct edge{

Int v1,v2;

}

2、文件读写 ：fopen , fscanf , fprintf, fclose

3、顺序表构建顶点集合、边集合

4、构建双亲表示：

算法描述：

（1）从root开始，遍历边集合找到root的所有孩子节点，并在双亲表示法中为这些节点设置父节点。

（2）对顶点集合中每个节点重复上述“找孩子”操作。

（3）直到已经为N个节点找了孩子，算法结束

5、依据前面双亲表示法中的节点存储顺序，构建孩子兄弟法的二叉树表示

算法描述：

从root开始，依此构建孩子兄弟法。

6、凸凹表示法输出：

（1）从双亲表示法，计算每个节点的层数k

（2）按双亲表示法顺序，依此输出k个tab和节点名

7、文件输出符号表示法

算法描述：

（1）从上面的“孩子兄弟表示法”递归生成每颗子树的描述串。

如对某个节点i，函数i返回以他为根的子树对应的描述串

Void fun(node * root,int i,char * result){

Strcat(result,”(”);

Strcat(result,itoa(i));

//遍历i的孩子，并为每个孩子子树生成描述串

For each child x{

​ Char buf[1000]=””;

fun(root,x,buf);

Strcat(result,buf);

}

Strcat(result,”)”);

}

树示例：
在这里插入图片描述

已知输入文件的内容：

20
1,2
1,3
4,1
5,1
2,15
2,14
2,13
12,3
11,4
9,4
5,6
5,7
5,8
14,16
16,18
16,19
16,17
11,20
11,10

具体实现

关于顶点集和边集

老师这里要求我们采用图形存储我们所接收到的数据

  • 顶点集存放所有顶点的名字，用顺序表存放顶点，下标从0开始
  • 边集存放着顶点之间的信息，同样用顺序表存放边，表中每个结点由两个数据组成，分别是每条边的两个顶点
  • 另外设置两个参数，计算顶点的个数和边的数量
#define N 100
struct Vertex{
	int Vname;
}; 
int VertexCount = 0;
Vertex VertexSet[N];

struct Edge{
	int v1;
	int v2;
};
int EdgeCount = 0;
Edge EdgeSet[N];

读取数据

  • 进行对文件的读取操作
  • 在读取文件的过程中对顶点集和边集进行初始化
  • 偷偷说一句这个老师真的好爱用文件操作。。。这个难道是以后出去工作的基操（？）
void loadDate(){
	FILE *fp;
	fp = fopen("TreeInput.txt","r");
	if(fp == NULL){
		printf("ERROR!");
	}
	fscanf(fp,"%d\n",&VertexCount);//第一行是顶点个数
	int i;
	for(i = 0 ; i < VertexCount ; i++){
		VertexSet[i].Vname = i+1;//顶点名字从1开始
	}
	while(!feof(fp)){
		fscanf(fp,"%d,%d\n",&EdgeSet[EdgeCount].v1,&EdgeSet[EdgeCount].v2);
		EdgeCount++;
	}
}

构建双亲表示

  • 双亲表示法实际上是用线性表来存放一棵树
  • 每个结点都包含两个基本的内容：结点本身的信息Vname以及其双亲结点的下标parentIndex
  • 由于下面要采用凸凹法输出这棵树，所以在每个结点的结构体定义中加上一个层数k
/
//建立双亲表示法结点结构

struct parentTree{
	int Vname;
	int parentIndex;
	int k;
}; 
parentTree parentNode[N];

在前面老师让我们用图形存储了数据，按理说每个结点的遍历就应该用图的方法去遍历，为此我还特意去学习了图的遍历深度优先搜索邻接矩阵存图什么的，但是这节实验之前老师都还没有上到这部分的内容，所以直接就按最朴素的方法去做了

算法描述：

（1）从root开始，遍历边集合找到root的所有孩子节点，并在双亲表示法中为这些节点设置父节点。

（2）对顶点集合中每个节点重复上述“找孩子”操作。

（3）直到已经为N个节点找了孩子，算法结束

  • 先用循环遍历给这棵树的每个结点赋值，并且每个结点的双亲下标都先设置一个默认值

  • 第一层循环按顶点集遍历每个顶点，设为顶点A

  • 第二层循环按顶点集遍历A之后的其他顶点，设为顶点B

  • 第三层循环遍历边集的每条边

  • 先将根节点的双亲设为-1

  • 根节点已经设置了双亲，往下判断一条边的两个顶点哪个是双亲哪个是儿子就看这个顶点的双亲是否有改变

  • 如果A和B是这条边的两个顶点，即分别与这条边的v1和v2相等，并且A顶点已经找到了双亲而B顶点还没有，则将A顶点设为B顶点的双亲

  • 求层数：这个操作是在网上看到的，觉得很神奇就拿来用了，具体的不知道该怎么描述，直接看代码吧

#define unknow -999
void BuildParentTree(){
	int i,j,k;
	for(i = 0 ; i < VertexCount ; i++){
		parentNode[i].Vname = VertexSet[i].Vname;
		parentNode[i].parentIndex = unknow;
	}
	parentNode[0].parentIndex = -1;
	for(i = 0 ; i < VertexCount ; i++){
		for(j = 1 ; j < VertexCount ; j++){
			for(k = 0 ; k < EdgeCount ; k++){
				if(	
					(EdgeSet[k].v1 == parentNode[i].Vname&&
					 EdgeSet[k].v2 == parentNode[j].Vname&&
					 parentNode[i].parentIndex != unknow&&
					 parentNode[j].parentIndex == unknow) 
					||
					(EdgeSet[k].v1 == parentNode[j].Vname&&
					 EdgeSet[k].v2 == parentNode[i].Vname&&
					 parentNode[i].parentIndex != unknow&&
					 parentNode[j].parentIndex == unknow)
				){
					parentNode[j].parentIndex = i;		
				}
			}
		}
	}
	//
	//求层数
	/
	for(i = 0 ; i < VertexCount ; i++){
		parentNode[i].k = 0;
		for(j = i ; parentNode[j].parentIndex != -1;j = parentNode[j].parentIndex){
			parentNode[i].k++;
		}
	}
}

凸凹表示法输出双亲表示法的树

要求要一棵树一棵树地输出，这里就用到了递归

  • 一棵树一棵树地输出，本质上就是由一个结点去找它的孩子结点，找到以后输出，接着由这个孩子结点去找它的孩子结点进行输出

  • 向函数中传入一个顶点A，如果这个顶点是根节点，则直接输出

  • 如果不是根节点，则遍历所有的顶点，找到双亲结点为A的顶点，根据这个顶点的层数k输出相应数量的tab，接着将这个顶点作为参数进行递归，去找这个顶点的其他孩子

void printParentTree(int v){
	if(v == 0){
		printf("%d\n",parentNode[v].Vname);
	}
	int i,j;
	for(i = 0 ; i < VertexCount ; i++){
		if(parentNode[i].parentIndex == v){
			for(j = 0 ; j < parentNode[i].k ; j++){
				printf("\t");
			}
			printf("%d\n",parentNode[i].Vname);	
			printParentTree(i);
		}
	}
}

构建孩子兄弟二叉树表示

5、依据前面双亲表示法中的节点存储顺序，构建孩子兄弟法的二叉树表示

算法描述：

从root开始，依此构建孩子兄弟法。

  • 构建结点

    struct BrotherChildTree{
	int Vname;
	BrotherChildTree *firstchild;
	BrotherChildTree *nextsibling;
};

  • 思路：遍历每个结点，分别进行找孩子和找兄弟的操作

  • 遍历结点——递归

  • 找孩子——传入一个结点A，根据双亲表示法，循环遍历每个结点，找到双亲结点为A的结点，新建一个结点P并分配空间，Vname为找到的这个结点的Vname，修改A的孩子指针域指向这个新结点P，新结点的两个指针域全部置空，break结束循环不再往下找孩子，将新结点P传入这个函数进行递归

  • 找兄弟——传入一个结点A，根据双亲表示法，循环遍历A之后的结点，找到双亲节点与A相同的结点，新建一个结点P并分配空间，Vname为找到的这个结点的Vname，修改A的兄弟指针域指向这个新结点P，新结点的两个指针域全部置空，break结束循环不再往下找孩子，将新结点P传入这个函数进行递归

void buildBCTree(int index,BrotherChildTree *T){
	int tIndex;
	int i;
	//找孩子 
	for(i = 0 ; i < VertexCount ; i++){
		if(parentNode[i].parentIndex == index){
			BrotherChildTree *p = (BrotherChildTree*)malloc(sizeof(BrotherChildTree));
			p->Vname = parentNode[i].Vname;
			p->firstchild = NULL;
			p->nextsibling = NULL;
			T->firstchild = p;
			T->nextsibling = NULL;
			tIndex = i;	 
			break;
		}
	}
	if(T->firstchild != NULL){
		buildBCTree(tIndex,T->firstchild);
	}
	//找兄弟
	for(i = index+1 ; i < VertexCount ; i++){
		if(parentNode[i].parentIndex == parentNode[index].parentIndex){
			BrotherChildTree *p = (BrotherChildTree *)malloc(sizeof(BrotherChildTree));
			p->Vname = parentNode[i].Vname;
			p->firstchild = NULL;
			p->nextsibling = NULL;
			T->nextsibling = p;
			tIndex = i;
			break;
		}
	} 
	if(T->nextsibling != NULL){
		buildBCTree(tIndex,T->nextsibling);
	}
}

括号表示法输出孩子兄弟二叉树

  • 原本看到这里以为是要用到广义表输出二叉树，但是实验的时候老师好像还没讲到广义表，所以是真·括号表示法输出
  • 每一棵树按照（根，孩子，兄弟）的形式输出
  • 同样用递归
  • 每传入一个结点就输出一个括号和结点本身：（A
  • 当孩子结点不为空时递归传入孩子结点
  • 找完孩子以后找兄弟，当兄弟结点不为空时递归传入兄弟结点
  • 最后输出括号：）-----这个不是微笑的表情
  • 老师要求最后从一整个字符串数组中输出：
    • 在主函数定义一个char类型的字符串数组string，在调用函数的时候传进去
    • 使用strcat函数进行字符串的拼接：strcat(string,“要拼进去的字符串”)
    • 因为每个结点的Vname类型是int，用isoa()函数进行int类型到char*类型的转换，在此之前还要新建立一个字符串数组buf放置转换后的字符：isoa(要转换的int数据，buf，进制)
      • 这里有个小插曲，我一开始想着能不能直接把string放到buf的位置直接把转换后的数字放进数组里面，但是在另一个程序尝试了一下，发现如果执行多次isoa()函数，传进函数的那个字符串数组中的内容会被覆盖，所以还是老老实实再新建一个数组放好字符以后拼进主串再转换一个
      • 还有在设置buf的大小时，我不想浪费太多的空间，原本只想开一个长度为1的数组，但是在进行char buf[1] = " "的时候报错了，查了以后才知道数组的大小设置至少要比数组元素总和多1，因为数组最后还有个\0占位
void printBCTree(BrotherChildTree *root,char *string){
	strcat(string,"(");
	char buf[2]=" ";
	itoa(root->Vname,buf,10);
	strcat(string,buf);
	if(root->firstchild != NULL){
		strcat(string,",");
		printBCTree(root->firstchild,string);
	} 
	if(root->nextsibling != NULL){
		strcat(string,",");
   		printBCTree(root->nextsibling,string);
	}
	strcat(string,")");
}

源代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define N 100
struct Vertex{
	int Vname;
}; 
int VertexCount = 0;
Vertex VertexSet[N];

struct Edge{
	int v1;
	int v2;
};
int EdgeCount = 0;
Edge EdgeSet[N];
/
//加载数据
 
void loadDate(){
	FILE *fp;
	fp = fopen("TreeInput.txt","r");
	if(fp == NULL){
		printf("ERROR!");
	}
	fscanf(fp,"%d\n",&VertexCount);
	int i;
	for(i = 0 ; i < VertexCount ; i++){
		VertexSet[i].Vname = i+1;
	}
	while(!feof(fp)){
		fscanf(fp,"%d,%d\n",&EdgeSet[EdgeCount].v1,&EdgeSet[EdgeCount].v2);
		EdgeCount++;
	}
}
/
//打印读入的数据 

void printDate(){
	printf("VertextCount is %d\n",VertexCount); 
	int i;
	for(i = 0 ; i < EdgeCount ; i++){
		printf("%d,%d\n",EdgeSet[i].v1,EdgeSet[i].v2);
	}
} 
/
//建立双亲表示法结点结构

struct parentTree{
	int Vname;
	int parentIndex;
	int k;
}; 
parentTree parentNode[N];

#define unknow -999
void BuildParentTree(){
	int i,j,k;
	for(i = 0 ; i < VertexCount ; i++){
		parentNode[i].Vname = VertexSet[i].Vname;
		parentNode[i].parentIndex = unknow;
	}
	parentNode[0].parentIndex = -1;
	for(i = 0 ; i < VertexCount ; i++){
		for(j = 1 ; j < VertexCount ; j++){
			for(k = 0 ; k < EdgeCount ; k++){
				if(	
					(EdgeSet[k].v1 == parentNode[i].Vname&&
					 EdgeSet[k].v2 == parentNode[j].Vname&&
					 parentNode[i].parentIndex != unknow&&
					 parentNode[j].parentIndex == unknow) 
					||
					(EdgeSet[k].v1 == parentNode[j].Vname&&
					 EdgeSet[k].v2 == parentNode[i].Vname&&
					 parentNode[i].parentIndex != unknow&&
					 parentNode[j].parentIndex == unknow)
				){
					parentNode[j].parentIndex = i;		
				}
			}
		}
	}
	//
	//求层数
	/
	for(i = 0 ; i < VertexCount ; i++){
		parentNode[i].k = 0;
		for(j = i ; parentNode[j].parentIndex != -1;j = parentNode[j].parentIndex){
			parentNode[i].k++;
		}
	}
}
//
//凸凹表示法输出 
/
void printParentTree(int v){
	if(v == 0){
		printf("%d\n",parentNode[v].Vname);
	}
	int i,j;
	for(i = 0 ; i < VertexCount ; i++){
		if(parentNode[i].parentIndex == v){
			for(j = 0 ; j < parentNode[i].k ; j++){
				printf("\t");
			}
			printf("%d\n",parentNode[i].Vname);	
			printParentTree(i);
		}
	}
}

//
//孩子兄弟表示法树的建立
/
struct BrotherChildTree{
	int Vname;
	BrotherChildTree *firstchild;
	BrotherChildTree *nextsibling;
}; 
void buildBCTree(int index,BrotherChildTree *T){
	int tIndex;
	int i;
	//找孩子 
	for(i = 0 ; i < VertexCount ; i++){
		if(parentNode[i].parentIndex == index){
			BrotherChildTree *p = (BrotherChildTree*)malloc(sizeof(BrotherChildTree));
			p->Vname = parentNode[i].Vname;
			p->firstchild = NULL;
			p->nextsibling = NULL;
			T->firstchild = p;
			T->nextsibling = NULL;
			tIndex = i;	 
			break;
		}
	}
	if(T->firstchild != NULL){
		buildBCTree(tIndex,T->firstchild);
	}
	//找兄弟
	for(i = index+1 ; i < VertexCount ; i++){
		if(parentNode[i].parentIndex == parentNode[index].parentIndex){
			BrotherChildTree *p = (BrotherChildTree *)malloc(sizeof(BrotherChildTree));
			p->Vname = parentNode[i].Vname;
			p->firstchild = NULL;
			p->nextsibling = NULL;
			T->nextsibling = p;
			tIndex = i;
			break;
		}
	} 
	if(T->nextsibling != NULL){
		buildBCTree(tIndex,T->nextsibling);
	}
}

//括号表示法输出 
///
void printBCTree(BrotherChildTree *root,char *string){
	strcat(string,"(");
	char buf[2]=" ";
	itoa(root->Vname,buf,10);
	strcat(string,buf);
	if(root->firstchild != NULL){
		strcat(string,",");
		printBCTree(root->firstchild,string);
	} 
	if(root->nextsibling != NULL){
		strcat(string,",");
   		printBCTree(root->nextsibling,string);
	}
	strcat(string,")");
}
int main(){
	loadDate();
	BuildParentTree();
    printParentTree(0);
	BrotherChildTree *root = 
	(BrotherChildTree *)malloc(sizeof(BrotherChildTree));
	root->Vname = parentNode[0].Vname;
	root->firstchild = NULL;
	root->nextsibling = NULL;
	buildBCTree(0,root);
	char string[1000] = " ";
	printBCTree(root,string);
	printf("%s",string);
	
}

在这里插入图片描述

leeprprprpr
关注
  • 16
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生成树实验
马赛克的博客
01-15 2829
目录 1容错实验 1.1实验内容 1.2实验原理 1.3关键命令 1.4配置过程 2负载均衡实验 2.1实验内容 2.2实验原理 2.3 配置过程 生成树协议用于在一个存再用于路径的以太网中为终端之间构建没有环路的交换路径。由于可以基于VLAN构建生成树，因此可以通过网络设计和生成树协议同时实现容错和负载均衡功能 1容错实验 1.1实验内容 构建如下图...
数据结构与算法-实验2 树的二叉链表表示及其遍历
加载中.......
01-13 1852
基本任务：用二叉链表存储结构表示下图所示二叉树， 并用递归方法输出三种遍历结果。 修改数节点值的数据类型及visit函数后，可以正常输出 进阶任务： 1，计算输出所建树的高度 2，用非递归算法实现中序遍历 3，实现层次遍历，提示见后面。 4，用顺序存储表示，并进行层次遍历、先序、中序和后续遍历 5，用非递归算法实现先序遍历、后续遍历
树的存储结构：双亲表示法、孩子表示法、孩子兄弟法
wmy0217_的博客
02-05 8571
文章目录双亲表示法孩子表示法孩子兄弟法 双亲表示法 实现：定义结构数组存放树的结点，每个结点包含两个域： 数据域：存放结点本身信息 双亲域：指示本结点的双亲结点在数组中的位置 结点结构： 结点类型定义： typedef struct PTNode {//结点类型定义 TElemType data; int parent; //双亲位置域 }PTNode; 另外，用 r 存储根结点的下...
树的三种表示法：双亲表示法、孩子表示法、孩子兄弟表示法
热门推荐
Huberyxiao的博客
03-25 2万+
抽象数据类型： 树的存储结构： 利用顺序存储和链式存储的特点，完全可以实现对树的存储结构的表示。介绍三种不同的表示法：双亲表示法、孩子表示法、孩子兄弟表示法。 1.双亲表示法 我们假设以一段连续空间存储树的结点，同时在每个结点中，附设一个指示器指示其双亲结点到链表中的位置。也就是说，每个结点除了直到自己是谁外，还要直到自己的双亲在哪里。如图： 其中data就是数据域，存储结点的信息。而paren...
数据结构c语言——树的三种存储结构（双亲表示法、孩子表示法、兄弟表示法）
girls的博客
06-20 1万+
在大量的应用中，人们曾使用多种形式的存储结构来表示树。这里,我们介绍3种常用的链表结构。 1.双亲表示法： 假设以一组连续空间存储树的结点，同时在每个结点中附设一个指示器指示其双亲结点在链表中的位置,其形式说明如下: 例如，图6.13展示一棵树及其双亲表示的存储结构。 这种存储结构利用了每个结点(除根以外)只有惟一的双亲的性质。PARENT(T,x)操作可以在常量时间内实现。反复调用PARENT操作，直到遇见无双亲的结点时，便找到了树的根,这就是ROOT(x)操作的执行过程。但是，在这种表示法中,求结点
数据结构试验树----谁要下载啊
06-18
先创建一棵树。。用递归的方法先序遍历一个二叉树。。。用非递归的方法中序遍历一个二叉树。。。用递归的方法后序遍历一个二叉树
数据结构实验三哈夫曼树实验报告.pdf
09-23
本实验报告主要探讨了如何构建哈夫曼树以及如何利用哈夫曼树进行编码和解码。 一、哈夫曼树的构建 哈夫曼树的构建过程通常分为两个步骤：首先，根据给定的权值创建一系列的叶子节点；其次，通过不断地合并权值最小...
决策树实验报告 代码大全
10-18
本实验报告主要探讨了决策树算法，特别是ID3算法及其原理。 首先，ID3算法是基于信息熵和信息增益的概念来构建决策树的。信息熵是用来衡量数据集的纯度或不确定性，熵值越小，表示分类的确定性越高。熵的计算公式为...
华东理工数据结构实验-树
weixin_56213139的博客
06-21 709
选取了数据结构中四个有关树的实验
第五十天 第十一章：图论part01 图论理论基础 深搜理论基础 98. 所有可达路径 广搜理论基础
最新发布
m0_69189584的博客
07-25 563
bfs是先把本节点所连接的所有节点遍历一遍，走到下一个节点的时候，再把连接节点的所有节点遍历一遍，搜索方向更像是广度，四面八方的搜索过程。注意图的输入形式，这里图用二维数组graph[s][t]表示，其中s,t表示s,t两点之间是否相连，相连赋值为1，不然为0。dfs是可一个方向去搜，不到黄河不回头，直到遇到绝境了，搜不下去了，再换方向（换方向的过程就涉及到了回溯）。了解邻接矩阵(*)，度，邻接表（数组+链表）等 遍历顺序：深搜加广搜。后面深搜的方法和回溯三部曲几乎一样。
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 393
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 244
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
java算法原理
jylee的博客
07-25 829
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
c语言（7.23）
fhgfyrsg的博客
07-23 700
【代码】c语言（7.23）
EXT4 数据结构
弥川的博客
07-25 358
结构 ext4_inode 实际使用的超出最初 128 字节 ext2 inode 的字节数记录在每个 inode 的 i_extra_isize 字段中，这使得结构 ext4_inode 可以在新内核中增长，而无需升级所有磁盘上的 inode。ext4 开始，flex_bg 中几个块组被捆绑在一起作为一个 逻辑块组，bitmap 空间和 inode Table 空间 flex_bg 的第一个块组被扩展为包括位图以及 flex_bg 中所有其他块组的 inode 表。没有 inode 0。
数据结构（3）（顺序栈）
qq_54094530的博客
07-25 552
栈是限定仅在栈顶进行插入和删除操作的线性表，在操作的时候，只允许栈顶改变不允许栈底改变，具有后进先出的特征。
数据结构前言
weixin_67466860的博客
07-25 1064
主要了解学习数据结构之前所需要了解的知识
matlab决策树实验
08-13
决策树是一种通过树状图的方式表示决策过程的机器学习模型，它通过对样本数据进行分类和预测来帮助决策。 在Matlab中，使用decisiontree模块可以方便地构建和实验决策树模型。首先，需要准备好训练数据集和测试数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值