二叉排序树

二叉排序树（Binary Sort Tree）又称二叉查找树。 它或者是一棵空树；或者是具有下列性质的二叉树：

 （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

（3）左、右子树也分别为二叉排序树；

             --如果有两个相等的元素， 可根据情况 自定义位置。。！

            实现了， 二叉排序树的 构造（递归和 非递归）、查找、插入。

  

[cpp] view plain copy print ?

1. //#include "SortedTree.h"   
2. #include <iostream>   
3. using namespace std;  
4.   
5.   
6. struct Node  
7. {  
8.     int data;     
9.     Node *left;  
10.     Node *right;  
11.   
12.     Node():data(-1),left(NULL),right(NULL){}  
13.     Node(int num):data(num),left(NULL),right(NULL){}  
14.   
15. };  
16.   
17. class BinarySortTree  
18. {  
19. public:   
20.     BinarySortTree(int num[], int len);  
21.     void InsertNode_Loop(int num);     //非递归插入   
22.     void InsertNode(int num);         //递归插入   
23.   
24.     void PrintTree();                  //打印树       
25.     Node* Search(int num);             //查找节点   
26.   
27. private:  
28.     void InsertNode(Node *curNode, int num);  //递归插入   
29.     void PrintTree(Node *curNode);              //打印树, 后根遍历二叉排序树       
30.   
31.     Node *Search(Node *curNode, int num);                       //查找节点   
32.   
33.     Node  *rootNode;  
34.   
35. };  
36.   
37. BinarySortTree::BinarySortTree(int a[],int len):rootNode(NULL)  
38. {  
39.     for (int i = 0; i<len; i++)  
40.     {  
41.         //InsertNode_Loop(a[i]);      //非递归   
42.         InsertNode(a[i]);             //递归     
43.     }     
44. }  
45.   
46. void BinarySortTree::InsertNode_Loop(int num)  
47. {  
48.     //若根节点为空，则用第一个节点 作为根节点。   
49.     if (rootNode == NULL)  
50.     {  
51.         rootNode = new Node(num);  
52.         return;  
53.     }  
54.     Node * pRootNode = rootNode;   
55.     Node *pNode = new Node(num);  
56.     //待插入的节点 小于根节点则 插入到 左子树   
57.     while(pRootNode != NULL)  
58.     {  
59.         if (num < pRootNode->data)  
60.         {  
61.             if (pRootNode->left == NULL)  
62.             {  
63.                 pRootNode->left = pNode;               
64.                 return;  
65.             }else  
66.             {  
67.                 pRootNode = pRootNode->left;  
68.             }  
69.   
70.         }else  
71.         {  
72.             if (pRootNode->right == NULL)  
73.             {  
74.                 pRootNode->right = pNode;                  
75.                 return;  
76.             }else  
77.             {  
78.                 pRootNode = pRootNode->right;  
79.             }          
80.         }   
81.     }     
82.   
83.     return;  
84. }  
85.   
86. void BinarySortTree::InsertNode(int num)  
87. {  
88.     if (rootNode == NULL)  
89.     {  
90.         rootNode = new Node(num);  
91.         return;  
92.     }  
93.   
94.     InsertNode(rootNode, num);   
95.   
96.     return;  
97. }  
98.   
99. void BinarySortTree::InsertNode(Node *curNode,int num)  
100. {  
101.     // 不要使用注释部分的代码，因为在c\c++ 中形参 只是‘值’ 传递！   
102.     /*  if (curNode == NULL) 
103.     { 
104.     Node *pNode = new Node(num); 
105.     curNode = pNode; 
106.     return; 
107.     } 
108.  
109.     if (num < curNode->data) 
110.     { 
111.     InsertNode(curNode->left, num); 
112.     }else 
113.     { 
114.     InsertNode(curNode->right, num); 
115.     } 
116.     */  
117.     if (num < curNode->data)  
118.     {  
119.         if (curNode->left == NULL)  
120.         {  
121.             curNode->left =  new Node(num);  
122.         }else  
123.   
124.         {  
125.             InsertNode(curNode->left, num);  
126.         }  
127.   
128.     }else if (num > curNode->data)  
129.     {  
130.         if (curNode->right == NULL)  
131.         {  
132.             curNode->right = new Node(num);  
133.         }else  
134.         {  
135.             InsertNode(curNode->right, num);  
136.         }  
137.     }      
138.   
139.     return;  
140. }  
141.   
142.   
143. Node* BinarySortTree::Search(int num)  
144. {  
145.     if (rootNode->data == num)  
146.     {  
147.         cout<<"查找成功..."<<num<<endl;  
148.         return rootNode;  
149.     }else if (num < rootNode->data)  
150.     {  
151.         return Search(rootNode->left, num);  
152.     }else  
153.     {  
154.         return Search(rootNode->right, num);  
155.     }  
156.   
157.     return NULL;  
158. }  
159.   
160. Node* BinarySortTree::Search(Node *curNode ,int num)  
161. {  
162.     if (curNode == NULL)  
163.     {  
164.         cout<<"查找失败..."<<num<<endl;  
165.         return NULL;  
166.     }else  
167.     {  
168.         if (curNode->data == num)  
169.         {  
170.             cout<<"查找成功..."<<num<<endl;  
171.             return curNode;  
172.         }else if (num < curNode->data)  
173.         {  
174.             Search(curNode->left, num);  
175.         }else  
176.         {  
177.             Search(curNode->right, num);  
178.         }   
179.     }  
180.     return NULL;  
181. }  
182.   
183.   
184. void BinarySortTree::PrintTree()  
185. {     
186.     if(rootNode !=NULL)  
187.     {  
188.         cout<<"打印树。。。"<<endl;  
189.         PrintTree(rootNode);  
190.     }  
191. }  
192.   
193. void BinarySortTree::PrintTree(Node* curNode)  
194. {  
195.     if (curNode == NULL)  
196.     {  
197.         return;  
198.     }     
199.     PrintTree(curNode->left);  
200.     PrintTree(curNode->right);  
201.     cout<<curNode->data<<endl;     
202. }  
203.   
204. int main()  
205. {  
206.     int a[] = {5,2,1,4,0,9,7,10,100};  
207.     BinarySortTree tree(a, sizeof(a)/sizeof(a[0]));  
208.   
209.     tree.PrintTree();  
210.     tree.Search(19);     
211.   
212.     return 0;  
213. }  

//#include "SortedTree.h"
#include <iostream>
using namespace std;


struct Node
{
	int data;	
	Node *left;
	Node *right;

	Node():data(-1),left(NULL),right(NULL){}
	Node(int num):data(num),left(NULL),right(NULL){}

};

class BinarySortTree
{
public: 
	BinarySortTree(int num[], int len);
	void InsertNode_Loop(int num);	   //非递归插入
	void InsertNode(int num);         //递归插入

	void PrintTree();			       //打印树	
	Node* Search(int num);			   //查找节点

private:
	void InsertNode(Node *curNode, int num);  //递归插入
	void PrintTree(Node *curNode);				//打印树, 后根遍历二叉排序树	

	Node *Search(Node *curNode, int num);						//查找节点

	Node  *rootNode;

};

BinarySortTree::BinarySortTree(int a[],int len):rootNode(NULL)
{
	for (int i = 0; i<len; i++)
	{
		//InsertNode_Loop(a[i]);      //非递归
		InsertNode(a[i]);			  //递归	
	}	
}

void BinarySortTree::InsertNode_Loop(int num)
{
	//若根节点为空，则用第一个节点 作为根节点。
	if (rootNode == NULL)
	{
		rootNode = new Node(num);
		return;
	}
	Node * pRootNode = rootNode; 
	Node *pNode = new Node(num);
	//待插入的节点 小于根节点则 插入到 左子树
	while(pRootNode != NULL)
	{
		if (num < pRootNode->data)
		{
			if (pRootNode->left == NULL)
			{
				pRootNode->left = pNode;				
				return;
			}else
			{
				pRootNode = pRootNode->left;
			}

		}else
		{
			if (pRootNode->right == NULL)
			{
				pRootNode->right = pNode;				
				return;
			}else
			{
				pRootNode = pRootNode->right;
			}		 
		} 
	}   

	return;
}

void BinarySortTree::InsertNode(int num)
{
	if (rootNode == NULL)
	{
		rootNode = new Node(num);
		return;
	}

	InsertNode(rootNode, num); 

	return;
}

void BinarySortTree::InsertNode(Node *curNode,int num)
{
	// 不要使用注释部分的代码，因为在c\c++ 中形参 只是‘值’ 传递！
	/*  if (curNode == NULL)
	{
	Node *pNode = new Node(num);
	curNode = pNode;
	return;
	}

	if (num < curNode->data)
	{
	InsertNode(curNode->left, num);
	}else
	{
	InsertNode(curNode->right, num);
	}
	*/
	if (num < curNode->data)
	{
		if (curNode->left == NULL)
		{
			curNode->left =  new Node(num);
		}else

		{
			InsertNode(curNode->left, num);
		}

	}else if (num > curNode->data)
	{
		if (curNode->right == NULL)
		{
			curNode->right = new Node(num);
		}else
		{
			InsertNode(curNode->right, num);
		}
	}    

	return;
}


Node* BinarySortTree::Search(int num)
{
	if (rootNode->data == num)
	{
		cout<<"查找成功..."<<num<<endl;
		return rootNode;
	}else if (num < rootNode->data)
	{
		return Search(rootNode->left, num);
	}else
	{
		return Search(rootNode->right, num);
	}

	return NULL;
}

Node* BinarySortTree::Search(Node *curNode ,int num)
{
	if (curNode == NULL)
	{
		cout<<"查找失败..."<<num<<endl;
		return NULL;
	}else
	{
		if (curNode->data == num)
		{
			cout<<"查找成功..."<<num<<endl;
			return curNode;
		}else if (num < curNode->data)
		{
			Search(curNode->left, num);
		}else
		{
			Search(curNode->right, num);
		} 
	}
	return NULL;
}


void BinarySortTree::PrintTree()
{	
	if(rootNode !=NULL)
	{
		cout<<"打印树。。。"<<endl;
		PrintTree(rootNode);
	}
}

void BinarySortTree::PrintTree(Node* curNode)
{
	if (curNode == NULL)
	{
		return;
	}	
	PrintTree(curNode->left);
	PrintTree(curNode->right);
	cout<<curNode->data<<endl;	
}

int main()
{
	int a[] = {5,2,1,4,0,9,7,10,100};
	BinarySortTree tree(a, sizeof(a)/sizeof(a[0]));

	tree.PrintTree();
	tree.Search(19);   

	return 0;
}

（后根）遍历结果：

    0 1 4 2 7 100 10 9 5

 

http://blog.csdn.net/wang603603/article/details/9967043