二叉树搜索树的概念，维基百科描述如下：

二叉查找树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树：

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

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

3.它的左、右子树也分别为二叉排序树。

简单的说，就是根节点比右边叶子结点大，但比左边叶子节点小。每一颗子树都如此。

往一个二叉搜索树中插入节点，算法描述如下：

如果该数一个结点都没有，那么先插入一个结点作为根结点。

如果有了，就看插入的结点比这个根结点大还是小，大么插右边，小么插左边，等于就不插。

插的时候看待插入的结点要插的这个位子是不是还空着，空着才能插。如果不空，比如被结点A占了，那么就把这个结点A作为根结点，再按照之前的方法再次插入一遍。

因此，很容易看出，这里存在递归。因此可以用递归方法实现。

1. using System; 
2. using System.Collections.Generic; 
3. using System.Linq; 
4. using System.Text; 
5. namespace tree 
6. { 
7.     #region 节点的定义 
8.     class node 
9.     { 
10.         public int nodevalue; 
11.         public node leftchild, rightchild; 
12.         public node() 
13.         { } 
14.         public node(int value) 
15.         { 
16.             nodevalue = value; 
17.         } 
18.         public void assignchild(node left, node right)//设定左右孩子 
19.         { 
20.             this.leftchild = left; 
21.             this.rightchild = right; 
22.         } 
23.         public bool hasleftchild//是否有左孩子 
24.         { 
25.             get 
26.             { 
27.                 return (leftchild != null); 
28.             } 
29.         } 
30.         public bool hasrightchild//是否有右孩子 
31.         { 
32.             get 
33.             { 
34.                 return (rightchild != null); 
35.             } 
36.         } 
37.         public bool haschild//是否有右孩子 
38.         { 
39.             get 
40.             { 
41.                 return hasleftchild || hasrightchild; 
42.             } 
43.         } 
44.     } 
45.     #endregion 
46.     class Program 
47.     { 
48.         static void Main(string[] args) 
49.         { 
50.             node node_1 = new node(1); 
51.             node node_2 = new node(2); 
52.             node node_3 = new node(3); 
53.             node node_4 = new node(4); 
54.             node node_5 = new node(5); 
55.             node node_6 = new node(6); 
56.             node node_7 = new node(7); 
57.             node node_8 = new node(8); 
58.             node node_9 = new node(9); 
59.             node node_10 = new node(10); 
60.             node node_11 = new node(11); 
61.             node node_12 = new node(12); 
62.             node node_13 = new node(13); 
63.             InsertIntoBST(node_6, node_12);//node_6作为根结点 
64.             InsertIntoBST(node_6, node_5); 
65.             InsertIntoBST(node_6, node_6); 
66.             InsertIntoBST(node_6, node_9); 
67.             InsertIntoBST(node_6, node_1); 
68.             InsertIntoBST(node_6, node_7); 
69.             InsertIntoBST(node_6, node_8); 
70.             InsertIntoBST(node_6, node_3); 
71.             InsertIntoBST(node_6, node_10); 
72.             InsertIntoBST(node_6, node_4); 
73.             InsertIntoBST(node_6, node_2); 
74.             InsertIntoBST(node_6, node_11); 
75.             preorder_visit_depth(node_6, 1,""); //先序遍历，附带打印深度和左右 
76.         } 
77.         //先序遍历 //DLR，附带打印深度和左右 
78.         static void preorder_visit_depth(node Anode, int depth,string lr) 
79.         { 
80.             Console.WriteLine(Anode.nodevalue + "-depth:" + depth+lr);//打印出深度和左右 
81.             depth++; 
82.             if (Anode.hasleftchild) 
83.             { 
84.                 preorder_visit_depth(Anode.leftchild, depth,"-left"); 
85.             } 
86.             if (Anode.hasrightchild) 
87.             { 
88.                 preorder_visit_depth(Anode.rightchild, depth,"-right"); 
89.             } 
90.         } 
91.         static void InsertIntoBST(node root, node leaf) 
92.         { 
93.             if (root == null) 
94.             { 
95.                 root = leaf; 
96.                 return; 
97.             } 
98.             if (root.nodevalue == leaf.nodevalue) 
99.             { 
100.                 return; 
101.             } 
102.             else if (root.nodevalue > leaf.nodevalue) 
103.             { 
104.                 if (root.hasleftchild == false) 
105.                 { 
106.                     root.leftchild = leaf; 
107.                 } 
108.                 else 
109.                 { 
110.                     InsertIntoBST(root.leftchild,leaf); 
111.                 } 
112.             } 
113.             else if (root.nodevalue < leaf.nodevalue) 
114.             { 
115.                 if (root.hasrightchild == false) 
116.                 { 
117.                     root.rightchild = leaf; 
118.                 } 
119.                 else 
120.                 { 
121.                     InsertIntoBST(root.rightchild, leaf); 
122.                 } 
123.             } 
124.         } 
125.     } 
126. } 

如果改变插入叶子节点的顺序，得到的树也是不一样的。例如下面的顺序。

1. InsertIntoBST(node_6, node_5); 
2. InsertIntoBST(node_6, node_6); 
3. InsertIntoBST(node_6, node_4); 
4. InsertIntoBST(node_6, node_2); 
5. InsertIntoBST(node_6, node_7); 
6. InsertIntoBST(node_6, node_9); 
7. InsertIntoBST(node_6, node_1); 
8. InsertIntoBST(node_6, node_8); 
9. InsertIntoBST(node_6, node_12); 
10. InsertIntoBST(node_6, node_10); 
11. InsertIntoBST(node_6, node_3); 
12. InsertIntoBST(node_6, node_11);