二叉树的一些操作整理

最新推荐文章于 2023-12-06 16:15:06 发布
原创 最新推荐文章于 2023-12-06 16:15:06 发布 · 726 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #二叉树 #递归 #遍历 

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

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

void Visit(BiTNode *pRoot)
{
	cout << pRoot->data << endl;
}

//1.创建一棵二叉树
void CreateBiTree(BiTNode **root)
{
	char ch;
	scanf("\n%c", &ch);
	if(ch=='#')
		*root = NULL;
	else
	{
		*root = (BiTNode *)malloc(sizeof(BiTNode));
		(*root)->data = ch;
		printf("Input %c's left child: ",ch);
		CreateBiTree(&((*root)->lchild));
		printf("Input %c's right child: ",ch);
		CreateBiTree(&((*root)->rchild));
	}
}

//2.递归前序遍历二叉树
/*
前序遍历递归解法：
（1）如果二叉树为空，空操作
（2）如果二叉树不为空，访问根节点，前序遍历左子树，前序遍历右子树
*/
void PreOrder(BiTNode *root)
{
	if(root == NULL)
		return ;
	printf("%c ", root->data);
	PreOrder(root->lchild);
	PreOrder(root->rchild);
}

//3.递归中序遍历二叉树
/*
中序遍历递归解法
（1）如果二叉树为空，空操作。
（2）如果二叉树不为空，中序遍历左子树，访问根节点，中序遍历右子树
*/
void InOrder(BiTNode *root)
{
	if(root == NULL)
		return ;
	InOrder(root->lchild);
	printf("%c ",root->data);
	InOrder(root->rchild);
}

//4.递归后序遍历二叉树
/*
后序遍历递归解法
（1）如果二叉树为空，空操作
（2）如果二叉树不为空，后序遍历左子树，后序遍历右子树，访问根节点
*/
void PostOrder(BiTNode *root)
{
	if(root == NULL)
		return ;
	PostOrder(root->lchild);
	PostOrder(root->rchild);
	printf("%c ",root->data);
}

//以下三种不同遍历二叉树的方法只是核心三行代码不同。
//具体思路参考该文：http://jianshu.io/p/49c8cfd07410
//5.非递归前序遍历二叉树
void PreOrder_Nonrecursive(BiTNode *root, vector<char> &path)
{
	stack< pair<BiTNode *,bool> > s;
	s.push(make_pair(root, false));
	bool visited;
	while(!s.empty())
	{
		root = s.top().first;
		visited = s.top().second;
		s.pop();
		if(root == NULL)
			continue;
		if(visited)
		{
			path.push_back(root->data);
		}
		else
		{
			s.push(make_pair(root->rchild,false));
			s.push(make_pair(root->lchild,false));
			s.push(make_pair(root,true));
		}
	}
}

//6.非递归中序遍历二叉树
void InOrder_Nonrecursive(BiTNode *root, vector<char> &path)
{
	stack< pair<BiTNode *,bool> > s;
	s.push(make_pair(root, false));
	bool visited;
	while(!s.empty())
	{
		root = s.top().first;
		visited = s.top().second;
		s.pop();
		if(root == NULL)
			continue;
		if(visited)
		{
			path.push_back(root->data);
		}
		else
		{
			s.push(make_pair(root->rchild,false));
			s.push(make_pair(root,true));
			s.push(make_pair(root->lchild,false));			
		}
	}
}

//7.非递归后序遍历二叉树
void PostOrder_Nonrecursive(BiTNode *root, vector<char> &path)
{
	stack< pair<BiTNode *,bool> > s;
	s.push(make_pair(root, false));
	bool visited;
	while(!s.empty())
	{
		root = s.top().first;
		visited = s.top().second;
		s.pop();
		if(root == NULL)
			continue;
		if(visited)
		{
			path.push_back(root->data);
		}
		else
		{
			s.push(make_pair(root,true));
			s.push(make_pair(root->rchild,false));			
			s.push(make_pair(root->lchild,false));			
		}
	}
}


//8.求二叉树节点的个数（递归）
/*
递归解法：
（1）如果二叉树为空，节点个数为0
（2）如果二叉树不为空，二叉树节点个数 = 左子树节点个数 + 右子树节点个数 + 1
*/
int GetNodeNum(BiTNode *pRoot)
{
	if(pRoot == NULL) //递归出口
		return 0;
	return GetNodeNum(pRoot->lchild)+GetNodeNum(pRoot->rchild)+1;
}

//9.求二叉树的深度（递归）
/*
递归解法：
（1）如果二叉树为空，二叉树的深度为0
（2）如果二叉树不为空，二叉树的深度 = max(左子树深度， 右子树深度) + 1
*/
int GetDepth(BiTNode *pRoot)
{
	if(pRoot == NULL) //递归出口
		return 0;
	int depthLeft = GetDepth(pRoot->lchild);
	int depthRight = GetDepth(pRoot->rchild);
	return depthLeft > depthRight ? (depthLeft + 1) : (depthRight + 1);
}

//10.分层遍历二叉树（按层次从上往下，从左往右）
/*
相当于广度优先搜索，使用队列实现。队列初始化，将根节点压入队列。
当队列不为空，进行如下操作：弹出一个节点，访问，若左子节点或右子节点不为空，将其压入队列。
*/
void LevelTraverse(BiTNode *pRoot)
{
	if(pRoot == NULL)
		return;
	queue<BiTNode *> q;
	q.push(pRoot);
	while(!q.empty())
	{
		BiTNode *pNode = q.front();
		q.pop();
		Visit(pNode);
		if(pNode->lchild != NULL)
			q.push(pNode->lchild);
		if(pNode->rchild != NULL)
			q.push(pNode->rchild);
	}
//	return;
}

//11. 将二叉查找树变为有序的双向链表
//解法一：
//解法二：参见《纸上谈兵》P46
/*
要求不能创建新节点，只调整指针。
递归解法：
（1）如果二叉树查找树为空，不需要转换，对应双向链表的第一个节点是NULL，最后一个节点是NULL
（2）如果二叉查找树不为空：
	如果左子树为空，对应双向有序链表的第一个节点是根节点，左边不需要其他操作；
	如果左子树不为空，转换左子树，二叉查找树对应双向有序链表的第一个节点就是
左子树转换后双向有序链表的第一个节点，同时将根节点和左子树转换后的双向有序链 表的最后一个节点连接；
	如果右子树为空，对应双向有序链表的最后一个节点是根节点，右边不需要其他操作；
	如果右子树不为空，对应双向有序链表的最后一个节点就是右子树转换后双向有序链表的
最后一个节点，同时将根节点和右子树转换后的双向有序链表的第一个节点连接。

二叉查找树定义：http://zh.wikipedia.org/wiki/%E4%BA%8C%E5%85%83%E6%90%9C%E5%B0%8B%E6%A8%B9
1.若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2.任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3.任意节点的左、右子树也分别为二叉查找树。
4.没有键值相等的节点（no duplicate nodes）

*/
/******************************************************************************
参数：
pRoot: 二叉查找树根节点指针
pFirstNode: 转换后双向有序链表的第一个节点指针
pLastNode: 转换后双向有序链表的最后一个节点指针
******************************************************************************/
void Convert(BiTNode *pRoot, BiTNode *&pFirstNode, BiTNode *&pLastNode)
{
	BiTNode *pFirstLeft=NULL, *pLastLeft=NULL, \
		*pFirstRight=NULL, *pLastRight=NULL;
	if(pRoot == NULL)
	{
		pFirstNode = NULL;
		pLastNode = NULL;
		return;
	}

	if(pRoot->lchild == NULL)
	{
		// 如果左子树为空，对应双向有序链表的第一个节点是根节点
		pFirstNode = pRoot;
	}
	else
	{
		Convert(pRoot->lchild, pFirstLeft, pLastLeft);
		// 二叉查找树对应双向有序链表的第一个节点就是左子树转换后双向有序链表的第一个节点 
		pFirstNode = pFirstLeft;
		// 将根节点和左子树转换后的双向有序链表的最后一个节点连接
		pRoot->lchild = pLastLeft;
		pLastLeft->rchild = pRoot;
	}

	if(pRoot->rchild == NULL)
	{
		// 对应双向有序链表的最后一个节点是根节点
		pLastNode = pRoot;
	}
	else
	{
		Convert(pRoot->rchild, pFirstRight, pLastRight);
		// 对应双向有序链表的最后一个节点就是右子树转换后双向有序链表的最后一个节点 
		pLastNode = pLastRight;
		// 将根节点和右子树转换后的双向有序链表的第一个节点连接
		pRoot->rchild = pFirstRight;
		pFirstRight->lchild = pRoot;
	}	
}

//12. 求二叉树第K层的节点个数
/*
（1）如果二叉树为空或者k<1返回0
（2）如果二叉树不为空并且k==1，返回1
（3）如果二叉树不为空且k>1，返回左子树中k-1层的节点个数与右子树k-1层节点个数之和
*/
int GetNodeNumKthLevel(BiTNode *pRoot, int k)
{
	if(pRoot == NULL || k < 1)
		return 0;
	if(k == 1)	//递归出口
		return 1;
	int numLeft = GetNodeNumKthLevel(pRoot->lchild, k-1);
	int numRight = GetNodeNumKthLevel(pRoot->rchild, k-1);
	return (numLeft + numRight);
}

//13. 求二叉树中叶子节点的个数
/*
递归解法：
（1）如果二叉树为空，返回0
（2）如果二叉树不为空且左右子树为空，返回1
（3）如果二叉树不为空，且左右子树不同时为空，返回左子树中叶子节点个数加上右子树中叶子节点个数
*/
int GetLeafNodeNum(BiTNode *pRoot)
{
	if(pRoot == NULL)
		return 0;
	if(pRoot->lchild == NULL && pRoot->rchild == NULL)
		return 1;
	int numLeft = GetLeafNodeNum(pRoot->lchild); //左子树中叶节点的个数
	int numRight = GetLeafNodeNum(pRoot->rchild); //右子树中叶节点的个数
	return (numLeft + numRight);
}

//14. 判断两棵二叉树是否结构相同


//15.求二叉树的镜像
/*
递归解法：
（1）如果二叉树为空，返回空
（2）如果二叉树不为空，求左子树和右子树的镜像，然后交换左子树和右子树
*/
BiTNode *Mirror(BiTNode *pRoot)
{
	if(pRoot == NULL)
		return NULL;
	BiTNode *pLeft = Mirror(pRoot->lchild);	//求左子树镜像
	BiTNode *pRight = Mirror(pRoot->rchild);	//求右子树镜像
	
	//交换左右子树
	pRoot->lchild = pRight;
	pRoot->rchild = pLeft;
	return pRoot;
}

//16. 求二叉树中两个节点的最低公共祖先节点
//http://leetcode.com/2011/07/lowest-common-ancestor-of-a-binary-tree-part-i.html
//A Bottom-up Approach (Worst case O(n) ):
BiTNode *GetLastCommonParent(BiTNode *pRoot, BiTNode *pNode1, BiTNode *pNode2)
{
	if(!pRoot) return NULL;
	if(pRoot == pNode1 || pRoot == pNode2) return pRoot;
	BiTNode *L = GetLastCommonParent(pRoot->lchild, pNode1, pNode2);
	BiTNode *R = GetLastCommonParent(pRoot->rchild, pNode1, pNode2);
	if(L && R) return pRoot;
	return L ? L : R;
}

//17. 求二叉树中节点的最大距离
//即二叉树中相距最远的两个节点之间的距离。
/*
递归解法：
（1）如果二叉树为空，返回0，同时记录左子树和右子树的深度，都为0
（2）如果二叉树不为空，最大距离要么是左子树中的最大距离，要么是右子树中的最大距离，要么是左子树节点中到根节点的最大距离+右子树节点中到根节点的最大距离，同时记录左子树和右子树节点中到根节点的最大距离。
*/

int GetMaxDistance(BiTNode *pRoot, int &maxLeft, int &maxRight)
{
	if(pRoot == NULL)
	{
		maxLeft = 0;
		maxRight =0;
		return 0;
	}

	int maxLL, maxLR, maxRL, maxRR;
	int maxDistLeft, maxDistRight;

	if(pRoot->lchild != NULL)
	{
		maxDistLeft = GetMaxDistance(pRoot->lchild,maxLL,maxLR);
		maxLeft = (maxLL > maxLR ? maxLL : maxLR) + 1;
	}
	else
	{
		maxDistLeft = 0;
		maxLeft = 0;
	}

	if(pRoot->rchild != NULL)
	{
		maxDistRight = GetMaxDistance(pRoot->rchild, maxRL, maxRR);
		maxRight = (maxRL > maxRR ? maxRL : maxRR) + 1;
	}
	else
	{
		maxDistRight = 0;
		maxRight = 0;
	}

	return max(max(maxDistLeft, maxDistRight), maxLeft + maxRight);
}

//18. 由前序遍历序列和中序遍历序列重建二叉树
/*
二叉树前序遍历序列中，第一个元素总是树的根节点的值。
中序遍历序列中，左子树的节点的值位于根节点的值的左边，右子树的节点的值位于根节点的值的右边。
递归解法：
（1）如果前序遍历为空或中序遍历为空或节点个数小于等于0，返回NULL。
（2）创建根节点。前序遍历的第一个数据就是根节点的数据，
在中序遍历中找到根节点的位置，可分别得知左子树和右子树的前序和中序遍历序列，重建左右子树。
*/

BiTNode *RebuildBinaryTree(int *pPreOrder, int* pInOrder, int nodeNum)
{
	if(pPreOrder == NULL || pInOrder == NULL || nodeNum <=0)
		return NULL;
	BiTNode * pRoot = new BiTNode;
	//前序遍历的第一个数据就是根节点数据
	pRoot->data = pPreOrder[0];
	pRoot->lchild = NULL;
	pRoot->rchild = NULL;
	//查找根节点在中序遍历中的位置，中序遍历中，根节点左边为左子树，右边为右子树
	int rootPositionInOrder = -1;
	for(int i = 0; i < nodeNum; ++i)
		if(pInOrder[i] == pRoot->data)
		{
			rootPositionInOrder = i;
			break;
		}
	if(rootPositionInOrder == -1)
	{
		throw std::exception("Invalid input.");
	}

	//重建左子树
	int nodeNumLeft = rootPositionInOrder;
	int *pPreOrderLeft = pPreOrder + 1;
	int *pInOrderLeft = pInOrder;
	pRoot->lchild = RebuildBinaryTree(pPreOrderLeft, pInOrderLeft, nodeNumLeft);

	//重建右子树
	int nodeNumRight = nodeNum - nodeNumLeft - 1;
	int *pPreOrderRight = pPreOrder + nodeNumLeft + 1;
	int *pInOrderRight = pInOrder + nodeNumLeft + 1;
	pRoot->rchild = RebuildBinaryTree(pPreOrderRight, pInOrderRight, nodeNumRight);
	
	return pRoot;
}


//19. 判断二叉树是不是完全二叉树
/*
若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，
第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

有如下算法，按层次（从上到下，从左到右）遍历二叉树，当遇到一个节点的左子树为空时，
则该节点右子树必须为空，且后面遍历的节点左右子树都必须为空，否则不是完全二叉树
*/

bool IsCompleteBinaryTree(BiTNode *pRoot)
{
	if(pRoot == NULL)
		return false;
	queue<BiTNode *> q;
	q.push(pRoot);
	bool mustHaveNoChild = false;
	bool result = true;
	while(!q.empty())
	{
		BiTNode* pNode = q.front;
		q.pop();
		if(mustHaveNoChild)	// 已经出现了有空子树的节点了，后面出现的必须为叶节点（左右子树都为空）
		{
			if(pNode->lchild != NULL || pNode->rchild != NULL)
			{
				result = false;
				break;
			}
		}
		else
		{
			if(pNode->lchild != NULL && pNode->rchild != NULL)
			{
				q.push(pNode->lchild);
				q.push(pNode->rchild);
			}
			else if(pNode->lchild != NULL && pNode->rchild == NULL)
			{
				mustHaveNoChild = true;
				q.push(pNode->lchild);
			}
			else if(pNode->lchild == NULL && pNode->rchild != NULL)
			{
				result = false;
				break;
			}
			else
			{
				mustHaveNoChild = true;
			}
		}
	}
	return result;
}

int main(void)
{
	BiTNode *root = NULL;
	int flag = 1, k=0;
	vector<char> pathpre,pathin,pathpost;
	printf("This program implies Basic operates of Binary Tree.\n");
	printf("Creat Binary Tree, PreOrder Traversal, InOrder Traversal, PostOrder Traversal.\n");

	printf("Please Creat a Binary Tree, \nInput the Tree's root Node.\n");
	CreateBiTree(&root);

	printf("\nRecursive PreOrder Traversal: \n");
	PreOrder(root);

	printf("\nRecursive InOrder Traversal: \n");
	InOrder(root);

	printf("\nRecursive PostOrder Traversal: \n");
	PostOrder(root);

	printf("\nNonRecursive PreOrder Traversal: \n");
	PreOrder_Nonrecursive(root,pathpre);
	for(vector<char>::const_iterator iter = pathpre.begin(); iter<pathpre.end(); ++iter)
		cout<< *iter <<endl;

	printf("NonRecursive InOrder Traversal: \n");
	InOrder_Nonrecursive(root,pathin);
	for(vector<char>::const_iterator iter = pathin.begin(); iter<pathin.end(); ++iter)
		cout<< *iter <<endl;

	printf("NonRecursive PostOrder Traversal: \n");
	PostOrder_Nonrecursive(root,pathpost);
	for(vector<char>::const_iterator iter = pathpost.begin(); iter<pathpost.end(); ++iter)
		cout<< *iter <<endl;

	return 0;

}


/*
参考资料：
http://blog.youkuaiyun.com/hackbuteer1/article/details/6583988
http://blog.youkuaiyun.com/luckyxiaoqiang/article/details/7518888
http://jianshu.io/p/49c8cfd07410
*/

二叉树的创建和相关算法
leap的博客
05-29 1万+
二叉树是一种非常重要的数据结构，它是分支结构的基础，今天本人将写一篇博客来叙述一下其相关的算法以及二叉树的创建过程！ 1：二叉树的创建： 主要有 先序，中序，后序，层序创建几种方式，其中前三种建立在二叉树遍历方式的基础上的。 （1）：先序创建      先序创建就是先创建根节点，随后依次创建其左子树和右子树，我们可以采用递归的方法来实现，因为二叉树本身就是建立在递归算法的基础上的。 （2
二叉树基本操作汇总
Kaiyang_Shao的博客
05-05 353
0. 前言 树结构是面试最长考察的一种数据结构，因为数这种结构的难度介于普通的数组和图之间，一般能够比较好的考察一个人的空间想象能力和对递归的使用。通常手写算法部分考察到树结构并不会很难，都是一些最基本的操作，例如前中后序遍历（某些大厂要求比较高，会让非递归方式实现，这个需要使用到栈进行存储，思考上有一定难度，后续会进行整理），构建一棵树，求数的深度，节点的个数等。只要理解树的结构和递归的过程，面...
二叉树的基本操作
los_ATend的博客
12-08 576
二叉树的基本操作
二叉树的好处（应用）
热门推荐
zealot_2002的专栏
11-30 2万+
二叉排序树是一种比较有用的折衷方案。     数组的搜索比较方便，可以直接用下标，但删除或者插入某些元素就比较麻烦。     链表与之相反，删除和插入元素很快，但查找很慢。     二叉排序树就既有链表的好处，也有数组的好处。     在处理大批量的动态的数据是比较有用。   文件系统和数据库系统一般都采用树（特别是B树）的数据结构数据，主要为排序和检索的效率。二叉树是一种最基本最典型
二叉树的操作
weixin_30432179的博客
08-19 134
先使用先序的方法建立一棵二叉树，然后分别使用递归与非递归的方法实现前序、中序、后序遍历二叉树，并使用了两种方法来进行层次遍历二叉树，一种方法就是使用STL中的queue，另外一种方法就是定义了一个数组队列，分别使用了front和rear两个数组的下标来表示入队与出队，还有两个操作就是求二叉树的深度、结点数。。。 [cpp]view plaincopy ...
二叉树常见算法整理
weixin_43946462的博客
07-06 681
/* public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } } */ 1、序列化二叉树 实现两个函数，分别用来序列化和反序列化二叉树 二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久
二叉树理论基础整理
最新发布
weixin_61344527的博客
12-06 533
客简单介绍了一下二叉树的类型和这些类型所具有的特性，重点在于二叉树的遍历方式以及这些遍历的一些应用。重点在前序、中序、后序的递归遍历和非递归遍历的实现，以及根据这个遍历的线性关系在原来二叉树的基础上建立起的前驱后继线索的二叉树，重点以中序线索二叉树讲了其创立和增删查。最后还讲了层次遍历。
二叉树遍历问题整理
Bananaaay的博客
04-19 1534
二叉树遍历问题整理 一、知二叉树先序和中序遍历求后序遍历 方一、直接递归找后序遍历 分析： 知道二叉树的先序和中序遍历，求其后序遍历： ​ 对于先序遍历的第一个元素是整个二叉树的根节点，对应的，我们可以在中序遍历中找到该元素的位置，因为中序遍历的顺序是先左节点，再根节点，再是右节点，所以在中序遍历中，该元素位置左边的元素都是该根节点左子树中的元素，该元素位置右边的元素都是该根节点右子树中的元素，同样也可以根据左右元素的数量知道左子树和右子树元素的数量。因为对于先序遍历，是按照根左右的顺序，所以我们可以在
二叉树基本操作+数据结构+实验报告整理.pdf
02-13
二叉树基本操作+数据结构+实验报告整理.pdf
树与二叉树详细整理.ppt
01-11
&quot;树与二叉树详细整理&quot; 树是一种非线性数据结构，主要用于描述带有层次关系的数据集。树的形式化定义是：树是由一个或多个结点组成的有限集合，其中有一个特定的称为根的结点；其余结点可分为m(m&ge;0)个互不相交的...
题目整理(二叉树).pdf
08-26
在本文件中，整理了与二叉树相关的多个考点，涵盖了建立二叉树、遍历二叉树、二叉树的深度和高度计算、二叉树的平衡判断、二叉树的修改操作等多个方面的算法知识。以下是整理的知识点： 1. 建立二叉树的二叉链表： ...
比较两个int型数组的大小
wangzengdi的专栏
06-11 6408
一般大家都知道比较字符型数组大小的函数strcmp
直接解析中缀表达式
wangzengdi的专栏
07-23 4316
预处理 判断表达式的合法性：1.如果表达式长度为1，且不是数字，2.如果表达式中开头一位为运算符（负号（减号）和左括号除外），3.如果是最后一位是运算符（右括号除外），4.1.1 小数点左、右任意一边不为数字，左括号”(“后面有：+ x ÷ ) .，左括号”(“前面有：数字、”)” ，可以认为是乘法，在左括号”(“前面插入”x”，右括号”)”前面为：+、- x ÷ . (，4.4.1 @”+”,@”
一道关于奥运奖牌排序的题
wangzengdi的专栏
06-16 2680
vector算法classstringlesslist 目录(?)[-] STL提供的Sort 算法 所有sort算法介绍sort 中的比较函数sort 的稳定性全排序局部排序nth_element 指定元素排序partition 和stable_partition Sort 和容器选择合适的排序函数小结 西方有句谚语：不要重复发明轮子！ S
全排列问题--剑指offer28
wangzengdi的专栏
05-18 879
#include void Permutation(char *pStr) { if(pStr == NULL) return; Permutation(pStr,pStr); } void Permutation(char *pStr, char *pBegin) { if(*pBegin == '\0') { printf("%s\n",pStr); } else
排序算法：快排，插入，希尔，归并，堆，选择，冒泡
wangzengdi的专栏
04-28 865
#include using namespace std;//划分函数：将数组划分为大于和小于某元素的两部分template int partition_job(T *array, int left, int right){int index = left;int pivot = array[index];swap(array[index],array[right]);for(int i = le
我的二分查找法（递归）
wangzengdi的专栏
05-18 548
template int binarySearch(T *array,int left, int right, T num) { assert(array != NULL); int mid = left + (right - left)/2; if(num == array[mid]) return mid; else if(num < array[mid]) right =
二叉树操作的毕设实践指南
资源摘要信息:&quot;本压缩包名为&#39;数据结构课程：二叉树操作综合实践&#39;，属于毕设项目资料。根据文件信息，该压缩包可能包含了与数据结构课程相关的二叉树操作的各类资料和实践内容。二叉树是数据结构中的基础概念之一，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值