数据结构基础(16) --树与二叉树

树的基本术语

1.结点:{数据元素+若干指向子树的分支}

2.结点的度:分支的个数（子树的个数）

3.树的度:树中所有结点的度的最大值

4.叶子结点:度为零的结点

5.分支结点:度大于零的结点(包含根和中间结点)

6.(从根到结点的)路径：由从根到该结点所经分支和结点构成;

7.结点的层次:假设根结点的层次为1,则根的孩子为第2层，如果某节点在第L层,则其子树的根在L+1层。

8.树的深度:树中叶子结点所在的最大层次;

 

二叉树

    二叉树或为空树，或是由一个根结点加上两棵分别称为左子树和右子树的、互不交的二叉树组成。(树的度最大为2)

二叉树的重要性质:

性质1:在二叉树的第i层上至多有2^(i-1)个结点(i≥1);

性质2:深度为 k 的二叉树上至多含 (2^k)-1个结点(k≥1);

性质3:对任何一棵二叉树，若它含有n0 个叶子结点（0度结点）、n2 个度为 2的结点，则必存在关系式：n0 = n2+1。

 

两类特殊的二叉树:

  满二叉树:指的是深度为k且含有(2^k)-1个结点的二叉树。

  完全二叉树:树中所含的 n 个结点和满二叉树中编号为 1 至 n 的结点一一对应。(编号的规则为，由上到下，从左到右。如上图所示)

    完全二叉树的特点：

1.叶子节点出现在最后2层

2.对于任意结点，若其右分支下的子孙的最大层次为L,则左分支下的子孙的最大层次为L或L+1;

 

性质4:具有n个结点的完全二叉树的深度为[logn](向下取整)+1。

性质5:若对含 n 个结点的完全二叉树从上到下且从左至右进行 1 至 n 的编号，则对完全二叉树中任意一个编号为 i 的结点：

(1) 若 i=1，则该结点是二叉树的根，无双亲，否则，编号为 [i/2](向下取整)的结点为其双亲结点；
(2) 若 2i>n，则该结点无左孩子，否则，编号为 2i 的结点为其左孩子结点；
(3) 若 2i+1>n，则该结点无右孩子结点，否则，编号为2i+1 的结点为其右孩子结点。

 

二叉树的链式存储实现

说明:

    由于这篇博客仅仅是为了演示二叉树的理论, 因此代码所做的封装性以及可用性都不理想, 但由于在实际应用中, 也基本上不可能这样直接的使用二叉树, 因此也就没怎么优化他, 在此首先给大家说声抱歉;

 

二叉树节点构造

[cpp] view plaincopy

1. template <typename Type>  
2. class TreeNode  
3. {  
4.     friend class BinaryTree<Type>;  
5. //因为此处仅仅是为了演示, 因此将之定义为public  
6. public:  
7.     TreeNode(const Type &_data = Type(), TreeNode *_left = NULL, TreeNode *_right = NULL)  
8.         : data(_data), leftChild(_left), rightChild(_right) { }  
9.   
10.     Type data;  
11.     TreeNode *leftChild;  
12.     TreeNode *rightChild;  
13. };  

二叉树构造:

[cpp] view plaincopy

1. template <typename Type>  
2. class BinaryTree  
3. {  
4. public:  
5.     //二叉树可以进行的操作  
6.     BinaryTree():root(NULL) {}  
7.     bool isEmpty() const  
8.     {  
9.         return root == NULL;  
10.     }  
11.     //先序遍历  
12.     void preOrder() const  
13.     {  
14.         return preOrder(root);  
15.     }  
16.     //中序遍历  
17.     void inOrder() const  
18.     {  
19.         return inOrder(root);  
20.     }  
21.     //后续遍历  
22.     void postOrder() const  
23.     {  
24.         return postOrder(root);  
25.     }  
26.     //层次遍历  
27.     void levelOrder() const;  
28.   
29. private:  
30.     void preOrder(const TreeNode<Type> *rootNode) const;  
31.     void inOrder(const TreeNode<Type> *rootNode) const;  
32.     void postOrder(const TreeNode<Type> *rootNode) const;  
33.     void visit(const TreeNode<Type> *node) const;  
34.   
35. //因为此处仅仅是为了演示, 因此将之定义为public  
36. public:  
37.     TreeNode<Type> *root;  
38. };  

先(根)序的遍历算法：

1.若二叉树为空,则直接返回;

2.否则

    (1)访问根结点(visit);

    (2)先序遍历左子树;

    (3)先序遍历右子树;

[cpp] view plaincopy

1. //实现  
2. template <typename Type>  
3. void BinaryTree<Type>::preOrder(const TreeNode<Type> *subTree) const  
4. {  
5.     if (subTree != NULL)  
6.     {  
7.         visit(subTree);  
8.   
9.         preOrder(subTree->leftChild);  
10.         preOrder(subTree->rightChild);  
11.     }  
12. }  

中(根)序的遍历算法：

1.若二叉树为空树，则空操作；

2.否则

    (1)中序遍历左子树；

    (2)访问根结点；

    (3)中序遍历右子树。

[cpp] view plaincopy

1. //实现  
2. template <typename Type>  
3. void BinaryTree<Type>::inOrder(const TreeNode<Type> *subTree)const  
4. {  
5.     if (subTree != NULL)  
6.     {  
7.         inOrder(subTree->leftChild);  
8.         visit(subTree);  
9.         inOrder(subTree->rightChild);  
10.     }  
11. }  

后(根)序的遍历算法：

1.若二叉树为空树，则空操作；

2.否则

    (1)后序遍历左子树；

    (2)后序遍历右子树；

    (3)访问根结点。

[cpp] view plaincopy

1. //实现  
2. template <typename Type>  
3. void BinaryTree<Type>::postOrder(const TreeNode<Type> *subTree)const  
4. {  
5.     if (subTree != NULL)  
6.     {  
7.         postOrder(subTree->leftChild);  
8.         postOrder(subTree->rightChild);  
9.         visit(subTree);  
10.     }  
11. }  

层次遍历算法与visit操作：

[cpp] view plaincopy

1. template <typename Type>  
2. void BinaryTree<Type>::levelOrder() const  
3. {  
4.     std::queue< TreeNode<Type>* > queue;  
5.     queue.push(root);  
6.   
7.     while (!queue.empty())  
8.     {  
9.         TreeNode<Type> *currentNode = queue.front();  
10.         queue.pop();  
11.   
12.         visit(currentNode);  
13.         if (currentNode->leftChild != NULL)  
14.             queue.push(currentNode->leftChild);  
15.         if (currentNode->rightChild != NULL)  
16.             queue.push(currentNode->rightChild);  
17.     }  
18. }  

[cpp] view plaincopy

1. template <typename Type>  
2. void BinaryTree<Type>::visit(const TreeNode<Type> *currentNode) const  
3. {  
4.     cout << currentNode->data << ' ';  
5. }  

二叉树构造与运用示例

构造一颗如下的二叉树:

[cpp] view plaincopy

1. //代码如下  
2. int main()  
3. {  
4.     BinaryTree<char> tree;  
5.     TreeNode<char> addition('+'), subtraction('-'), multiplies('*'), divides('/');  
6.     TreeNode<char> a('A'), b('B'), c('C'), d('D'), e('E');  
7.   
8.     tree.root = &addition;  
9.     addition.leftChild = &subtraction;  
10.     addition.rightChild = &e;  
11.     subtraction.leftChild = &multiplies;  
12.     subtraction.rightChild = &d;  
13.     multiplies.leftChild = ÷s;  
14.     multiplies.rightChild = &c;  
15.     divides.leftChild = &a;  
16.     divides.rightChild = &b;  
17.   
18.     cout << "preOrder: ";  
19.     tree.preOrder();  
20.     cout << endl;  
21.     cout << "inOrder: " ;  
22.     tree.inOrder();  
23.     cout << endl;  
24.     cout << "postOrder: ";  
25.     tree.postOrder();  
26.     cout << endl;  
27.   
28.     cout << "level Order";  
29.     tree.levelOrder();  
30.     cout << endl;  
31.       
32.     return 0;  
33. }  

遍历算法的应用举例

    1.统计二叉树中叶子结点的个数(先序遍历)

    2.求二叉树的深度(后序遍历)

    3.复制二叉树(后序遍历)

原文地址：http://blog.csdn.net/zjf280441589/article/details/42611067