再谈二叉树

由于树结构经常是面试官拷问的知识点，掌握好它是必须的，又看了些资料，再试着记录一点心得。

一般无规律的树没什么意义,太复杂面试时间也有限。所以主要讨论的是二元搜索树(binary search tree)

二元搜索树的优势是查找很快。时间复杂度是O(log₂(n))，也常写成O(log(n)).
因为比如

    70
   /  /
  50   90
 / /   / /
40 45 80 120
 

查询40这个节点，需要3次遍历，整个树节点是7。  于是有这个关系
       2^x = n (x代表次数， n代表节点树(data size))

       x = log₂n 

这种指数级的速度是很快的。2的10次方等于1204， 在这里等效为最多10次就可以从1024个数据中找出需要的节点来。

不过如果二叉树左右分布不均的话，甚至每个节点只有一个右节点，这样就成了链结构，就失去了该优势。

代码：

结构定义:

1. typedef struct nodeT
2. {
3.     struct nodeT *left;
4.     struct nodeT *right;
5.     int value;
6. }node;

初始化二元搜索树

1. #include <assert.h>
2. #define NUM 7
4. int data[NUM] = {70, 50, 90, 40, 45, 80, 120};
6. /*
7. input:
8. data: 新节点data值
9. return:
10. 新节点指针
11. */
13. PNode newNode(int data)
14. {
15.     PNode p = (PNode)malloc(sizeof(Node));
16.     assert( p != NULL);
17.     p->data = data;
18.     p->lChild = NULL;
19.     p->rChild = NULL;
20.     return p;
21. }
23. /* 
24. return:
25.   false:插入重复data值节点
26.   true: 成功构建
27. */
29. bool CreateBTree(PNode &root)
30. {
31.     int i;
32.     root = newNode(data[0]);
33.     PNode p;
34.     PNode parent;
35.     for (i=1; i<NUM; i++)
36.     {
37.         p = root;
38.         while (p != NULL)
39.         {
40.             // 保存插入节点的父节点
41.             parent = p;
42.             if (data[i] > p->data)
43.                 p = p->rChild;
44.             else if (data[i] < p->data)
45.                 p = p->lChild;
46.             // 要求节点data值不重复
47.             else
48.                 return false;
49.         }
50.         if (p == NULL)
51.         {
52.             // 新建节点，设置其data值和父节点
53.             p = newNode(data[i]);
54.             //p->parent = parent;
55.             if (p->data < parent->data)
56.                 parent->lChild = p;
57.             else
58.                 parent->rChild = p;
59.         }
60.     }
61.     return true;
62. }

遍历:

1. void PreOrderTraversal(PNode root)
2. {
3.     if (root == NULL)
4.         return;
5.     else
6.     {
7.         // printf的位置决定了三种遍历方法
8.         printf("%d ", root->data);
9.         PreOrderTraversal(root->lChild);
10.         PreOrderTraversal(root->rChild);
11.     }
12. }

查询节点：

1. /*
2. params:
3.   value: 寻找data值为value的节点
4. return:
5.   成功: 返回该节点
6.   失败: 返回NULL
7. */
9. PNode SearchNode(PNode root, int value)
10. {
11.     if (root == NULL)
12.         return NULL;
13.     
14.     PNode p = root;
15.     while (p)
16.     {
17.         if (p->data < value)
18.             p = p->rChild;
19.         else if (p->data > value)
20.             p = p->lChild;
21.         else
22.             return p;
23.     }   
24.     return NULL;
25. }

增加父节点

1. PNode newNode(int data)
2. {
3.     PNode p = (PNode)malloc(sizeof(Node));
4.     assert( p != NULL);
5.     p->data = data;
6.     p->lChild = NULL;
7.     p->rChild = NULL;
8.     p->parent = NULL;   //添加
9.     return p;
10. }
12. /*
13. 添加父节点
14. */
15. void AddParent(PNode root)
16. {
17.     PNode p;
18.     if (root == NULL)
19.         return;
20.     p = root;
21.     if (root->lChild != NULL)
22.     {
23.         root->lChild->parent = p;
24.         AddParent(root->lChild);
25.     }
26.     if (root->rChild != NULL)
27.     {
28.         root->rChild->parent = p;
29.         AddParent(root->rChild);
30.     }
31. }