树表查找之二叉排序树

首先介绍下基本概念：二叉排序树是一棵二叉树，或者为空，或者满足以下条件：

①若左子树不空，则其上的值均小于根的值；

②若右子树不空，其上的值均不小于根的值；

③左右子树也是二叉排序树

下面以基本的构造二叉排序树和查找其中的元素来说明其基本的算法。

1、构造

构造的基本思想：假设已存在一棵二叉排序树，需要向其上添加元素。方法是新建一个指向node类型的

指针，将key装入该指针指向的区域，然后遍历二叉排序树以寻找到合适的位置，将新建节点链接上。至于如

何寻找合适位置，则是根据二叉排序树的特点，在左右子树不断寻找，直到找到一个合适的NULL位置。详见

代码。

2、查找

先比较根节点的关键字与待查元素的大小关系。如果相等，则表明查找到，查找结束；否则，如果前者大

于后者，则在左子树中查找；否则，在右子树中查找。

代码如下：

[cpp] view plain copy print ?

1. #include<iostream>
2. using namespace std;
4. struct node //节点包含一个关键字和左右两个指向节点的指针
5. {
6. int key;
7. node *lchild;
8. node *rchild;
9. };
11. class bin_search_t //二叉排序树类
12. {
13. public:
14. bin_search_t();
15. void insert(node *&T,node *u);
16. void create_bst(node *&T);
17. node* visit(node *T,int value);
19. node *root;
20. };
21. bin_search_t::bin_search_t()
22. {
23. root=NULL; //root为NULL决定了insert()和create_bst()都得用root的引用
24. }
26. void bin_search_t::insert(node *&T,node *u) //将u指示的节点元素插入到以T为根的排序树中
27. {
28. if(T==NULL) //每次都是在空处链接
29. T=u;
30. else if(u->key>T->key)
31. insert(T->rchild,u);
32. else
33. insert(T->lchild,u);
34. }
36. void bin_search_t::create_bst(node *&T) //需要引用,因为下面有T=NULL语句，不引用就无法从root处访问了
37. {
38. node *u=NULL;
40. const int MAX=9999; //标志构造结束
41. int x;
43. while(1)
44. {
45. cin>>x;
46. if(x==MAX) break;
48. u=new node;
49. u->key=x;
50. u->lchild=NULL;
51. u->rchild=NULL;
53. insert(T,u);
54. }
55. }
57. /*递归查找*/
58. node* bin_search_t::visit(node *T,int value)
59. {
60. if(T==NULL || T->key==value ) //把T==NULL放在前面会省去很多麻烦，因为当T==NULL时，T->key会出错
61. return T;
62. else if(T->key>value)
63. return visit(T->lchild,value);
64. else
65. return visit(T->rchild,value);
66. }
68. /*
69. 非递归查找
70. node* bin_search_t_n::visit(node *T,int value)
71. {
72. node *p=T;
74. while(p!=NULL)
75. {
76. if(p->key==value)
77. return p;
78. else if(p->key>value)
79. p=p->lchild;
80. else
81. p=p->rchild;
82. }
84. return p;
85. }
86. */
88. int main()
89. {
90. bin_search_t p;
91. node *q;
93. p.create_bst(p.root);
94. q=p.visit(p.root,9); //以查找9为例
96. cout<<q<<endl; //输出9的位置
97. if(q!=NULL) //根据是否查找的，输出
98. cout<<q->key<<endl;
99. else
100. cout<<"q==NULL"<<endl;
102. return 0;
103. }

#include<iostream>
using namespace std;

struct node   //节点包含一个关键字和左右两个指向节点的指针
{
	int key;
	node *lchild;
	node *rchild;
};

class bin_search_t  //二叉排序树类
{
public:
	bin_search_t();
	void insert(node *&T,node *u);
	void create_bst(node *&T);
	node* visit(node *T,int value);

	node *root;
};
bin_search_t::bin_search_t()
{
	root=NULL; //root为NULL决定了insert()和create_bst()都得用root的引用
}

void bin_search_t::insert(node *&T,node *u)  //将u指示的节点元素插入到以T为根的排序树中
{
	if(T==NULL)  //每次都是在空处链接
		T=u;
	else if(u->key>T->key)
		insert(T->rchild,u);
	else
		insert(T->lchild,u);
}

void bin_search_t::create_bst(node *&T)  //需要引用,因为下面有T=NULL语句，不引用就无法从root处访问了
{
	node *u=NULL;

	const int MAX=9999; //标志构造结束
	int x;

	while(1)  
	{
		cin>>x;
		if(x==MAX) break;

		u=new node;  
		u->key=x;
		u->lchild=NULL;
		u->rchild=NULL;

		insert(T,u);	
	}
}

/*递归查找*/
node* bin_search_t::visit(node *T,int value)
{
	if(T==NULL || T->key==value )  //把T==NULL放在前面会省去很多麻烦，因为当T==NULL时，T->key会出错
		return T;
	else if(T->key>value)
		return visit(T->lchild,value);
	else
		return visit(T->rchild,value);
}

/*
非递归查找
node* bin_search_t_n::visit(node *T,int value)
{
	node *p=T;

	while(p!=NULL)
	{
		if(p->key==value)
			return p;
		else if(p->key>value)
			p=p->lchild;
		else
			p=p->rchild;
	}

	return p;
}
*/

int main()
{
	bin_search_t p;
	node *q;

	p.create_bst(p.root);
	q=p.visit(p.root,9);   //以查找9为例

    cout<<q<<endl;     //输出9的位置
	if(q!=NULL)        //根据是否查找的，输出
	    cout<<q->key<<endl;
	else
		cout<<"q==NULL"<<endl;

	return 0;
}