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

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

 

C47BB9BE8D7145838FC340FDF109A3D6

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

          

  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); 

DB1698E3D3B546F1A111B209FBDD7BF6