二叉树终极版(递归)

最新推荐文章于 2024-09-11 15:01:00 发布
最新推荐文章于 2024-09-11 15:01:00 发布
阅读量380 收藏 4
点赞数 6
分类专栏： 数据结构和算法 文章标签： 数据结构 二叉树 c++ 递归法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36833548/article/details/121357009
版权
这段代码实现了一个模板化的二叉树结构，包括节点定义、二叉树的创建、销毁、前序、中序、后序遍历、输出叶子节点、计算节点度数、节点计数、计算高度以及查找、获取节点的父节点和子节点等功能。用户可以输入字符构建二叉树，并进行各种操作。
摘要由CSDN通过智能技术生成

二叉树终极版(递归)

二叉树是一个典型的递归的类型

二叉树结点
template<class T>
struct BinTreeNode
{
	T data;
	BinTreeNode<T>* leftchild;
	BinTreeNode<T>* rightchild;
	BinTreeNode()
	{
		leftchild = NULL;
		rightchild = NULL;
	}
	BinTreeNode(T x)
	{
		data = x;
		leftchild = NULL;
		rightchild = NULL;
	}
};
二叉树类函数体
class BinTree
{
public:
	BinTree();
	~BinTree();
	BinTreeNode<T>* Get_root()
	{
		return root;
	}  //返回根结点
	void CreateTree(BinTreeNode<T>*& root);  //创建二叉树
	void DeleTree(BinTreeNode<T>* root);  //销毁二叉树
	void PreTra(BinTreeNode<T>* root);  //前序遍历
	void InodTra(BinTreeNode<T>* root);  //中序遍历
	void PosodTra(BinTreeNode<T>* root);  //后序遍历
	void Output_leaves(BinTreeNode<T>* root);  //输出叶子结点
	void count_0_1_2(BinTreeNode<T>* root, int& i, int& j, int& k);  //计算度为0,1,2的结点的个数
	int Calc_Nodes(BinTreeNode<T>* root);  //计算二叉树的结点个数
	int Calc_height(BinTreeNode<T>* root);  //计算二叉树的深度
	BinTreeNode<T>* Find(BinTreeNode <T>* root, T item);  //在二叉树中搜索item
	BinTreeNode<T>* Parent(BinTreeNode <T>* root, T item);  //返回item的父结点指针     
	BinTreeNode<T>* LeftChild(BinTreeNode<T>* root, T item);  //返回item的左孩子指针     
	BinTreeNode<T>* RightChild(BinTreeNode<T>* root, T item);  //返回item的右孩子指针
protected:
	BinTreeNode<T>* root;
};
二叉树的创建
template<class T>
void BinTree<T>::CreateTree(BinTreeNode<T>*& root)
{
	T x;
	cin >> x;
	if (x == '#')
	{
		root = NULL;
		return;
	}
	root = new BinTreeNode<T>(x);
	if (root == NULL)
		return;
	CreateTree(root->leftchild);
	CreateTree(root->rightchild);
}
二叉树的销毁
template<class T>
void BinTree<T>::DeleTree(BinTreeNode<T>* root)
{
	if (root == NULL)
		return;
	DeleTree(root->leftchild);
	DeleTree(root->rightchild);
	delete root;
}
前序遍历
template<class T>
void BinTree<T>::PreTra(BinTreeNode<T>* root)
{
	if (root != NULL)
	{
		cout << root->data << ' ';
		PreTra(root->leftchild);
		PreTra(root->rightchild);
	}
}
中序遍历
template<class T>
void BinTree<T>::InodTra(BinTreeNode<T>* root)
{
	if (root != NULL)
	{
		InodTra(root->leftchild);
		cout << root->data << ' ';
		InodTra(root->rightchild);
	}
}
后序遍历
template<class T>
void BinTree<T>::PosodTra(BinTreeNode<T>* root)
{
	if (root != NULL)
	{
		PosodTra(root->leftchild);
		PosodTra(root->rightchild);
		cout << root->data << ' ';
	}
}
输出叶子结点
template<class T>
void BinTree<T>::Output_leaves(BinTreeNode<T>* root)
{
	if (root == NULL) return;
	if (root->leftchild == NULL && root->rightchild == NULL)
	{
		cout << root->data << endl;
	}
	Output_leaves(root->leftchild);
	Output_leaves(root->rightchild);
}
计算结点度为0,1,2的个数
template<class T>
void BinTree<T>::count_0_1_2(BinTreeNode<T>* root, int& i, int& j, int& k)
{
	if (root != NULL)
	{
		if (root->leftchild == NULL && root->rightchild == NULL)
			i++;
		if (root->leftchild == NULL && root->rightchild != NULL || root->leftchild != NULL && root->rightchild == NULL)
			j++;
		if (root->leftchild != NULL && root->rightchild != NULL)
			k++;
		count(root->leftchild, i, j, k);
		count(root->rightchild, i, j, k);
	}
}
计算二叉树结点的个数
template<class T>
int BinTree<T>::Calc_Nodes(BinTreeNode<T>* root)
{
	if (root == NULL)
		return 0;
	return	1 + Calc_Nodes(root->leftchild) + Calc_Nodes(root->rightchild);
}
计算二叉树的高度(深度)
template<class T>
int BinTree<T>::Calc_height(BinTreeNode<T>* root)
{
	int hl = 0, hr = 0, maxh = 0;
	if (root == NULL)
		return 0;
	hl = Calc_height(root->leftchild);
	hr = Calc_height(root->rightchild);
	maxh = hl > hr ? hl : hr;
	return maxh + 1;
}
二叉树中搜索一个指定的x值
template<class T>
BinTreeNode<T>* BinTree<T>::Find(BinTreeNode <T>* root, T item)
{
	BinTreeNode<T>* temp = NULL;
	if (root == NULL)
		return NULL;
	if (root->data == item)
		return root;
	temp = Find(root->leftchild, item);
	if (temp)
		return temp;
	temp = Find(root->rightchild, item);
	if (temp)
		return temp;
	return NULL;
}
求二叉树某个结点的父结点
template<class T>
BinTreeNode<T>* BinTree<T>::Parent(BinTreeNode <T>* root, T item)
{
	BinTreeNode<T>* temp = NULL;
	if (root == NULL)
		return NULL;
	if (root->leftchild != NULL)
	{
		if (root->leftchild->data == item)
			return root;
	}
	if (root->rightchild != NULL)
	{
		if (root->rightchild->data == item)
			return root;
	}
	temp = Parent(root->leftchild, item);
	if (temp)
		return temp;
	temp = Parent(root->rightchild, item);
	if (temp)
		return temp;
	return NULL;
}
求二叉树某个结点的左子女结点
template<class T>
BinTreeNode<T>* BinTree<T>::LeftChild(BinTreeNode<T>* root, T item)
{
	BinTreeNode<T>* temp = NULL;
	if (root == NULL)
		return NULL;
	if (root->data == item)
		return root->leftchild;
	temp = LeftChild(root->leftchild, item);
	if (temp)
		return temp;
	temp = LeftChild(root->rightchild, item);
	if (temp)
		return temp;
}
求二叉树某个结点的右子女结点
template<class T>
BinTreeNode<T>* BinTree<T>::RightChild(BinTreeNode<T>* root, T item)
{
	BinTreeNode<T>* temp = NULL;
	if (root == NULL)
		return NULL;
	if (root->data == item)
		return root->rightchild;
	temp = RightChild(root->leftchild, item);
	if (temp)
		return temp;
	temp = RightChild(root->rightchild, item);
	if (temp)
		return temp;
}
主函数
int main()
{
	BinTreeNode<char>* root;
	BinTree<char> t;
	int i = 0, j = 0, k = 0, count = 0, height = 0;
	char ch;
	t.CreateTree(root);
	cout << "二叉树的前序遍历为:" << endl;
	t.PreTra(root);
	cout << endl;
	cout << "二叉树的中序遍历为:" << endl;
	t.InodTra(root);
	cout << endl;
	cout << "二叉树的后序遍历为:" << endl;
	t.PosodTra(root);
	cout << endl;
	cout << "输出二叉树的叶子结点:" << endl;
	t.Output_leaves(root);
	t.count_0_1_2(root, i, j, k);
	cout << "二叉树0度点个数:" << i << ' ' << "二叉树1度点个数:" << j << ' ' << "二叉树2度点个数:" << k << endl;
	count = t.Calc_Nodes(root);
	cout << "二叉树的结点个数为:" << count << endl;
	height = t.Calc_height(root);
	cout << "二叉树的高度(深度)为:" << height << endl;
	cout << "搜索指定x值的结点,以'#'为结束" << endl;
	while (cin >> ch && ch != '#')
	{
		if (t.Find(root, ch))
			cout << "success" << endl;
		else
			cout << "failure" << endl;
	}
	cout << "搜索某结点的父结点和左右子女结点,以'#'为结束" << endl;
	while (cin >> ch && ch != '#')
	{
		BinTreeNode<char>* temp = NULL;
		temp = t.Parent(root, ch);
		if (temp)
			cout << "父结点为:" << temp->data << endl;
		else
			cout << "父结点为:" << "NULL" << endl;
		temp = t.LeftChild(root, ch);
		if (temp)
			cout << "左子女结点结点为:" << temp->data << endl;
		else
			cout << "左子女结点结点为:" << "NULL" << endl;
		temp = t.RightChild(root, ch);
		if (temp)
			cout << "右子女结点为结点为:" << temp->data << endl;
		else
			cout << "右子女结点为结点为:" << "NULL" << endl;
	}
	return 0;
}
完整代码
#include<iostream>

using namespace std;

template<class T>
struct BinTreeNode
{
	T data;
	BinTreeNode<T>* leftchild;
	BinTreeNode<T>* rightchild;
	BinTreeNode()
	{
		leftchild = NULL;
		rightchild = NULL;
	}
	BinTreeNode(T x)
	{
		data = x;
		leftchild = NULL;
		rightchild = NULL;
	}
};

template<class T>
class BinTree
{
public:
	BinTree();
	~BinTree();
	BinTreeNode<T>* Get_root()
	{
		return root;
	}  //返回根结点
	void CreateTree(BinTreeNode<T>*& root);  //创建二叉树
	void DeleTree(BinTreeNode<T>* root);  //销毁二叉树
	void PreTra(BinTreeNode<T>* root);  //前序遍历
	void InodTra(BinTreeNode<T>* root);  //中序遍历
	void PosodTra(BinTreeNode<T>* root);  //后序遍历
	void Output_leaves(BinTreeNode<T>* root);  //输出叶子结点
	void count_0_1_2(BinTreeNode<T>* root, int& i, int& j, int& k);  //计算度为0,1,2的结点的个数
	int Calc_Nodes(BinTreeNode<T>* root);  //计算二叉树的结点个数
	int Calc_height(BinTreeNode<T>* root);  //计算二叉树的深度
	BinTreeNode<T>* Find(BinTreeNode <T>* root, T item);  //在二叉树中搜索item
	BinTreeNode<T>* Parent(BinTreeNode <T>* root, T item);  //返回item的父结点指针     
	BinTreeNode<T>* LeftChild(BinTreeNode<T>* root, T item);  //返回item的左孩子指针     
	BinTreeNode<T>* RightChild(BinTreeNode<T>* root, T item);  //返回item的右孩子指针
protected:
	BinTreeNode<T>* root;
};

template<class T>
BinTree<T>::BinTree()
{
	root = NULL;
}

template<class T>
BinTree<T>::~BinTree()
{
	DeleTree(root);
}

template<class T>
void BinTree<T>::CreateTree(BinTreeNode<T>*& root)
{
	T x;
	cin >> x;
	if (x == '#')
	{
		root = NULL;
		return;
	}
	root = new BinTreeNode<T>(x);
	if (root == NULL)
		return;
	CreateTree(root->leftchild);
	CreateTree(root->rightchild);
}

template<class T>
void BinTree<T>::DeleTree(BinTreeNode<T>* root)
{
	if (root == NULL)
		return;
	DeleTree(root->leftchild);
	DeleTree(root->rightchild);
	delete root;
}

template<class T>
void BinTree<T>::PreTra(BinTreeNode<T>* root)
{
	if (root != NULL)
	{
		cout << root->data << ' ';
		PreTra(root->leftchild);
		PreTra(root->rightchild);
	}
}

template<class T>
void BinTree<T>::InodTra(BinTreeNode<T>* root)
{
	if (root != NULL)
	{
		InodTra(root->leftchild);
		cout << root->data << ' ';
		InodTra(root->rightchild);
	}
}

template<class T>
void BinTree<T>::PosodTra(BinTreeNode<T>* root)
{
	if (root != NULL)
	{
		PosodTra(root->leftchild);
		PosodTra(root->rightchild);
		cout << root->data << ' ';
	}
}

template<class T>
void BinTree<T>::Output_leaves(BinTreeNode<T>* root)
{
	if (root == NULL) return;
	if (root->leftchild == NULL && root->rightchild == NULL)
	{
		cout << root->data << endl;
	}
	Output_leaves(root->leftchild);
	Output_leaves(root->rightchild);
}

template<class T>
void BinTree<T>::count_0_1_2(BinTreeNode<T>* root, int& i, int& j, int& k)
{
	if (root != NULL)
	{
		if (root->leftchild == NULL && root->rightchild == NULL)
			i++;
		if (root->leftchild == NULL && root->rightchild != NULL || root->leftchild != NULL && root->rightchild == NULL)
			j++;
		if (root->leftchild != NULL && root->rightchild != NULL)
			k++;
		count_0_1_2(root->leftchild, i, j, k);
		count_0_1_2(root->rightchild, i, j, k);
	}
}

template<class T>
int BinTree<T>::Calc_Nodes(BinTreeNode<T>* root)
{
	if (root == NULL)
		return 0;
	return	1 + Calc_Nodes(root->leftchild) + Calc_Nodes(root->rightchild);
}

template<class T>
int BinTree<T>::Calc_height(BinTreeNode<T>* root)
{
	int hl = 0, hr = 0, maxh = 0;
	if (root == NULL)
		return 0;
	hl = Calc_height(root->leftchild);
	hr = Calc_height(root->rightchild);
	maxh = hl > hr ? hl : hr;
	return maxh + 1;
}

template<class T>
BinTreeNode<T>* BinTree<T>::Find(BinTreeNode <T>* root, T item)
{
	BinTreeNode<T>* temp = NULL;
	if (root == NULL)
		return NULL;
	if (root->data == item)
		return root;
	temp = Find(root->leftchild, item);
	if (temp)
		return temp;
	temp = Find(root->rightchild, item);
	if (temp)
		return temp;
	return NULL;
}

template<class T>
BinTreeNode<T>* BinTree<T>::Parent(BinTreeNode <T>* root, T item)
{
	BinTreeNode<T>* temp = NULL;
	if (root == NULL)
		return NULL;
	if (root->leftchild != NULL)
	{
		if (root->leftchild->data == item)
			return root;
	}
	if (root->rightchild != NULL)
	{
		if (root->rightchild->data == item)
			return root;
	}
	temp = Parent(root->leftchild, item);
	if (temp)
		return temp;
	temp = Parent(root->rightchild, item);
	if (temp)
		return temp;
	return NULL;
}

template<class T>
BinTreeNode<T>* BinTree<T>::LeftChild(BinTreeNode<T>* root, T item)
{
	BinTreeNode<T>* temp = NULL;
	if (root == NULL)
		return NULL;
	if (root->data == item)
		return root->leftchild;
	temp = LeftChild(root->leftchild, item);
	if (temp)
		return temp;
	temp = LeftChild(root->rightchild, item);
	if (temp)
		return temp;
}

template<class T>
BinTreeNode<T>* BinTree<T>::RightChild(BinTreeNode<T>* root, T item)
{
	BinTreeNode<T>* temp = NULL;
	if (root == NULL)
		return NULL;
	if (root->data == item)
		return root->rightchild;
	temp = RightChild(root->leftchild, item);
	if (temp)
		return temp;
	temp = RightChild(root->rightchild, item);
	if (temp)
		return temp;
}

int main()
{
	BinTreeNode<char>* root;
	BinTree<char> t;
	int i = 0, j = 0, k = 0, count = 0, height = 0;
	char ch;
	t.CreateTree(root);
	cout << "二叉树的前序遍历为:" << endl;
	t.PreTra(root);
	cout << endl;
	cout << "二叉树的中序遍历为:" << endl;
	t.InodTra(root);
	cout << endl;
	cout << "二叉树的后序遍历为:" << endl;
	t.PosodTra(root);
	cout << endl;
	cout << "输出二叉树的叶子结点:" << endl;
	t.Output_leaves(root);
	t.count_0_1_2(root, i, j, k);
	cout << "二叉树0度点个数:" << i << ' ' << "二叉树1度点个数:" << j << ' ' << "二叉树2度点个数:" << k << endl;
	count = t.Calc_Nodes(root);
	cout << "二叉树的结点个数为:" << count << endl;
	height = t.Calc_height(root);
	cout << "二叉树的高度(深度)为:" << height << endl;
	cout << "搜索指定x值的结点,以'#'为结束" << endl;
	while (cin >> ch && ch != '#')
	{
		if (t.Find(root, ch))
			cout << "success" << endl;
		else
			cout << "failure" << endl;
	}
	cout << "搜索某结点的父结点和左右子女结点,以'#'为结束" << endl;
	while (cin >> ch && ch != '#')
	{
		BinTreeNode<char>* temp = NULL;
		temp = t.Parent(root, ch);
		if (temp)
			cout << "父结点为:" << temp->data << endl;
		else
			cout << "父结点为:" << "NULL" << endl;
		temp = t.LeftChild(root, ch);
		if (temp)
			cout << "左子女结点结点为:" << temp->data << endl;
		else
			cout << "左子女结点结点为:" << "NULL" << endl;
		temp = t.RightChild(root, ch);
		if (temp)
			cout << "右子女结点为结点为:" << temp->data << endl;
		else
			cout << "右子女结点为结点为:" << "NULL" << endl;
	}
	return 0;
}
chn-zgq
关注
专栏目录
算法图解-终极版-递归-从前有座山
deep learning
10-04 558
递归 到底递归是如何执行的， 首先递归用到的是有限的存储空间， 在ram上存储， 另外， 递归，是对内存空间的重读使用， 图解只是为了方面理解， 但递归是有数量限制的， 不能像迭代那样， 可以无限多的迭代下去。 那么如何递归呢： 如果求F(5)的阶乘， 具体如上图。F(1) = 1, 返回到subvalue = 1, returnValue = 2 * f(1) = 2, 在继续， 直到求出结果。 应用求阶乘 def fact(n): if n <=1: return .
二叉树-遍历终极版
yixianfeng41的专栏
02-16 2712
对于二叉树的遍历，最熟悉的就是递归遍历了，对二叉树的非递归遍历大致知道一些，但是不太熟悉，尤其是后续非递归遍历的实现，一直比较懵逼，于是上网查询了一下，果然大神无处不在，那个后序遍历的双栈法，简直让人拍案叫绝，下面总结下。
C++模板学习：函数模板、结构体模板、类模板
diaorong4751的博客
03-22 914
C++模板：函数、结构体、类 模板实现 1.前言：(知道有模板这回事的童鞋请忽视) 　　普通函数、函数重载、模板函数 认识。 //学过c的童鞋们一定都写过函数sum吧，当时是这样写的： int sum(int a,int b) { return a+b; } //实现了整数的相加 //如果再想同时实现小数的相加，就再多写个小数的相加。普通实现我就不写了，知道...
二叉树面试题刷题模板[终极版]
wardseptember的博客
11-18 586
文章目录递归树结构二叉树的最大深度后序递归二叉树最小深度后序递归二叉树的直径后序递归平衡二叉树后序递归小总结对称的二叉树递归解法二叉树的镜像后序递归树的子结构递归解法二叉搜索树的最近公共祖先前序递归二叉树的最近公共祖先前序递归二叉搜索树的第k大节点中序递归二叉树中和为某一值的路径前序递归538. 把二叉搜索树转换为累加树类中序递归669. 修剪二叉搜索树前序递归找树左下角的值前序递归遍历左叶子之和递归遍历最长同值路径后序递归二叉树中第二小的节点递归遍历572. 另一个树的子树前序递归合并二叉树前序递归路径总
二叉树递归遍历与非递归遍历(终极版)
wusecaiyun的专栏
09-13 3309
二叉树遍历是二叉树中最基本的问题，其实现的方法非常多，有简单粗暴但容易爆栈的递归算法，还有稍微高级的使用栈模拟递归的非递归算法，另外还有不用栈而且只需要常数空间和线性时间的神奇Morris遍历算法，本文将对这些算法进行讲解和实现。 递归算法 二叉树节点使用以下数据结构进行表示，包括关键字、左儿子、右儿子属性和一个带默认参数的构造函数。 struct成员的默认属性为public
篇一：二叉树-遍历终极版
爱敲代码的小黄
08-09 249
对于二叉树的遍历，最熟悉的就是递归遍历了，对二叉树的非递归遍历大致知道一些，但是不太熟悉，尤其是后续非递归遍历的实现，一直比较懵逼，于是上网查询了一下，果然大神无处不在，那个后序遍历的双栈法，简直让人拍案叫绝，下面总结下。 1、先序遍历 先序遍历即顺序为：根节点-&gt;左节点-&gt;右节点 递归版: void xianxu(struct node *root)//先序遍历 { ...
一棵二叉树的中根线索二叉树_二叉树面试题刷题模板（终极版）
weixin_39908106的博客
11-20 180
树结构二叉树的最大深度后序递归二叉树最小深度后序递归二叉树的直径后序递归平衡二叉树后序递归小总结对称的二叉树递归解法二叉树的镜像后序递归树的子结构递归解法二叉搜索树的最近公共祖先前序递归二叉树的最近公共祖先前序递归二叉搜索树的第k大节点中序递归二叉树中和为某一值的路径前序递归538. 把二叉搜索树转换为累加树类中序递归669. 修剪二叉搜索树前序递归找树左下角的值前序递归遍历左叶子之和递...
二叉树-常见简单算法题
yixianfeng41的专栏
02-19 2577
二叉树，对一些常见的简单算法题，比如翻转二叉树，求高度，判断是否是相等的二叉树等，我们是必须掌握的！！！
算法Day2：递归——汉诺塔、斐波那契数列
JohnnyLin
02-26 1590
递归算法 递归思想 拆解问题：大问题->小问题 求解：小问题->大问题 写递归方法的步骤 ①明确函数的功能先不要去思考里面代码怎么写，首先搞清楚这个函数的干嘛用的，能完成什么功能？ ②明确原问题与子问题的关系寻找f(n) 与f(n –1) 的关系 ③明确递归基（边界条件）递归的过程中，子问题的规模在不断减小，当小到一定程度时可以直接得出它的解寻找递归基，相当于是思考：问题规模小...
递归技术的终极指南：树形数据结构中的应用与优化
[递归技术的终极指南：树形数据结构中的应用与优化](https://img-blog.csdn.net/20161008173146462) # 1. 递归技术简介 递归技术是一种在程序设计中常见且强大的编程方法，它允许函数调用自身来解决问题。这种技术...
【递归与迭代】：Python搜索算法的终极选择策略
[【递归与迭代】：Python搜索算法的终极选择策略](https://media.geeksforgeeks.org/wp-content/uploads/20240410135517/linked-list.webp) # 1. 递归与迭代概念解析 在计算机科学领域，递归与迭代是两种基本的解决...
【尾递归调用栈分析】：栈空间使用减少的终极技巧
递归可以被分为两种基本类型：直接递归和间接递归。直接递归是指函数直接调用自身，而间接递归则是通过调用一个或多个其他函数来间接地调用自身。 ## 1.2 尾递归的特点与重要性 尾递归是递归的一种特殊形式，其...
递归与迭代的终极对决：数据结构中效率与可读性的平衡艺术
[递归与迭代的终极对决：数据结构中效率与可读性的平衡艺术](https://media.geeksforgeeks.org/wp-content/uploads/20230626180106/file.png) # 1. 递归与迭代的基本概念解析 在计算机科学中，算法是解决问题的一...
数据结构应用实例(四)——最小生成树
Blogs of zcy1221
09-10 1219
每次选择最近顶点，需要进行一次遍历，比较 N 次，之后将其添加进最小生成树，更新 weight 和 pre，一次遍历，N 次操作，总共需要选择 N-1 次，所以 prim 算法的时间复杂度为。4、 kruskal 算法，为图的结构体添加成员 E ——存放边的结构体数组，成员为两节点编号和边的权值，这样在创建图时，可以直接创建 E，同时，图的数据文件中添加边的条数；综合所述，Prim 算法适合顶点相对较少而边相对稠密的网的最小生成树的求解，而 Kruskal 算法适合于求边比较稀疏的网的最小生成树；
【数据结构-二维前缀最小值】力扣3148. 矩阵中的最大得分
最新发布
sjsjs11的博客
09-11 1010
也就是说，当grid[i][j]为终点的时候，要在以(0,0)为左上角，(i,j)为右下角的矩阵中（不包括(i,j)）找到最小的那个元素值mn。如果用列来表示我们需要的信息，也就是从0到j-1列的最小值，然后第j列的从0到i-1行的最小值，这两个最小值我们进行比较，更小的那个就是我们需要的信息。所以说在遍历每一行的时候，我们都要重置pre_min为INT_MAX，pre_min的作用就是找到从0到j-1列的最小值，col_min的作用就是储存第j列的从0到i-1行的最小值。
数据结构----树
2301_77841194的博客
09-07 996
1、树(Tree)是n(n≥0)个结点的有限集。n=O时称为空树。在任意一棵非空树中:(1）有且仅有一个特定的称为根(Root)的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树,并且称为根的子树(SubTree)2、树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点（Leaf）或终端结点;度不为0的结点称为非终端结点或分支结点。
数据结构归并两个链表并按照学号升序
wsdsbtzk的博客
09-07 410
int id;int score;int N,M;cin>>N>>M;return 0;i<n;i++)Student* q;while(p!=NULL)q=p;p=p->next;free(q);=NULL)p=p->next;p->next=s2;=NULL)
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
2303_80388948的博客
09-07 920
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
理解二叉树后序遍历递归算法
"这篇资料来自《数据结构（清华大学版）——树和二叉树》章节，主要讲解了树和二叉树的相关概念，特别是后序遍历递归算法的应用。" 在计算机科学中，树是一种重要的数据结构，用于模拟具有层次关系的数据。树的基本...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值