47 树Tree

最新推荐文章于 2024-07-25 15:54:48 发布
最新推荐文章于 2024-07-25 15:54:48 发布
阅读量82 收藏
点赞数
分类专栏： 笔记 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36643203/article/details/120390095
版权
二叉树性质
性质1: 在二叉树的第i层上至多有2i-1个结点（i>0）
性质2: 深度为k的二叉树至多有2k-1个结点（k>0）
性质3: 对于任何一棵二叉树，若2度的结点数有n2个，则叶子数（n0）必定为n2＋1 （即n0=n2+1）
满二叉树：一棵深度为k 且有2k -1个结点的二叉树。 （特点：每层都“充满”了结点）

1 树的表示法

1 二叉链

// 二叉链表示法
/*
typedef struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
*/

struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
};
typedef struct BiTNode BiTNode;
typedef struct BiTNode* BiTree;
void main01() {
	BiTNode t1, t2, t3, t4, t5;
	t1.data = 1;
	t2.data = 2;
	t3.data = 3;
	t4.data = 4;
	t5.data = 5;

	// 建立关系
	t1.lchild = &t2;
	t1.rchild = &t3;
	t2.lchild = &t4;
	t3.lchild = &t5;

	// 树的遍历
}
void main02() {
	BiTNode* p1, * p2, * p3, * p4, * p5;
	p1 = (BiTNode*)malloc(sizeof(BiTNode));
	p2 = (BiTNode*)malloc(sizeof(BiTNode));
	p3 = (BiTNode*)malloc(sizeof(BiTNode));
	p4 = (BiTNode*)malloc(sizeof(BiTNode));
	p5 = (BiTNode*)malloc(sizeof(BiTNode));

	p1->data = 1;
	p2->data = 2;
	p3->data = 3;
	p4->data = 4;
	p5->data = 5;


	// 建立关系
	p1->lchild = p2;
	p1->rchild = p3;
	p2->lchild = p4;
	p3->lchild = p5;

	// 树的遍历
}

2 三叉链

// 三叉链表
typedef struct TriTNode {
	int data;
	struct TriTNode* lchild, * rchild;
	struct TriTNode* parent;
}TriTNode, *TriTree;

3 双亲链表

// 双亲链表
#define MAX_TREE_SIZE 100
typedef	struct BPTNode {
	int data;
	int parentPosition;	// 指向双亲的指针		// 数组下标
	char LRTag;	// 左右孩子标志域
}BPTNode;

typedef struct BPTree {
	BPTNode nodes[100];//因为节点之间是分散的，需要把节点存储到数组中
	int num_node;	// 节点数目
	int root;	// 根节点的位置// 注意此域存储的是父亲节点在数组的下标
}BPTree;

void main() {
	BPTree tree;
	// 根节点
	tree.nodes[0].parentPosition = 1000;
	
	// B节点
	tree.nodes[1].parentPosition = 0;
	tree.nodes[1].data = 'B';
	tree.nodes[1].LRTag = 1;

	// C节点
	tree.nodes[2].parentPosition = 0;
	tree.nodes[2].data = 'C';
	tree.nodes[2].LRTag = 2;
}

2 树的遍历

1 先序遍历

先遍历根，再遍历左子树，再遍历右子树

2 中序遍历

先遍历左子树，再遍历根，再遍历右子树

3 后序遍历

先遍历左子树，再遍历右子树，再遍历根

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tHzRJHoh-1632112771959)(C:\Users\302\AppData\Roaming\Typora\typora-user-images\image-20210907101926430.png)]

#include<stdlib.h>
#include<stdio.h>
#include<string.h>


// 二叉链表示法
/*
typedef struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
*/

struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
};
typedef struct BiTNode BiTNode;
typedef struct BiTNode* BiTree;

void preOreder(BiTNode *root) {
	if (root == NULL) {
		return;
	}
	printf("%d ", root->data);
	// 遍历左子树
	preOreder(root->lchild);

	// 遍历右子树
	preOreder(root->rchild);

}

void midOreder(BiTNode* root) {
	if (root == NULL) {
		return;
	}

	// 遍历左子树
	midOreder(root->lchild);

	printf("%d ", root->data);

	// 遍历右子树
	midOreder(root->rchild);
}

void rearOreder(BiTNode* root) {
	if (root == NULL) {
		return;
	}

	// 遍历左子树
	rearOreder(root->lchild);
	// 遍历右子树
	rearOreder(root->rchild);

	printf("%d ", root->data);

	
}

void main() {
	BiTNode t1, t2, t3, t4, t5;
	memset(&t1, 0, sizeof(BiTNode));
	memset(&t2, 0, sizeof(BiTNode));
	memset(&t3, 0, sizeof(BiTNode));
	memset(&t4, 0, sizeof(BiTNode));
	memset(&t5, 0, sizeof(BiTNode));
	t1.data = 1;
	t2.data = 2;
	t3.data = 3;
	t4.data = 4;
	t5.data = 5;
	// 建立关系
	t1.lchild = &t2;
	t1.rchild = &t3;
	t2.lchild = &t4;
	t3.lchild = &t5;

	// 树的遍历
	printf("先序遍历：\n");
	preOreder(&t1);
	printf("\n");

	printf("中序遍历：\n");
	midOreder(&t1);
	printf("\n");

	printf("后序遍历：\n");
	rearOreder(&t1);
 }

结果

先序遍历：
1 2 4 3 5
中序遍历：
4 2 1 5 3
后序遍历：
4 2 5 3 1

4 树的非递归遍历(中序遍历)

栈模型

C++版本

#include<iostream>
using namespace std;
#include<stack>

/*
步骤1：
如果结点有左子树，该结点入栈；
如果结点没有左子树，访问该结点；
步骤2：
如果结点有右子树，重复步骤1；
如果结点没有右子树（结点访问完毕），根据栈顶指示回退，访问栈顶元素，并访问右子树，重复步骤1
如果栈为空，表示遍历结束。
*/

typedef struct BiTNode {
	int data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode,*BiTree;

// 找到中序遍历起点
BiTNode *goLeft(BiTNode* T, stack<BiTNode*>& s) {
	if (T == NULL) {
		return NULL;
	}
	// 判断T有无左子树，没有返回，若有继续
	while (T->lchild != NULL) {
		s.push(T);
		T = T->lchild;
	}
	return T;
}

void InOrder(BiTNode* T) {
	//
	BiTNode* t = NULL;
	stack<BiTNode*> s;

	t = goLeft(T, s);

	while (t) {
		printf("%d ", t->data);
		//如果t有右子树 重复步骤1
		if (t->rchild != NULL) {
			t = goLeft(t->rchild, s);	// 右子树中中序遍历起点
		}
		// 如果t没有右子树 根据栈顶指示 回退
		else if (!s.empty()) {
			t = s.top();
			s.pop();
		}
		// 如果没有右子树且栈为空
		else {
			t = NULL;
		}
	}
}

void midOrder(BiTNode* T) {
	if (T == NULL) {
		return;
	}
	// 遍历左子树
	midOrder(T->lchild);
	printf("%d ", T->data);
	// 遍历右子树
	midOrder(T->rchild);
}

void main() {
	BiTNode t1, t2, t3, t4, t5;
	memset(&t1, 0, sizeof(BiTNode));
	memset(&t2, 0, sizeof(BiTNode));
	memset(&t3, 0, sizeof(BiTNode));
	memset(&t4, 0, sizeof(BiTNode));
	memset(&t5, 0, sizeof(BiTNode));

	t1.data = 1;
	t2.data = 2;
	t3.data = 3;
	t4.data = 4;
	t5.data = 5;

	t1.lchild = &t2;
	t1.rchild = &t3;
	t2.lchild = &t4;
	t3.lchild = &t5;

	printf("中序遍历:\n");
	midOrder(&t1);
	cout << endl;

	cout << "中序遍历（非递归）:\n";
	InOrder(&t1);
	cout << endl;

}

结果

中序遍历:
4 2 1 5 3
中序遍历（非递归）:
4 2 1 5 3

C语言版本

#include<stdio.h>
#include<stdlib.h>
#include"linkstack.h"
/*
步骤1：
如果结点有左子树，该结点入栈；
如果结点没有左子树，访问该结点；
步骤2：
如果结点有右子树，重复步骤1；
如果结点没有右子树（结点访问完毕），根据栈顶指示回退，访问栈顶元素，并访问右子树，重复步骤1
如果栈为空，表示遍历结束。
*/

typedef struct BiTNode {
	int data;
	struct BiTNode* lchild;
	struct BiTNode* rchild;
}BiTNode, * BiTree;

// 找到中序遍历起点
BiTNode* goLeft(BiTNode* T, LinkStack* s) {
	if (T == NULL) {
		return NULL;
	}
	// 判断T有无左子树，没有返回，若有继续
	while (T->lchild != NULL) {
		LinkStack_Push(s, (void*)T);
		T = T->lchild;
	}
	return T;
}

void InOrder(BiTNode* T) {
	// 
	BiTNode* t = NULL;
	//stack<BiTNode*> s;
	LinkStack* s = LinkStack_Create();

	t = goLeft(T, s);

	while (t) {
		printf("%d ", t->data);
		//如果t有右子树 重复步骤1
		if (t->rchild != NULL) {
			t = goLeft(t->rchild, s);	// 右子树中中序遍历起点
		}
		// 如果t没有右子树 根据栈顶指示 回退
		//else if (!s.empty()) {
		else if(LinkStack_Size(s)>0){
			/*t = s.top();
			s.pop();*/
			t = (BiTNode*)LinkStack_Pop(s);
		}
		// 如果没有右子树且栈为空
		else {
			t = NULL;
		}
	}
}

void midOrder(BiTNode* T) {
	if (T == NULL) {
		return;
	}
	// 遍历左子树
	midOrder(T->lchild);
	printf("%d ", T->data);
	// 遍历右子树
	midOrder(T->rchild);
}

void main() {
	BiTNode t1, t2, t3, t4, t5;
	memset(&t1, 0, sizeof(BiTNode));
	memset(&t2, 0, sizeof(BiTNode));
	memset(&t3, 0, sizeof(BiTNode));
	memset(&t4, 0, sizeof(BiTNode));
	memset(&t5, 0, sizeof(BiTNode));

	t1.data = 1;
	t2.data = 2;
	t3.data = 3;
	t4.data = 4;
	t5.data = 5;

	t1.lchild = &t2;
	t1.rchild = &t3;
	t2.lchild = &t4;
	t3.lchild = &t5;

	printf("中序遍历:\n");
	midOrder(&t1);
	printf("\n");

	printf("中序遍历（非递归）:\n");
	InOrder(&t1);
	printf("\n");

}

结果

中序遍历:
4 2 1 5 3
中序遍历（非递归）:
4 2 1 5 3

3 #法创建树

#define _CRT_SECURE_NO_WARNINGS
#include<stdlib.h>
#include<stdio.h>
#include<string.h>


// 二叉链表示法
/*
typedef struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
*/

struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
};
typedef struct BiTNode BiTNode;
typedef struct BiTNode* BiTree;


void InOrder(BiTNode* T) {
	if (T == NULL) {
		return;
	}
	InOrder(T->lchild);
	printf("%d ", T->data);
	InOrder(T->rchild);
}

// 销毁树时用后续方法销毁
void FreeTree(BiTNode* T) {
	if (T == NULL) {
		return;
	}
	if (T->lchild != NULL) {
		FreeTree(T->lchild);
		T->lchild = NULL;
	}
	if (T->rchild != NULL) {
		FreeTree(T->rchild);
		T->rchild = NULL;
	}
	if (T != NULL) {
		free(T);
		T = NULL;
	}
}


// #法创建树 先序方法建立二叉链表
BiTNode* BiTree_Create() {
	BiTNode* tmp = NULL;
	char ch;
	scanf("%c", &ch);
	if (ch == '#') {
		return NULL;
	}
	else {
		tmp = (BiTNode*)malloc(sizeof(BiTNode));
		if (tmp == NULL) {
			return NULL;
		}
		tmp->data = ch;	//生成节点
		tmp->lchild = BiTree_Create();
		tmp->rchild = BiTree_Create();
	}
	return tmp;
}

void main() {
	int nCount = 0, depthval = 0;
	BiTNode* my = BiTree_Create();

	printf("\n 中序遍历 \n");
	InOrder(my);
	printf("\n");

	FreeTree(my);
}

结果

1#23###

 中序遍历
49 51 50

4 二叉线索树

希望可以像链表一样能够遍历树

结论：线索化过程就是在遍历过程（假设是中序遍历）中修改空指针的过程：

将空的lchild改为结点的直接前驱；

将空的rchild改为结点的直接后继。

可以把二叉树中序遍历结果存到链表里，再进行遍历，实现同样的效果

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define OK 1
#define ERROR -1
#define OVERFLOW 0
typedef enum{Link, Thread} PointerTag;
typedef char TElemType;
typedef int Status;

typedef struct _tag_BiThrNode {
	TElemType data;
	struct _tag_BiThrNode* lchild, * rchild;
	PointerTag LTag;
	PointerTag RTag;
}BiThrNode, * BiThrTree;


TElemType Nil = '#';

Status visit(TElemType e) {
	printf("%c", e);
	return OK;
}

// 按前序输入二叉线索树中节点的值，构造二叉	线索树T
// 0(整型)/空格（字符型）表示空节点
// 1##
Status CreateBiThrTree(BiThrTree* T) {
	TElemType h;
	scanf("%c", &h);

	if (h == Nil)
		* T = NULL;
	else {
		*T = (BiThrTree)malloc(sizeof(BiThrNode));
		if (!*T)
			exit(OVERFLOW);
		(*T)->data = h;	//生成根节点(前序)
		CreateBiThrTree(&(*T)->lchild);	//递归构造左子树
		if ((*T)->lchild)	//有左孩子
			(*T)->LTag = Link;
		CreateBiThrTree(&(*T)->rchild);	//递归构造右子树
		if ((*T)->rchild)	//有有孩子
			(*T)->RTag = Link;
	}
	return OK;
}

BiThrTree pre;	// 全局变量，始终指向刚刚访问过的节点
// 中序遍历进行中序线索化
void InThreading(BiThrTree p) {
	if (p) {
		InThreading(p->lchild);	// 递归左子树线索化
		if (!p->lchild)	// 没有左孩子
		{
			p->LTag = Thread;	//前驱线索
			p->lchild = pre; //左孩子指针指向前驱
		}
		if (!pre->rchild)	// 前驱没有右孩子
		{
			pre->RTag = Thread;	//后驱线索
			pre->rchild = p; //前驱右孩子指针指向后驱（当前节点p）
		}
		pre = p;//保持pre指向p的前驱
		InThreading(p->rchild);//递归右子树线索化
	}
}


/* 中序遍历二叉树T，并将其中序线索化，Thrt指向头节点*/
Status InOrderThreading(BiThrTree* Thrt, BiThrTree T) {
	*Thrt = (BiThrTree)malloc(sizeof(BiThrNode));
	if (!*Thrt)
		exit(OVERFLOW);
	(*Thrt)->LTag = Link;//建头节点
	(*Thrt)->RTag = Thread;
	(*Thrt)->rchild = (*Thrt);	//右指针回指
	if (!T)//若二叉树为空，则左指针回指
		(*Thrt)->lchild = *Thrt;
	else {
		(*Thrt)->lchild = T;
		pre = (*Thrt);
		InThreading(T);	//中序遍历进行中序线索化
		pre->rchild = *Thrt;
		pre->RTag = Thread;//最后一个节点线索化
		(*Thrt)->rchild = pre;
	}
	return OK;
}


// 中序遍历二叉线索树T（头节点）的非递归算法
Status InOrderTraverse_Thr(BiThrTree T) {
	BiThrTree p;
	p = T->lchild;	// p指向根节点
	while (p != T) {
		// 空树或遍历结束 p==T
		while (p->LTag == Link)p = p->lchild;
		if (!visit(p->data))	//访问其左子树为空的节点
			return ERROR;
		while (p->RTag == Thread && p->rchild != T) {
			p = p->rchild;
			visit(p->data);	//访问后继节点
		}
		p = p->rchild;
	}
	return OK;
}


int main() {
	BiThrTree H, T;
	printf("请按先序输入二叉树(如'ABDH##I##EJ###CF##G##')");
	CreateBiThrTree(&T);	//按先序产生二叉树
	InOrderThreading(&H, T);	// 中序遍历；并中序线索化二叉树
	printf("中序遍历(输出)二叉线索树:\n");
	InOrderTraverse_Thr(H);	//中序遍历输出二叉线索树
	printf("\n");
}

结果

请按先序输入二叉树(如'ABDH##I##EJ###CF##G##')ABDH##I##EJ###CF##G##
中序遍历(输出)二叉线索树:
HDIBJEAFCG

5 霍夫曼树

霍夫曼树

1.给定n个数值{ v1, v2, …, vn}

2.根据这n个数值构造二叉树集合F

F = { T1, T2, …, Tn}

Ti的数据域为vi，左右子树为空

3.在F中选取两棵根结点的值最小的树作为左右子树构造一棵新的二叉树，这棵二叉树的根结点中的值为左右子树根结点中的值之和

4.在F中删除这两棵子树，并将构造的新二叉树加入F中

5.重复3和4，直到F中只剩下一个树为止。这棵树即霍夫曼树

霍夫曼树是一种特殊的二叉树

霍夫曼树应用于信息编码和数据压缩领域

霍夫曼树是现代压缩算法的基础

案例1 计算叶子节点的个数

#include<stdlib.h>
#include<stdio.h>
#include<string.h>


// 二叉链表示法
/*
typedef struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
*/

struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
};
typedef struct BiTNode BiTNode;
typedef struct BiTNode* BiTree;

int sum = 0;

void coutLeaf(BiTNode* T) {
	if (T != NULL) {
		if (T->lchild == NULL && T->rchild == NULL) {
			sum++;
		}
		if (T->lchild) {
			coutLeaf(T->lchild);
		}
		if (T->rchild) {
			coutLeaf(T->rchild);
		}
	}
}

// 采用指针的方式，不使用全局变量
void coutLeaf2(BiTNode* T, int *sum) {
    // 采用前序求叶子节点，中序求叶子节点，后序求叶子节点结果一样
	if (T != NULL) {
		if (T->lchild == NULL && T->rchild == NULL) {
			(*sum)++;	// ++的优先级高
		}
		if (T->lchild) {
			coutLeaf2(T->lchild, sum);
		}
        /*
        if (T->lchild == NULL && T->rchild == NULL) {
			(*sum)++;	// ++的优先级高
		}
		*/
		if (T->rchild) {
			coutLeaf2(T->rchild, sum);
		}
        /*
        if (T->lchild == NULL && T->rchild == NULL) {
			(*sum)++;	// ++的优先级高
		}
		*/
	}
}

void main() {
	BiTNode t1, t2, t3, t4, t5;
	memset(&t1, 0, sizeof(BiTNode));
	memset(&t2, 0, sizeof(BiTNode));
	memset(&t3, 0, sizeof(BiTNode));
	memset(&t4, 0, sizeof(BiTNode));
	memset(&t5, 0, sizeof(BiTNode));
	t1.data = 1;
	t2.data = 2;
	t3.data = 3;
	t4.data = 4;
	t5.data = 5;
	// 建立关系
	t1.lchild = &t2;
	t1.rchild = &t3;
	t2.lchild = &t4;
	t3.lchild = &t5;

	coutLeaf(&t1);
	printf("sum:%d \n", sum);
	{
		int mysum = 0;
		coutLeaf2(&t1, &mysum);
		printf("sum:%d \n", mysum);
	}
	
 }

结果

sum:2
sum:2

案例2 求树的深度

#include<stdlib.h>
#include<stdio.h>
#include<string.h>


// 二叉链表示法
/*
typedef struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
*/

struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
};
typedef struct BiTNode BiTNode;
typedef struct BiTNode* BiTree;

int Depth(BiTNode *T) {
	int depthleft = 0;
	int depthright = 0;
	int depthval = 0;

	if (T == NULL) {
		depthval = 0;
		return depthval;
	}
	// 求左子树的高度
	depthleft = Depth(T->lchild);
	// 求右子树的高度
	depthright = Depth(T->rchild);
	
	// +1
	depthval = 1 + (depthleft > depthright ? depthleft : depthright);
	return depthval;
}

void main() {
	BiTNode t1, t2, t3, t4, t5;
	memset(&t1, 0, sizeof(BiTNode));
	memset(&t2, 0, sizeof(BiTNode));
	memset(&t3, 0, sizeof(BiTNode));
	memset(&t4, 0, sizeof(BiTNode));
	memset(&t5, 0, sizeof(BiTNode));
	t1.data = 1;
	t2.data = 2;
	t3.data = 3;
	t4.data = 4;
	t5.data = 5;
	// 建立关系
	t1.lchild = &t2;
	t1.rchild = &t3;
	t2.lchild = &t4;
	t3.lchild = &t5;

	printf("%d \n",Depth(&t1));
}

结果

3

案例3 copy Tree

#include<stdlib.h>
#include<stdio.h>
#include<string.h>


// 二叉链表示法
/*
typedef struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
}BiTNode, * BiTree;
*/

struct BiTNode {
	int data;
	struct BiTNode* lchild, * rchild;
};
typedef struct BiTNode BiTNode;
typedef struct BiTNode* BiTree;

void midOreder(BiTNode* root) {
	if (root == NULL) {
		return;
	}

	// 遍历左子树
	midOreder(root->lchild);

	printf("%d ", root->data);

	// 遍历右子树
	midOreder(root->rchild);
}

BiTNode* CopyTree(BiTNode *T) {
	BiTNode* newNode = NULL;
	BiTNode* newLp = NULL;
	BiTNode* newRp = NULL;
	if (T == NULL) {
		return NULL;
	}
	// copy 左子树
	if (T->lchild != NULL) {
		newLp = CopyTree(T->lchild);	// copy左子树
	}
	else {
		newLp = NULL;
	}

	// copy 右子树
	if (T->rchild != NULL) {
		newRp = CopyTree(T->rchild);
	}
	else {
		newRp = NULL;
	}

	// malloc根节点
	newNode = (BiTNode*)malloc(sizeof(BiTNode));
	if (newNode == NULL) {
		return NULL;
	}
	newNode->lchild = newLp;
	newNode->rchild = newRp;
	newNode->data = T->data;

	return newNode;
}

void main() {
	BiTNode t1, t2, t3, t4, t5;
	memset(&t1, 0, sizeof(BiTNode));
	memset(&t2, 0, sizeof(BiTNode));
	memset(&t3, 0, sizeof(BiTNode));
	memset(&t4, 0, sizeof(BiTNode));
	memset(&t5, 0, sizeof(BiTNode));
	t1.data = 1;
	t2.data = 2;
	t3.data = 3;
	t4.data = 4;
	t5.data = 5;
	// 建立关系
	t1.lchild = &t2;
	t1.rchild = &t3;
	t2.lchild = &t4;
	t3.lchild = &t5;
    
	printf("midOrder:\n");
	midOreder(&t1);
	printf("\n");

	{
		BiTNode* root = CopyTree(&t1);
		printf("copy midOrder:\n");
		midOreder(root);
		printf("\n");
	}

}

结果

midOrder:
4 2 1 5 3
copy midOrder:
4 2 1 5 3

确定树的方法：通过中序遍历和先序遍历可以确定一个树

​ 通过中序遍历和后序遍历可以确定一个树

HowDonew
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DecisionTree6.0.2.zip
11-19
标题“DecisionTree6.0.2.zip”暗示我们讨论的是一个关于决策树的软件或库的版本6.0.2，被压缩成ZIP文件格式。描述中的链接指向了一个CSDN博客文章，虽然具体内容未给出，但我们可以推测该文章可能详细介绍了如何...
always-treeshake-mui:有关如何使用next.js正确摇树Mui的示例
05-10
总是摇摇欲坠的梅始终使用Next.js进行TreeShake MUI吗？ 是的！ 您应该节省几千字节此处使用的示例是从，它显示了如何正确删除未使用的代码。有％的差异？ 不从模块导入多个导出时，Initial几乎相同。 包装前后...
47二叉树遍历一
qq_41627390的博客
08-16 88
数据结构：树(Tree)【详解】
热门推荐
UniqueUnit的博客
02-26 15万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
【tree】二叉查找树
厚积薄发者，轻舟万重山
06-12 386
二叉查找树的递归实现和非递归实现
tree 树结构 自己组装数据
b0303的博客
06-29 235
easyUI组装两级树结构 这是组装的方式： { "open": [ { "id": 46, "pName": "天天速冻间", "pPyName": "TTSDJ", "pNumber": "DS202009280046", "pCode": "0046", "projectendflag": "0", .
详解决策树 Decision Tree
Avery123123的博客
10-31 1264
详解决策树 Decision Tree 基本概念 特征选择 信息增益ID3 算法 信息增益率C4.5 算法 基尼值基尼指数CART 算法 剪枝预 剪枝预 后剪枝 多变量决策树 连续值处理 缺失值处理
Mobox-State-Tree
06-03
MobX-State-Tree（MST）是一个基于MobX的状态管理库，它通过结构化和类型化的状态树来管理应用状态。MST结合了MobX的响应式特性和Redux的不可变性，使得状态管理更加简洁和强大。 以下是对MobX-State-Tree的深入总结...
echarts，tree 图，节点收缩，option 配置即可
01-10
echarts tree目前只能用initialTreeDepth来控制显示的层数，不能逐个控制每个节点的收缩放开状态，很不方便。... 'symbolSize': 47, 'mcHereShow':true } series: [ { type: 'tree', data: [data], ...... }
基于B-树和B+树的使用：数据搜索和数据库索引的详细介绍
09-10
1. **B-树（Balanced Multiway Search Tree）** - 定义：B-树是一种自平衡的多路搜索树，每个节点可以有多个子节点。其主要特性包括： - 节点最多有m个子节点（m阶B-树）。 - 根节点如果不是叶子节点，至少有两...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 162
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 213
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 292
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 412
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 724
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 959
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
dab112的博客
07-24 1155
介绍了二叉搜索树的实现与模拟
数据结构：顺序表的实现
最新发布
2303_81073778的博客
07-25 184
3.test.c文件。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 456
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
hbuilderx圣诞树代码
12-06
以下是使用HBuilderX实现的圣诞树代码： ...<!... 圣诞树 ... background-color: #000;... .tree { ... .tree:before { ... .tree:after { ... .tree .star { ... .tree ul li:nth-child(47) { animation-delay: 9.2s; } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值