二叉樹是一種特殊的樹結構：每個節點最多有兩個子節點。

　　二叉樹的性質：

　　（1）二叉樹第i層的節點數目最多為 2^{i-1} (i≥1)。

　　（2）深度為k的二叉樹至多有2^{k}-1個結點(k≥1)。

　　（3）包含n個結點的二叉樹的高度至少為log₂ (n+1)。

　　（4）在任意一棵二叉樹中，若終端結點的個數為n₀，度為2的結點數為n₂，則n₀=n₂+1。

實現：

bitTree.h

 1 #pragma once
 2 
 3 #include <iostream>
 4 
 5 struct tree
 6 {
 7     int data;
 8     tree *liftChild, *rightChild;
 
 9 };
10 
11 class bitTree
12 {
13 public:
14     bitTree();
15     ~bitTree();
16 
17     void insertTree(int data);
18 
19     //前序遍歷
20     void preorder(tree *p);
21     //中序遍歷
22     void interthem(tree *p);
23     //後序遍歷
24     void postorder(tree *p);
25 
26     //計算二叉樹節點數
27     int count(tree *p);
28
 
     //統計葉子節點數
29     int findLeafNum(tree *p);
30 
31     //獲取二叉樹根節點
32     tree *getRoot();
33 
34     static int leafNum;
35 
36 private:
37     tree *root;
38 };

bitTree.cpp

 1 int bitTree::leafNum = 0;
 2 
 3 bitTree::bitTree()
 4 {
 5     root = NULL;
 6 }
 7 
 8 
 9 bitTree::~bitTree()
 
10 {
11 }
12 
13 void bitTree::insertTree(int data)
14 {
15     tree *newTree = new tree;
16     newTree->data = data;
17     newTree->liftChild = newTree->rightChild = NULL;
18 
19     if (NULL == root)
20         root = newTree;
21     else
22     {
23         tree *backup = NULL;
24         tree *current = root;
25         while (current != NULL)
26         {
27             backup = current;
28             if (current->data > data)
29                 current = current->liftChild;
30             else
31                 current = current->rightChild;
32         }
33         if (backup->data > data)
34             backup->liftChild = newTree;
35         else
36             backup->rightChild = newTree;
37     }
38 }
39 
40 void bitTree::preorder(tree * p)
41 {
42     if (p != NULL)
43     {
44         std::cout << p->data << " ";
45         preorder(p->liftChild);
46         preorder(p->rightChild);
47     }
48 }
49 
50 void bitTree::interthem(tree * p)
51 {
52     if (p != NULL)
53     {
54         interthem(p->liftChild);
55         std::cout << p->data << " ";
56         interthem(p->rightChild);
57     }
58 }
59 
60 void bitTree::postorder(tree * p)
61 {
62     if (p != NULL)
63     {
64         postorder(p->liftChild);
65         postorder(p->rightChild);
66         std::cout << p->data << " ";
67     }
68 }
69 
70 int bitTree::count(tree *p)
71 {
72     if (NULL == p)
73         return 0;
74     else
75         return count(p->liftChild) + count(p->rightChild) + 1;
76 }
77 
78 int bitTree::findLeafNum(tree *p)
79 {
80     if (NULL == p)
81         return 0;
82     else
83     {
84         if (p->liftChild == NULL && p->rightChild == NULL)
85             return leafNum += 1;
86         else
87         {
88             findLeafNum(p->liftChild);
89             findLeafNum(p->rightChild);
90         }
91         return leafNum;
92     }
93 }
94 
95 tree * bitTree::getRoot()
96 {
97     return root;
98 }

碼海拾遺：二叉樹的遍歷（遞歸實現）