二叉查找树搜索区间

最新推荐文章于 2020-09-07 18:08:53 发布
最新推荐文章于 2020-09-07 18:08:53 发布
阅读量384 收藏
点赞数
分类专栏： 数据结构 文章标签： 搜索 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FengNingXueChen/article/details/76681744
版权

给定节点root和k1,k2,搜索并打印满足k1<=x<=k2的节点

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

template<class Type>
class BinaryTree
{
private:
	struct BtNode 
	{
		BtNode *leftchild;
		BtNode *rightchild;
		Type data;
	};
public:
	typedef BtNode * PBtNode;
private:
	BtNode *root;
	Type  RefValue;
	typedef BtNode NodeType;

	static BtNode * _Buynode()
	{
		BtNode *s = (BtNode *)malloc(sizeof(BtNode));
		if(NULL == s) exit(1);
		memset(s,0,sizeof(BtNode));
		return s;
	}
	static void _Freenode(BtNode *p)
	{
		free(p);
	}

	BtNode * Create(Type *&str)
	{
		BtNode * s = NULL;
		if(*str != RefValue)
		{
			s = _Buynode();
			s->data = *str;
			s->leftchild = Create(++str);
			s->rightchild = Create(++str);
		}
		return s;
	}
	static void PreOrder(BtNode *ptr)
	{
		if(ptr != NULL)
		{
			cout<<ptr->data<<" ";
			PreOrder(ptr->leftchild);
			PreOrder(ptr->rightchild);
		}
	}

	static void InOrder(BtNode *ptr)
	{
		if(ptr != NULL)
		{
			InOrder(ptr->leftchild);
			cout<<ptr->data<<" ";
			InOrder(ptr->rightchild);
		}
	}

	static void PastOrder(BtNode *ptr)
	{
		if(ptr != NULL)
		{	
			PastOrder(ptr->leftchild);
			PastOrder(ptr->rightchild);
			cout<<ptr->data<<" ";
		}
	}
	static void Destroy(BtNode *ptr)
	{
		if(ptr != NULL)
		{
			Destroy(ptr->leftchild);
			Destroy(ptr->rightchild);
			_Freenode(ptr);
		}
	}

	static BtNode * FindValue(BtNode *broot,const Type &x)
	{
		BtNode *s = NULL;
		if(broot != NULL)
		{
			if(broot->data == x) return broot;
			s = FindValue(broot->leftchild,x );
			if(s == NULL) 
			{
				s = FindValue(broot->rightchild ,x);
			}
			else
			{
				return s;
			}
		}
		return s;
	}


	static BtNode *FindParent(BtNode *broot,const BtNode* child)
	{
		BtNode *s = NULL;
		if(broot != NULL)
		{
			if(broot->leftchild == child ||broot->rightchild == child) return broot;
			s = FindParent(broot->leftchild ,child);
			if(s == NULL)
			{
				return FindParent(broot->rightchild ,child);
			}
			else
			{
				return s;
			}
		}
		return s;
	}


	static int Size(BtNode *const broot )
	{
		if(broot == NULL) return 0;
		return Size(broot->leftchild)+Size(broot->rightchild)+1;
	}

	static int  MaxDepth(int a,int b)
	{
		return a>b?a:b;
	}
	static int Depth(BtNode *const broot)
	{
		if(broot == NULL)return 0;
		return MaxDepth(Depth(broot->leftchild ),Depth(broot->rightchild ))+1;
	}

	static int findps(Type value,Type *is,int n)
	{
		int count = 0;
		while(is != NULL)
		{
			if(*is == value) break;
			count++;
			is++;
		}
		if(count  == n) return -1;
		else return count;
	}
    static BtNode *CreateTreepi(Type *ps,Type *is,int n,Type refvalue)
	{
		BtNode *s = NULL;
		if(n != 0 && *ps != refvalue && ps != NULL)
		{
			s = _Buynode();
			s->data = *ps;
			int index = findps(*ps,is,n);
			if(index == -1)exit(1);
			s->leftchild  = CreateTreepi(ps+1,is,index,refvalue);
			s->rightchild  = CreateTreepi(ps+index+1,is+index+1,n-index-1,refvalue);
		}
	return s;
	}

	static bool equality_tree(BtNode const *aroot,BtNode const *broot)
	{
		if(aroot != NULL && broot != NULL)
		{
			if(aroot->data != broot->data)return false;
			else
			{
				return equality_tree(aroot->leftchild,broot->leftchild)
					&&equality_tree(aroot->rightchild ,broot->rightchild);
			}
		}
		else if(aroot == NULL && broot == NULL)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool DoseTree1HaveTree2(PBtNode p,PBtNode s)
	{
		bool result = true;
		if(s != NULL && p  == NULL || s != NULL && s->data != p->data)
		{
			result = false;
		}
		else if(s != NULL && s->data == p->data)
		{
			result = DoseTree1HaveTree2(p->leftchild,s->leftchild);

			if(result)result=DoseTree1HaveTree2(p->rightchild ,s->rightchild);
		}
		return result;
	}
	bool HasSubtree(PBtNode p,PBtNode s)
	{
		bool result = false;
		if(p != NULL && s != NULL)
		{
			if(p->data == s->data)
				result = DoseTree1HaveTree2(p,s);
			if(!result)
			{
				result = HasSubtree(p->leftchild,s);
			}
			if(!result)
			{
				result = HasSubtree(p->rightchild,s);
			}
		}
		return result;
	}
	void mirrorRrcursively(PBtNode p)
	{
		if(p == NULL ||p->leftchild == NULL && p->rightchild == NULL)return;
		PBtNode tmp = p->leftchild;
		p->leftchild = p->rightchild;
		p->rightchild = tmp;
		mirrorRrcursively(p->leftchild);
		mirrorRrcursively(p->rightchild);
	}	

	void Find_Path(PBtNode proot,Type k1,Type k2)
	{
		if(proot != NULL)
		{
			if(proot->data>=k1)
				cout<<proot->data<<endl;
			if(proot->leftchild != NULL 
				&& proot->leftchild->data>=k1 &&proot->leftchild->data<=k2)
				Find_Path(proot->leftchild,k1,k2);
			if(proot->rightchild != NULL 
				&& proot->rightchild->data>=k1 &&proot->rightchild->data<=k2)
				Find_Path(proot->rightchild,k1,k2);
		}
	}
public:
	
	BinaryTree(const Type &x):root(NULL),RefValue(x) {}
	/********************************************************************
    /*函数名称：BinaryTree(const BinaryTree<Type> &bt)
	/*函数功能：已经有的对象初始化新的对象
    /*调用参数：BinaryTree<Type> &bt
    /*返回类型：BinaryTree
	/*测试用例：char *str0="ABC##DE##F##G#H##";
				char *str1="ABCE###DF###G#H##";
				char *str2="ABDE####C#FG##H##";
				BinaryTree<char> myt('#');
				myt.CreateTree(str0);
				BinaryTree<char> yout(myt);
				yout.PreOrder();
	*********************************************************************/
    
	 PBtNode Copy(const PBtNode broot)
	{
		PBtNode s = NULL;
		if(broot != NULL)
		{
			s = _Buynode();
			s->data = broot->data ;
			s->leftchild  = Copy(broot->leftchild );
			s->rightchild  = Copy(broot->rightchild );
		}
		return s;
	}
	BinaryTree(const BinaryTree<Type> &bt)
	{
		if(&bt == NULL) return ;
	    RefValue  = bt.RefValue ;
		root = copy(bt.root);
	}


/********************************************************************
/*函数名称：operator=(const BinaryTree<Type> &bt)
/*函数功能：已经有的对象赋值已有的的对象
/*调用参数：const BinaryTree<Type> &bt
/*返回类型：BinaryTree<Type> &
/*测试用例：char *str0="ABC##DE##F##G#H##";
			char *str1="ABCE###DF###G#H##";
			char *str2="ABDE####C#FG##H##";
			BinaryTree<char> myt('#');
			myt.CreateTree(str2);
			BinaryTree<char> yout('#');
			yout = myt;
			yout.PreOrder();
*********************************************************************/
BinaryTree<Type> & operator=(const BinaryTree<Type> &bt)
{
	if(this != &bt)
	{
		Destroy(root);
		root = Copy(bt.root);
	}
	return *this;
}


	/********************************************************************
    /*函数名称：~BinaryTree()
	/*函数功能：释放对象所占的内存
    /*调用参数：this
    /*返回类型：BinaryTree
	/*测试用例：char *str0="ABC##DE##F##G#H##";
				char *str1="ABCE###DF###G#H##";
				char *str2="ABDE####C#FG##H##";
				BinaryTree<char> myt('#');
				myt.CreateTree(str2);
	*********************************************************************/
	~BinaryTree()
	{
		Clear();
	}


	/********************************************************************
    /*函数名称：GetRoot() const
	/*函数功能：得到数的根节点地址
    /*调用参数：BtNode const *this
    /*返回类型：BinaryTree
	/*测试用例：
	*********************************************************************/
	BtNode * GetRoot() const { return root;}


	void Clear() 
	{
		Destroy(root);
		root = NULL;
	}

	void Find_Path(Type k1,Type k2)
	{
		Find_Path(root,k1,k2);
	}

	/********************************************************************
    /*函数名称：CreateTree(Type *str)
	/*函数功能：用字符串创建一棵树
    /*调用参数：this，Type *str
    /*返回类型：void
	/*测试用例：char *str0="ABC##DE##F##G#H##";
				char *str1="ABCE###DF###G#H##";
				char *str2="ABDE####C#FG##H##";
				BinaryTree<char> myt('#');
				myt.CreateTree(str2);
	*********************************************************************/
	void CreateTree(Type *str)
	{
		if(str != NULL)
		{
			root = Create(str);
		}
	}


	/********************************************************************
    /*函数名称：CreateTreePI(Type *str)
	/*函数功能：用字符串创建一棵树
    /*调用参数：this，Type *pi,Type *is
    /*返回类型：void
	/*测试用例：char *str0="ABC##DE##F##G#H##";
				char *str1="ABCE###DF###G#H##";
				char *str2="ABDE####C#FG##H##";
				BinaryTree<char> myt('#');
				myt.CreateTree(str2);
	*********************************************************************/
	
	void CreateTreePI(Type *pi,Type *is)
	{
		int n = strlen(pi);
		root = CreateTreepi(pi,is,n,RefValue);
	}



	void PreOrder() const
	{
		PreOrder(root);
		cout<<endl;
	}
	void InOrder() const
	{
		InOrder(root);
		cout<<endl;
	}
	void PastOrder() const
	{
		PastOrder(root);
		cout<<endl;
	}
	/********************************************************************
    /*函数名称：FindValue(const Type &x) const
	/*函数功能：寻找节点在树上的地址
    /*调用参数：const Type &x，BinaryTree<Type> * const this
    /*返回类型：BtNode *
	/*测试用例：char *str0="ABC##DE##F##G#H##";
				char *str1="ABCE###DF###G#H##";
				char *str2="ABDE####C#FG##H##";
				char x = 'q';
				BinaryTree<char> myt('#');
				myt.CreateTree(str0);
				myt.PreOrder();
				BinaryTree<char>::PBtNode p =NULL;
				while(x != '#')
				{
					cin>>x;
					p = myt.FindValue(x);
					cout<<p<<endl;
				}
	*********************************************************************/
	BtNode * FindValue(const Type &x) const
	{
		if(this == NULL) return NULL;
		return findvalue(root,x);
	}



	/********************************************************************
    /*函数名称：FindParent(const BtNode *child) const
	/*函数功能：已知节点地址，找父亲节点地址
   /*调用参数：const BtNode *child，BinaryTree<Type> * const this
    /*返回类型：BtNode *
	/*测试用例：char *str0="ABC##DE##F##G#H##";
				char *str1="ABCE###DF###G#H##";
				char *str2="ABDE####C#FG##H##";
				char x = 'q';
				BinaryTree<char> myt('#');
				myt.CreateTree(str0);
				myt.PreOrder();
				BinaryTree<char>::PBtNode p =NULL,pa = NULL;
				while(x != '#')
				{
					cin>>x;
					p = myt.FindValue(x);
					cout<<p<<endl;
					pa = myt.FindParent(p);
					cout<<pa<<endl;
					cout<<endl;
				}
	*********************************************************************/
	BtNode * FindParent(const BtNode *child) const
	{
		if(this == NULL ||child == NULL) return NULL;
		return findparent(root,child);
	}


	/********************************************************************
    /*函数名称：Size() const
	/*函数功能：求树节点的大小
    /*调用参数：BtNode const *this
    /*返回类型：int
	/*测试用例：char *str0="ABC##DE##F##G#H##";
				char *str1="ABCE###DF####";
				char *str2="ABDE####C##";
				BinaryTree<char> myt('#');
				myt.CreateTree(str2);
				myt.PreOrder();
				cout<<myt.Size()<<endl;
	*********************************************************************/
	int Size() const
	{
		if(this == NULL) return -1;
		return Size(root);
	}

	int Depth() const
	{
		if(this == NULL) return -1;
		return Depth(root);
	}

/********************************************************************
/*函数名称：operator == (const BinaryTree<Type> &bt) const
/*函数功能：判断二叉树是否相等
/*调用参数：BtNode const *this，const BinaryTree<Type> &bt
/*返回类型：boll
/*测试用例：char *ps1="ABCDEFGH";
			char *is1="CBEDFAGH";
			char *ps2="ABDEHCFIG";
			char *is2="DBHEAFICG";
			char *ps3="ABDECFG";
			char *is3="DBEAFCG";
			BinaryTree<char> myt('#');
			myt.CreateTreePI(ps2,is2);
			BinaryTree<char> yout('#');
			yout.CreateTreePI(ps3,is3);
			cout<<(myt != yout)<<endl;
			cout<<(myt == yout)<<endl;
*********************************************************************/

bool operator==(const BinaryTree<Type> &bt) const
{
	if(this == NULL ||&bt == NULL) return false;
	if(this == &bt) return true;
	if(RefValue != bt.RefValue) return false;
	return equality_tree(root,bt.root);
}
/********************************************************************
/*函数名称：operator != (const BinaryTree<Type> &bt) const
/*函数功能：判断二叉树是否不等
/*调用参数：BtNode const *this，const BinaryTree<Type> &bt
/*返回类型：boll
/*测试用例：
*********************************************************************/
bool operator != (const BinaryTree<Type> &bt) const
{
	return !(*this == bt);
}
/*判断是否为子结构*/

bool HasSubtree(const BinaryTree<Type> &bt)
{
	return HasSubtree(this->GetRoot(),bt.GetRoot());
}
/*求二叉树的镜像*/

void mirrorRrcursively()
{
	mirrorRrcursively(this->GetRoot());
}


};



template<class Type>
class TreeIterator
{
protected:
	BinaryTree<Type> &tree;
	typename BinaryTree<Type>::PBtNode _Ptr;
public:
	TreeIterator(BinaryTree<Type> &bt):tree(bt),_Ptr(NULL)
	{}	
	Type &operator*() { return _Ptr->data;}
	const Type & operator*() const { return _Ptr->data;}
	bool IsDone() const { return _Ptr == NULL;}
	virtual void First() = 0;
	virtual void operator++() = 0;
};


template<class Type>
class PreIterator:public TreeIterator<Type>
{
	stack<typename BinaryTree<Type>::PBtNode> st;
public:
	PreIterator(BinaryTree<Type> &bt):TreeIterator<Type>(bt){}
	virtual void First()
	{
		_Ptr = NULL;
		if(tree.GetRoot() != NULL)
		{
			st.push(tree.GetRoot());
			operator++();
		}
	}
	virtual void operator++()
	{
		if(st.empty())
		{
			_Ptr = NULL;
			return ;
		}
		else
		{
			_Ptr = st.top();st.pop();
			if(_Ptr->rightchild != NULL)st.push(_Ptr->rightchild);
			if(_Ptr->leftchild != NULL)st.push(_Ptr->leftchild);
		}
	}
};


template<typename Type>
class StkNode
{
public:
	typename BinaryTree<Type>::PBtNode pnode;
	int popnum;
public:
	StkNode(typename BinaryTree<Type>::PBtNode p = NULL):pnode(p),popnum(0){}
};

template<class Type>
class InIterator:public TreeIterator<Type>
{
private:
	stack<StkNode<Type> > st;
public:
	InIterator(BinaryTree<Type> &bt):TreeIterator<Type>(bt){}
	virtual void First()
	{
		_Ptr = NULL;
		if(tree.GetRoot())
		{
			st.push(tree.GetRoot());
			operator++();
		}
	}
	
	virtual void operator++()
	{
		if(st.empty()) 
		{
			_Ptr = NULL;
			return;
		}
		typename StkNode<Type> node;
		while(!st.empty())
		{
			node = st.top();st.pop();
			if(++node.popnum == 2)
			{
				_Ptr = node.pnode ;
				if(node.pnode ->rightchild != NULL)st.push(StkNode<Type><node.pnode->rightchild> );
				break;
			}
			else if(node.popnum == 1)
			{
				st.push(node);
				if(node.pnode ->leftchild != NULL)st.push(StkNode<Type><node.pnode->leftchild>);
			}
		}
	}
};

template<typename Type>
void Printf_Iterator(TreeIterator<Type> &Tree)
{
	Tree.First();
	while(!Tree.IsDone())
	{
		cout<<*Tree<<" ";
		++Tree;
	}
	cout<<endl;

}

//template<class Type>
//class PastIterator  : public TreeIterator<Type>
//{
//protected:
//	stack<typename StkNode<Type> > st;
//public:
//	PastIterator(BinaryTree<Type> &bt):TreeIterator<Type>(bt){}
//
//	virtual void First()
//	{
//		_Ptr = NULL;
//		if(tree.GetRoot() != NULL)
//		{
//			st.push(StkNode<Type>(tree.GetRoot()));
//			operator++();
//		}
//	}
//	virtual void operator++()
//	{
//		if(st.empty())
//		{
//			_Ptr = NULL;
//			return;
//		}
//		StkNode<Type> node;
//		for(;;)
//		{
//			node = st.top(); st.pop();
//			if(++node.popnum == 3)
//			{
//				_Ptr = node.pnode;
//				return ;
//			}
//			st.push(node);
//			if(node.popnum == 1 && node.pnode->leftchild != NULL)
//			{
//				st.push(StkNode<Type>(node.pnode->leftchild));
//			}else if(node.popnum == 2 && node.pnode->rightchild != NULL)
//			{
//				st.push(StkNode<Type>(node.pnode->rightchild));
//			}
//		}
//	}
//};

//fei StkNode
template<typename Type>
class NiceInIterator:public TreeIterator<Type>
{
private:
	stack<typename BinaryTree<Type>::PBtNode> st;
public:
	NiceInIterator(typename BinaryTree<Type> &bt):TreeIterator<Type>(bt){}
	virtual void First()
	{
		if(tree.GetRoot())
		{
			typename BinaryTree<Type>::PBtNode p = tree.GetRoot();
			while(p != NULL)
			{
				st.push(p);
				p = p->leftchild ;
			}
			_Ptr = st.top();st.pop();
		}
	}
	virtual void operator++()
	{
		if(_Ptr != NULL)
		{
			_Ptr = _Ptr->rightchild;
		}
		while(!st.empty() ||_Ptr != NULL)
		{
			while(_Ptr != NULL )
			{
				st.push(_Ptr );
				_Ptr = _Ptr->leftchild;
			}
			_Ptr = st.top();st.pop();
			return ;
		}
		if(st.empty())
		{
			_Ptr = NULL;
			return ;
		}
	}
};


//非StkNode
template<class Type>
class PastIterator  : public TreeIterator<Type>
{
private:
	typename BinaryTree<Type>::PBtNode tag;
	stack<typename BinaryTree<Type>::PBtNode> st;
public:
	PastIterator(BinaryTree<Type> &bt):TreeIterator<Type>(bt),tag(NULL){}

	virtual void First()
	{
		if(tree.GetRoot())
		{
			//st.push(tree.GetRoot());
			_Ptr = tree.GetRoot();
			operator++();
		}
	}
	virtual void operator++()
	{
		if(tag == tree.GetRoot())
		{
			_Ptr = NULL;
			return ;
		}
		if(_Ptr != tree.GetRoot())_Ptr = NULL;
        while(!st.empty() || _Ptr != NULL)
		{
			while(_Ptr != NULL)
			{
				st.push(_Ptr);
				_Ptr = _Ptr->leftchild;
			}
			_Ptr = st.top(); st.pop();
			if(_Ptr->rightchild == NULL ||_Ptr->rightchild == tag)
			{
				tag = _Ptr;
				return ;
			}else
			{
				st.push(_Ptr);
				_Ptr = _Ptr->rightchild;
			}
		}
	}
};


template<typename Type>
class LevelIterator:public TreeIterator<Type>
{
private:
	queue<typename BinaryTree<Type>::PBtNode> qu;
public:
	LevelIterator(typename BinaryTree<Type> &bt):TreeIterator<Type>(bt){}
	virtual void First()
	{
		_Ptr = NULL;
		if(tree.GetRoot() != NULL)
		{
			qu.push(tree.GetRoot());
			operator++();
		}
	}
	virtual void operator++()
	{
		if(qu.empty())
		{
			_Ptr = NULL;
			return ;
		}
		_Ptr = qu.front();qu.pop();
		if(_Ptr->leftchild  != NULL)
			qu.push(_Ptr->leftchild);
		if(_Ptr->rightchild != NULL)
			qu.push(_Ptr->rightchild);
	}
};
测试用例 

#include<iostream>
#include "BinaryTree.h"
using namespace std;
int main()
{
	char *str0="ABC##DE##F##G#H##";
	char *str1="ABCE###DF###G#H##";
	char *str2="ABDE####C#FG##H##";
	BinaryTree<char> myt('#');
	myt.CreateTree(str1);
	myt.Find_Path('A','F');
}

运行结果

A
B
C
E
D
F
请按任意键继续. . .



FengNingXueChen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的先中后序遍历
qq_36314864的博客
04-25 641
二叉树的遍历 二叉树的遍历：指按某条搜索路径访问树中的每个结点，使得每个结点均被访问一次，而且仅被访问一次。 二叉树的递归定义可知，遍历一棵二叉树便要决定对根结点N、左子树L、右子树R的访问顺序。按照先遍历左子树再遍历右子树的原则，常见的遍历次序有先序（NLR）、中序（LNR）、后序（LRN）三种遍历算法。其中"序"指的是根结点在何时被访问。 先序遍历 先序遍历操作过程如下 若二叉树为空，则什么也不做；否则， 1）访问根结点 2）先序遍历左子树 3）先序遍历右子树 对应递归算法 void PreOrder(
树——二叉树的先序、中序和后序遍历
05-26 589
1，二叉树是否只有一种遍历方式（层次遍历）？ 2，典型的二叉树的遍历方式： 1，先序遍历（Pre-Order Traversal）； 2，中序遍历（In-Order Traversal）； 3，后序遍历（Post-Order Traversal）； 3，先序遍历（“先序”指最先访问根结点中的数据元素）： 　　1，二...
动态规划 最优二叉搜索树.docx
最新发布
12-17
最优二叉搜索树进一步优化了查找效率，使得在给定的查询频率分布下，查找的总成本最小。 动态规划解决最优二叉搜索树问题通常采用自底向上的策略，也称为Floyd算法。假设我们有一个键序列K = {k1 和对应的查询频率P...
0020算法笔记——【动态规划】最优二叉搜索树问题 - liufeng_king的专栏 - 博客频道 - CSDN1
08-03
在最优二叉搜索树问题中，我们有一个有序集合S={x_1, x_2, ..., x_n}，每个元素x_i在集合中有相应的查找概率b_i（如果元素等于x_i）和a_i（如果元素在(x_i, x_{i+1})范围内）。定义p为在树中搜索一次的平均比较次数...
c.rar_c++区间树_区间树
09-20
红黑树是一种自平衡的二叉查找树，其特点是每个节点都带有颜色属性（红色或黑色），并且满足特定的性质，确保了树的高度保持在O(log n)范围内。在描述中提到的`RB.cpp`文件很可能是红黑树的实现。红黑树常用于实现...
综合查找算法（顺序查找、折半查找、二叉排序树、哈希表）-数据结构课程设计
09-26
它通过不断将查找区间减半来缩小搜索范围，平均时间复杂度为O(log n)。折半查找的优势在于效率高，但前提是数据必须事先排序，且不支持动态插入和删除操作。 **二叉排序树**是一种自平衡的二叉搜索树，其中每个节点...
二叉树先中后序遍历（递归与非递归）
qinxinli的博客
08-19 300
非递归利用栈 #include &lt;iostream&gt; #include &lt;stack&gt; using namespace std; typedef struct BinaryTree { char data; BinaryTree* lchild; BinaryTree* rchild; }BinaryTree; typedef struct MYDATA {...
二叉查找树中搜索区间
不积跬步无以至千里
10-03 749
给定两个值 k1 和 k2（k1 如果有 k1 = 10 和 k2 = 22, 你的程序应该返回 [12, 20, 22]. 20 / \ 8 22 / \ 4 12 /** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNo
11. 二叉查找树中搜索区间
strike1989的博客
03-06 289
给定两个值 k1 和 k2（k1 &lt; k2）和一个二叉查找树的根节点。找到树中所有值在 k1 到 k2 范围内的节点。即打印所有x (k1 &lt;= x &lt;= k2) 其中 x 是二叉查找树的中的节点值。返回所有升序的节点值。样例如果有 k1 = 10 和 k2 = 22, 你的程序应该返回 [12, 20, 22]. 20 / \ 8 22 / \ 4 ...
【线段树】一种二叉搜索树
JZHu_Ming_Han的博客
08-20 433
线段树是什么 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。（以上转自百度百科） 如果我们用根节点代表1~n这个区间，那么它的左儿子节点就代表区间1~(n+1)div 2，右儿子代表区间(n+1)div 2+1~n，以此类推（如下图） 线段树如何实现 我们用深搜来插入，查询与修改。 1，建树与区间查询 每次走到一...
【算法导论随笔】第三部分2 二叉搜索树与红黑树与区间树
carvingfate的博客
09-07 310
BST(排序二叉树/搜索树) 排序：中序遍历 同快排一样，有序时挨个插入元素O（n^2），所以先对数组随机化 后继和前驱 https://blog.csdn.net/qq_42403295/article/details/88758816 证明BST高度期望值是logn Cormen课上用到的思路：令y=2^x,然后证明y 因为比如 max(a,b)<=a+b max(2的a次方与2的b次方)<=2的a次方+2的b次方 当|a-b|逐渐增大时，后者收敛速度比前者快 ...
lintcode11. 二叉查找树中搜索区间
sinb妃的博客
01-16 139
给定一个二叉查找树和范围[k1, k2]。按照升序返回给定范围内的节点值。 样例 样例 1: 输入：{5},6,10 输出：[] 5 它将被序列化为 {5} 没有数字介于6和10之间 样例 2: 输入：{20,8,22,4,12},10,22 输出：[12,20,22] 解释： 20 / \ 8 22 / \ 4...
java先序后序遍历函数
xiaoxin888888的专栏
10-27 1159
<br />/** * 树的前序递归遍历 pre=prefix(前缀) * @param node 要遍历的节点 */ public static void preOrder(TreeNode node) { //如果传进来的节点不为空，则遍历，注，叶子节点的子节点为null if (node != null) { System.out.print(node.getN
先序，中序，后序用循环和递归的实现
THEWORLDKIND的专栏
08-18 520
先序，中序，后序用循环和递归的实现 #include #include #include using namespace std; struct binaryTreeNode {     int m_data;     binaryTreeNode *m_left;     binaryTreeNode *m_right; }; vector result; //递归先序遍
【二叉树遍历算法】——前/中/后序递归与非递归的实现
「Android之禅」公众号博主，和你分享有价值有思考的技术文章
10-17 1419
昨天面试了美团，面试官要求写出二叉树的中序遍历，要求实现递归与非递归方式。在写非递归的时候，一个while循环中忘记控制空指针，╮(╯▽╰)╭当时脑子一片空白不在状态。回来后告诉自己，这类问题以后绝不会发生！下述6种实现方法希望大家都能理解，并快速能手写代码出来。（理解，懂得思路才是王道，因为面试的时候人的情绪相对来说是比较紧张，需要掌握得更熟悉） 先（前）序递归遍历 void preorde
二分查找与二叉查找树解题指南
"第六课_二分查找与二叉查找树.pdf" 二分查找是一种高效的搜索算法，它适用于已排序的数组或列表。在查找过程中，算法会不断将搜索范围减半，直到找到目标值或者确定目标不存在。基本步骤如下： 1. 首先，计算数组...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值