[c++] 树和二叉树

已于 2022-11-18 17:53:53 修改
阅读量1.1k 收藏 2
点赞数 1
文章标签： 数据结构 算法 c++
于 2022-11-17 09:39:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55878068/article/details/127897262
版权

目录

内容描述

1. 普通二叉树和线索二叉树

2. 霍夫曼树

3. 输入输出示例

程序代码

TreeNode.h

MyTree.h

Huffman.h

TreeNode.cpp

MyTree.cpp

Huffman.cpp

main.cpp

测试结果

内容描述

1. 普通二叉树和线索二叉树

实现树的节点 TreeNode（支持线索二叉树）和树 MyTree（支持线索二叉树），采用二叉链表存储，完成以下功能：

  • 树节点的初始化和销毁
  • 树初始化，初始化一棵空树
  • 树初始化，根据二叉树的先序序列，生成二叉树的二叉链表存储,使用 @ 表示 NULL
  • 树的复制构造函数,复制参数中的树
  • 树销毁，支持普通二叉树与线索二叉树
  • 先序遍历二叉树并打印，仅支持普通二叉树，不考虑线索化，对节点的访问操作为打印该节点
  • 中序遍历二叉树并打印，支持普通二叉树与线索二叉树，对节点的访问操作为打印该节点
  • 后序遍历二叉树并打印，仅支持普通二叉树，不考虑线索化，对节点的访问操作为打印该节点
  • 定位二叉树中的节点，在树中找到值为v的节点则返回该节点，否则返回 NULL，支持普通二叉树与线索二叉树
  • 计算二叉树的叶子结点数，仅支持普通二叉树，不考虑线索化
  • 计算二叉树的深度，仅支持普通二叉树，不考虑线索化
  • 当前树是否是线索二叉树，是线索二叉树返回 true，否则 false
  • 为二叉树生成中序线索二叉树
  • 寻找中序线索二叉树中某节点的前驱节点，仅支持线索二叉树
  • 寻找中序线索二叉树中某节点的后继节点，仅支持线索二叉树

2. 霍夫曼树

实现霍夫曼树 HuffmanTree，输出对应的霍夫曼编码，具体完成以下功能：

  • 树初始化 HuffmanTree，根据输入创建一棵霍夫曼树，第一个参数为节点个数，第二个参数为节点数组，节点值为节点重要度，越大代表越重要，要求树构建时偏小的值放入左子树，偏大的值放入右子树
  • 树销毁
  • 输出霍夫曼编码，格式：节点值：编码，节点排序递减
  • 其他必要的函数

3. 输入输出示例

MyTree myTree("ABC@@DE@G@@F@@@");
myTree.preOrderTraverse();//ABCDEGF
cout << endl;
myTree.inOrderTraverse();//CBEGDFA
cout << endl;
myTree.postOrderTraverse();//CGEFDBA
cout << endl;
cout << myTree.countLeaf() << endl;//3
cout << myTree.countHeight() << endl;//5
 
MyTree myThreadedTree(myTree);
cout << myThreadedTree.isThreadedTree() << endl;//0
myThreadedTree.inOrderThreading();
cout << myThreadedTree.isThreadedTree() << endl;//1
myThreadedTree.inOrderTraverse();//CBEGDFA
cout << endl;
 
TreeNode n = myThreadedTree.locateNode('G');
myThreadedTree.preNode(n).printNode();//E
cout << endl;
myThreadedTree.nextNode(n).printNode();//D
 
cout << endl;	int v[] = {2,7,5,4};
HuffmanTree hTree(4, v);
hTree.printHuffmanCodes();
/*
7:0
5:10
4:111
2:110
*/

程序代码

TreeNode.h

#ifndef TREENODE_H
#define TREENODE_H

class TreeNode
{
public:
	char data;
	TreeNode* lchild, * rchild;
	bool ltag, rtag;

	TreeNode();
	~TreeNode();

	void printNode();
};

#endif

MyTree.h

#ifndef MyTree_H
#define MyTree_H
#include "TreeNode.h"

class MyTree {
private:
	TreeNode* treeNode;
	void preOrder(TreeNode*& tn, void(*pf)(TreeNode*& tn));
	void inOrder(TreeNode*& tn, void(*pf)(TreeNode*& tn));
	void postOrder(TreeNode*& tn, void(*pf)(TreeNode*& tn));
	void createTree(TreeNode*& tn, const char*& str);
	void createTree(TreeNode*& tn, const TreeNode* tn0);
	int Leaf(TreeNode*&& tn);
	int Height(TreeNode*&& tn);
	bool isThr(TreeNode*&& tn);
	void inOrderThr(TreeNode*& tn, TreeNode*&& pre);
	bool locate(char c, TreeNode* tn, TreeNode*& temp);

public:
	MyTree();
	MyTree(const char* str);
	MyTree(MyTree& mt);
	~MyTree();

	void preOrderTraverse();
	void inOrderTraverse();
	void postOrderTraverse();
	int countLeaf();
	int countHeight();
	bool isThreadedTree();
	void inOrderThreading();
	TreeNode locateNode(char c);
	TreeNode preNode(TreeNode tn);
	TreeNode nextNode(TreeNode tn);
};

#endif

Huffman.h

#ifndef HUFFMANTREE_H
#define HUFFMANTREE_H

class HuffmanTree {
private:
	typedef struct
	{
		int weight;   //结点的权值,为了方便直接用int
		int parent, lChild, rChild;  //左右孩子和双亲
	}HTNode,*HTree;
	HTree htree;
	int n;

	void select(int n, int& s1, int& s2);
public:
	HuffmanTree(int n, int w[]);
	~HuffmanTree();
	void printHuffmanCodes();
};

#endif

TreeNode.cpp

#include "TreeNode.h"
#include<bits/stdc++.h>

TreeNode::TreeNode()
{
	data = 0;
	lchild = nullptr;
	rchild = nullptr;
	ltag = 0;
	rtag = 0;
}

void TreeNode::printNode() {
	std::cout << data;
}

TreeNode::~TreeNode() {}

MyTree.cpp

#include "MyTree.h"
#include <bits/stdc++.h>

MyTree::MyTree() {
	treeNode = nullptr;
}

MyTree::MyTree(const char* str) {
	createTree(treeNode, str);
}

MyTree::MyTree(MyTree& mt) {
	createTree(treeNode, mt.treeNode);
	if (mt.isThreadedTree())
		inOrderThreading();
}

MyTree::~MyTree() {
	postOrder(treeNode, [](TreeNode*& tn)->void {delete tn; });
}

void MyTree::createTree(TreeNode*& tn, const char*& str)
{
	if (*str)
	{
		if (*str == '@')
		{
			tn = nullptr;
			return;
		}
		tn = new TreeNode;
		tn->data = *str;
		createTree(tn->lchild, ++str);
		createTree(tn->rchild, ++str);
	}
}

void MyTree::createTree(TreeNode*& tn, const TreeNode* tn0)
{
	if (tn0 == nullptr)
	{
		tn = nullptr;
		return;
	}
	tn = new TreeNode;
	tn->data = tn0->data;
	createTree(tn->lchild, tn0->lchild);
	createTree(tn->rchild, tn0->rchild);
}

void MyTree::preOrder(TreeNode*& tn, void(*pf)(TreeNode*& tn)) {
	if (tn == nullptr)return;
	(*pf)(tn);
	if (tn->ltag == 0)
		preOrder(tn->lchild, pf);
	if (tn->rtag == 0)
		preOrder(tn->rchild, pf);
}

void MyTree::inOrder(TreeNode*& tn, void(*pf)(TreeNode*& tn)) {
	if (tn == nullptr)return;
	if (tn->ltag == 0)
		inOrder(tn->lchild, pf);
	(*pf)(tn);
	if (tn->rtag == 0)
		inOrder(tn->rchild, pf);
}

void MyTree::postOrder(TreeNode*& tn, void(*pf)(TreeNode*& tn)) {
	if (tn == nullptr)return;
	if (tn->ltag == 0)
		postOrder(tn->lchild, pf);
	if (tn->rtag == 0)
		postOrder(tn->rchild, pf);
	(*pf)(tn);
}

void MyTree::preOrderTraverse() {
	preOrder(treeNode, [](TreeNode*& tn)->void {std::cout << tn->data; });
}

void MyTree::inOrderTraverse() {
	inOrder(treeNode, [](TreeNode*& tn)->void {std::cout << tn->data; });
}

void MyTree::postOrderTraverse() {
	postOrder(treeNode, [](TreeNode*& tn)->void {std::cout << tn->data; });
}

int MyTree::countLeaf() {
	return Leaf(std::move(treeNode));
}

int MyTree::Leaf(TreeNode*&& tn)
{
	if (tn == nullptr)return 0;
	else if ((tn->lchild == nullptr && tn->rchild == nullptr) || (tn->ltag == 1 && tn->rtag == 1))
		return 1;
	else if (tn->rchild == nullptr || tn->rtag == 1)return Leaf(std::move(tn->lchild));
	else if (tn->lchild == nullptr || tn->ltag == 1)return Leaf(std::move(tn->rchild));
	else return Leaf(std::move(tn->lchild)) + Leaf(std::move(tn->rchild));
}

int MyTree::countHeight() {
	return Height(std::move(treeNode));
}

int MyTree::Height(TreeNode*&& tn)
{
	if (tn == nullptr)return 0;
	else if ((tn->lchild == nullptr && tn->rchild == nullptr) || (tn->ltag == 1 && tn->rtag == 1))
		return 1;
	else if (tn->rchild == nullptr || tn->rtag == 1)return 1 + Height(std::move(tn->lchild));
	else if (tn->lchild == nullptr || tn->ltag == 1)return 1 + Height(std::move(tn->rchild));
	else return 1 + std::max(Height(std::move(tn->lchild)), Height(std::move(tn->rchild)));
}

bool MyTree::isThreadedTree() {
	return isThr(std::move(treeNode));
}

bool MyTree::isThr(TreeNode*&& tn) {
	if (tn == nullptr || (tn->lchild == nullptr && tn->ltag == 0))
		return false;
	else if (tn->ltag == 1)return true;
	else return isThr(std::move(tn->lchild));
}

void MyTree::inOrderThreading()
{
	inOrderThr(treeNode, nullptr);
}

void MyTree::inOrderThr(TreeNode*& tn, TreeNode*&& pre)
{
	if (tn == nullptr)return;
	inOrderThr(tn->lchild, std::move(pre));
	if (tn->lchild == nullptr)
	{
		tn->lchild = pre;
		tn->ltag = 1;
	}
	if (pre != nullptr && pre->rchild == nullptr)
	{
		pre->rchild = tn;
		pre->rtag = 1;
	}
	pre = tn;
	inOrderThr(tn->rchild, std::move(pre));
}

TreeNode MyTree::locateNode(char c)
{
	TreeNode* temp;
	locate(c, treeNode, temp);
	return *temp;
}

bool MyTree::locate(char c, TreeNode* tn, TreeNode*& temp)
{
	if (tn == nullptr)return false;
	else if (tn->data == c)
	{
		temp = tn;
		return true;
	}
	else if ((tn->lchild == nullptr && tn->rchild == nullptr) || (tn->ltag == 1 && tn->rtag == 1))
		return false;
	else if (tn->rchild == nullptr || tn->rtag == 1)return locate(c, tn->lchild, temp);
	else if (tn->lchild == nullptr || tn->ltag == 1)return locate(c, tn->rchild, temp);
	else return locate(c, tn->lchild, temp) || locate(c, tn->rchild, temp);
}

TreeNode MyTree::preNode(TreeNode tn) {
	if (tn.ltag == 1)return *tn.lchild;
	else {
		TreeNode* p = tn.lchild;
		while (p->rtag == 0)
		{
			p = p->rchild;
		}
		return *p;
	}
}

TreeNode MyTree::nextNode(TreeNode tn)
{
	if (tn.rtag == 1)
		return *tn.rchild;
	else {
		TreeNode* p = tn.rchild;
		while (p->ltag == 0)
		{
			p = p->lchild;
		}
		return *p;
	}
}

Huffman.cpp

#include "Huffman.h"
#include <bits/stdc++.h>

HuffmanTree::HuffmanTree(int n, int w[]) {
	int s1;
	int s2;
	this->n = n;
	int m = 2 * n - 1;
	htree = new HTNode[m];
	//1--n号空间存放叶子结点，初始化结点
	for (int i = 0; i < n; i++) {
		//其中叶子结点的权值是w[n]数组保存
		htree[i].weight = w[i];
		htree[i].lChild = -1;
		htree[i].rChild = -1;
		htree[i].parent = -1;
	}
	//对于其它的结点即非叶子结点
	for (int i = n; i < m; i++) {
		htree[i].weight = -1;
		htree[i].lChild = -1;
		htree[i].rChild = -1;
		htree[i].parent = -1;
	}

	//创建非叶子结点，构建哈夫曼树
	for (int i = n; i < m; i++) {
		//找到权值最小的两个结点，分别赋值给s1和s2
		select(i, s1, s2);
		htree[s1].parent = i;
		htree[s2].parent = i;
		htree[i].lChild = s1;
		htree[i].rChild = s2;
		htree[i].weight = htree[s1].weight + htree[s2].weight;
	}
}

HuffmanTree::~HuffmanTree() {
	delete[]htree;
}

void HuffmanTree::select(int num, int& s1, int& s2) {
	int min;
	//遍历全部的结点，找出一个单结点
	for (int i = 0; i < num; i++) {
		if (htree[i].parent == -1) {
			min = i;
			break;
		}
	}
	//继续遍历全部结点，找出权值最小的单结点
	for (int i = 0; i < num; i++) {
		if (htree[i].parent == -1) {
			if (htree[i].weight < htree[min].weight) {
				min = i;
			}
		}
	}
	s1 = min;
	//进行和上面相同的操作，找到第二小的结点
	for (int i = 0; i < num; i++) {
		if (htree[i].parent == -1 && i != s1) {
			min = i;
			break;
		}
	}
	for (int i = 0; i < num; i++) {
		if (htree[i].parent == -1 && i != s1) {
			if (htree[i].weight < htree[min].weight) {
				min = i;
			}
		}
	}
	s2 = min;
}

void HuffmanTree::printHuffmanCodes() {
	//从n个叶子结点到根求哈弗曼编码
	std::string* huffmanCode = new std::string[n];	//创建一个储存编码的数组
	for (int i = 0; i < n; i++) {
		std::string code = "";
		//这里我们从叶子结点开始向上遍历
		for (int c = i, p = htree[i].parent; p != -1; c = p, p = htree[p].parent) {
			if (htree[p].lChild == c) {
				code = "0" + code;	//如果该结点是双亲结点的左孩子，则在编码前加‘0’
			}
			else {
				code = "1" + code;	//如果该结点是双亲结点的右孩子，则在编码前加‘1’
			}
		}
		huffmanCode[i] = code;
	}
	//节点排序递减输出编码
	int* weight = new int[n];
	for (int i = 0; i < n; ++i)
	{
		weight[i] = htree[i].weight;
	}
	//简单选择排序
	for (int i = 0; i < n; i++) {
		int max = i;
		for (int j = i + 1; j < n; ++j)
		{
			if (weight[j] > weight[max]) {
				max = j;
			}
		}
		std::cout << weight[max] << ": " << huffmanCode[max] << std::endl;
		int temp = weight[max];
		weight[max] = weight[i];
		weight[i] = temp;
		std::string code = huffmanCode[max];
		huffmanCode[max] = huffmanCode[i];
		huffmanCode[i] = code;
	}

	/*
	// 	for (int i = 0; i < n; i++) {
	// 		std::cout << htree[i].weight << ": " << huffmanCode[i] << std::endl;
	// 	}
	*/

	delete[]weight;
	delete[]huffmanCode;
}

main.cpp

#include <bits/stdc++.h>
#include "TreeNode.h"
#include "MyTree.h"
#include "Huffman.h"
using namespace std;

int main()
{
	MyTree myTree("ABC@@DE@G@@F@@@");
	myTree.preOrderTraverse();//ABCDEGF
	cout << endl;
	myTree.inOrderTraverse();//CBEGDFA
	cout << endl;
	myTree.postOrderTraverse();//CGEFDBA
	cout << endl;
	cout << myTree.countLeaf() << endl;//3
	cout << myTree.countHeight() << endl;//5

	MyTree myThreadedTree(myTree);
	cout << myThreadedTree.isThreadedTree() << endl;//0
	myThreadedTree.inOrderThreading();
	cout << myThreadedTree.isThreadedTree() << endl;//1
	myThreadedTree.inOrderTraverse();//CBEGDFA
	cout << endl;

	TreeNode n = myThreadedTree.locateNode('G');
	myThreadedTree.preNode(n).printNode();//E
	cout << endl;
	myThreadedTree.nextNode(n).printNode();//D

	cout << endl;	int v[] = {2,7,5,4};
	HuffmanTree hTree(4, v);
	hTree.printHuffmanCodes();
	/*
	7:0
	5:10
	4:111
	2:110
	*/

	return 0;
}

测试结果

结果如图所示：

-Drm123-
关注
C++学习——树和二叉树
yhchank的博客
01-14 162
二叉树的递归定义如下：二叉树要么为空，要么由根节点、左子树、右子树组成，而左子树和右子树分别是一棵二叉树。在计算机中，树一般是“倒置”的，即根在上，叶子在下。 树和二叉树类似，区别在于没一个节点不一定只有两棵子树。 图示： 不管是二叉树还是树，每个非根节点都有一个父亲，也成父节点。 以下是一道例题 UVa679: Dropping Balls 题目 UVA679 Dropping Balls 分析 可以发现，对于一个结点k，其左子节点、右子结点的编号分别为2k和2k+1。 因为小球落下后，开关的状态就
数据结构（C++）：树和二叉树
lzx的博客
02-22 402
树无疑是数据结构中占着举足轻重的地位，因此需要细嚼慢咽。 比如满二叉树，完全二叉树，线索二叉树，遍历二叉树，AVL树（平衡二叉树），BST树（二叉排序树），B树，B+树，赫夫曼树，堆排序，树形选择排序以及有关图的知识！ 鉴于二叉树的应用型，对于树只做知识梳理： 树的结点：一个数据元素及若干指向其子树的分支 结点的度：结点拥有的子树数 叶子或终端结点：度为0的结点 分支结点或非终端结点：度不为0的结点 树的度：树内各结点的度的最大值 孩子和双亲：结点的子树的根称为该结点的孩子，该结点的
算法（24）-前缀树（1）-treeNode结构-数组-C++
aggie4628的专栏
02-08 1308
前缀树是处理字符串常见的数据结构。 前缀树一般包含四个功能：1.添加word void insert(string word) 2. 删除word void delete(string word) 3. 查询是否在字典树中 b...
【第四节】C/C++数据结构之树与二叉树
攻城狮7号的博客
06-07 1633
二叉树(Tree)是n个节点的有限集合，该集合为空集(或称为空二叉树)，或者由一个根节点和两颗互不相交的、分别称为根节点的左子树与右子树的二叉树组成。A. 所有节点都只有左子树的二叉树叫左斜树，所有节点都只有右子树的二叉树叫右斜树，这两者统称为斜树；B. 在一棵二叉树中，如果所有分支节点都存在左子树与右子树，并且所有叶子都在同一层次上，这样的二叉树称为满二叉树；
C++ 树形结构
x_xx_xxx_xxxx的博客
08-29 5405
参考自：http://blog.csdn.net/stephenxu111/article/details/2446382 修改了此篇文章中 代码显示的一点小问题。///Tree.h 文件 #pragma once #include <list> #include <algorithm> using namespace std;struct TreeNode; //定义一个结构体原形 clas
C++(数据结构)：树和二叉树
08-03
C++(数据结构)：树和二叉树 C++(数据结构)：树和二叉树 C++(数据结构)：树和二叉树 C++(数据结构)：树和二叉树 C++(数据结构)：树和二叉树 C++(数据结构)：树和二叉树 C++(数据结构)：树和二叉树 C++(数据结构)：树...
数据结构C++——二叉树和树
qq_60987997的博客
07-23 1103
设完全二叉树中一元素的序号为i, 1≤i≤n。，存在两个不同的二叉树，经过中序遍历都能得到这个结果。但实际上，这两颗二叉树想要实际表达的算式并不相同。与我们希望得到的最为接近。(复制、删除、输出等)。：按照树的层级，从上到下、从左到右依次遍历。：可以看作是缺少了部分元素的完全二叉树。设二叉树中元素数目为n。（前缀和后缀表达式中不会存在歧义）的次序访问树中元素，在同一层中，比如：家庭关系、公司组织……在二叉树的遍历中，每个元素。得到的表达式分别称为其的。树(tree)t是一个。实现，层次遍历通常借助。
数据结构树和二叉树(C++)
06-15
C++作为编程语言，提供了实现这些数据结构和算法的手段，可以利用类和对象来表示树和二叉树的节点，通过指针或引用来表示节点间的连接。理解并熟练掌握树和二叉树的概念、性质以及操作方法，对于解决复杂的算法问题...
树与二叉树_liongv3_c++学习_二叉树_资料_
10-01
在IT领域，树和二叉树是数据结构中非常重要的概念，它们被广泛应用于各种算法设计和软件...在这个过程中，C++作为一门强大的编程语言，能够提供丰富的工具和库支持，使得实现和调试树和二叉树相关的算法变得更加方便。
编程c++ 数据结构理论 树和二叉树
最新发布
08-28
一直过不了CSP初赛是很多初学者的烦恼，我想和通过写文章的方式帮助初学者通过初赛，学习更多理论知识，通过举栗子的方式让大家懂得更多。
二叉树的类封装（C++）
01-18
利用C++语言封装了二叉树的数组实现及链表实现，常用操作均被封装到类中。如：检索，添加、删除、遍历（前序、中序、后序）等。
C++ tree 树 结构
11-01
an STL-like C++ tree class used in various projects
c++数据结构--树与二叉树详解
qq_60462402的博客
05-03 1547
树的定义 树（tree）是n（n>=0）个结点的有限集，它或为空树（n=0）；或为非空树，对于非空树T: (1)有且仅有一个称之为根的结点； (2)除根以外的其余结点可分为m（m>0）个互不相交的有限集T1，T2，…，Tm，其中每一个集合本身又是一棵树，并且称为根的子树。 树的结构定义是一个递归的定义，即在树的定义中又用到树的定义，它道出了树的固有特性。 下面介绍一些树形结构中的基本术语。 树的基本术语 **结点：**树中的一个独立单元，包含一个数据元素及若干指向其子树的分支，如上图中的R、
c++树形结构
2301_76145087的博客
08-12 345
首先直接给出二叉树的递归定义① 要么二叉树没有根结点，是一棵空树。② 要么二叉树由根结点、左子树、右子树组成，且左子树和右子树都是二叉树。那么，什么是递归定义呢？其实递归定义就是用自身来定义自身。例如之前反复提及的斐波那契数列，它的定义为F[n]=F[n-1]+F[n-2]，这里其实就是递归定义，即用自身序列的元素（F[n-1] 与F[n-2]）来定义这个序列本身（即 F[n]）。
C++高级数据结构算法 | 树与二叉树的基本概念与性质
ZY-JIMMY
05-29 2089
树的基本概念 、二叉树的定义 、二叉树的性质
【开卷数据结构 】 树与二叉树
Ceylan__的博客
04-26 3242
在之前的文章里，我们学习的一直是一对一的线性结构，可现实中，还有很多一对多的情况需要处理，所以我们需要研究这样一种一对多的数据结构 ——“树”
C++ 小白入门leetcode (三）——tree 树 简单题目 详细解析
www_z_dd的博客
03-14 869
Tree C++ 100. 相同的树 给定两个二叉树，编写一个函数来检验它们是否相同。 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 一： class Solution { public: static string s; bool isSameTree(TreeNode* p, TreeNode* q) { if(p==NULL&a...
树的表示 | Tree | C/C++实现
qq_40998706的博客
01-30 1480
问题描述 请编写一个程序，输出给定有根树T中各节点u的信息，信息内容如下： u的结点编号 u的结点种类（根、内部节点、叶） u的父节点编号 u的子结点列表 u的深度 这里我们设给定树拥有n个结点，编号分别为0至n - 1。 输入： 第1行输入结点的个数n。接下来n行按照下述格式输入各结点的信息，每个结点占一行。 id k c1 c2 … ck id为结点的编号，k为度。c1 c2 … ck为第1个...
C++实现的二叉树创建和遍历，超入门邻家小女也懂了_c++二叉树的建立与遍历
kOS0ym的博客
04-27 922
/ 上一次访问的节点。// 继续弹出栈顶元素。// 更新上一次访问的节点。} else { // 右子树还未访问。// 右子树为空或已经访问过。
C++实现的数据结构：树与二叉树详解
二叉树和森林在数据结构中扮演着至关重要的角色，它们为各种算法提供了基础，如搜索、排序、图遍历等。 总结来说，这篇资料深入讲解了树和二叉树的理论知识以及C++的实现方法，对于学习数据结构和算法的开发者来说...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值