树以及树的遍历和搜索

逃离我推掉我的手 2022-08-10 00:53 135阅读 0赞

# 1. 数据结构定义 #

树是由一系列节点和节点之间的关系组成，递归定义描述如下：

*  若节点集合为空集，可以是一棵树；
 *  若节点集合非空，则由树根（root）以及零个或多个非空的子树（T1,T2...Tk）组成，root与其每棵子树的树根之间有一条边关联；

树的一个节点中除了存储本身包含的数据外，还要存储该节点的孩子节点、兄弟节点之间的关系，通常用的存储结构如下：

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 定义树节点数据结构  
2.  **struct** TNode \{  
3.      Element data; // 节点数据  
4.      TNode\* firstChild; // 第一个孩子节点  
5.      TNode\* nextSibling; // 相邻的下一个兄弟节点  
6.  \};

下图所示为一棵树的逻辑结构和存储结构：

![SouthEast][]

# 2. 树的遍历 #

## 2.1 三种遍历方式 ##

树的 三种遍历方式 都是以树的  **根节点为基准 **定义的，具体如下：

*  **前序遍历:  **  
    先访问根节点，然后依次访问子树；
 *  **中序遍历:  
     **先访问根节点的第一个孩子节点，然后访问根节点，最后依次访问剩下根节点的孩子节点；
 *  **后序遍历:  
     **先依次访问根节点的孩子节点，最后访问根节点.

## 2.2 递归实现 ##

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  \#include <iostream>  
2.  \#include <malloc.h>  
3.  **using** **namespace** std;  
4.    
5.  **typedef** **char** Element;  
6.    
7.  // 定义树节点数据结构  
8.  **struct** TNode \{  
9.      Element data; // 节点数据  
10.     TNode\* firstChild; // 第一个孩子节点  
11.     TNode\* nextSibling; // 相邻的下一个兄弟节点  
12. \};  
13.   
14. **void** visitNode(TNode\* node) \{  
15.     cout << node->data << "    ";  
16. \}  
17.   
18. // 递归实现三种树的遍历方式  
19. // 前序遍历： 先访问根节点，再依次访问孩子节点  
20. **void** preOrder(TNode\* root) \{  
21.     **if** (NULL == root)  
22.         **return**;  
23.     visitNode(root);  
24.     TNode\* child = root->firstChild;  
25.     **while** (NULL != child) \{  
26.         preOrder(child);  
27.         child = child->nextSibling;  
28.     \}  
29. \}  
30.   
31. // 后序遍历：先依次访问孩子节点，最后访问根节点  
32. **void** postOrder(TNode\* root) \{  
33.     **if** (NULL == root) \{  
34.         **return**;  
35.     \}  
36.     TNode\* child = root->firstChild;  
37.     **while** (NULL != child) \{  
38.         postOrder(child);  
39.         child = child->nextSibling;  
40.     \}  
41.     visitNode(root);  
42. \}  
43.   
44. // 中序遍历：先访问第一个孩子节点，然后访问根节点，最后一次访问剩下的孩子节点  
45. **void** inOrder(TNode\* root) \{  
46.     **if** (NULL == root) \{  
47.         **return**;  
48.     \}  
49.     TNode\* child = root->firstChild;  
50.     **if** (NULL != child) \{  
51.         inOrder(child);  
52.         child = child->nextSibling;  
53.     \}  
54.     visitNode(root);  
55.     **while** (NULL != child) \{  
56.         inOrder(child);  
57.         child = child->nextSibling;  
58.     \}  
59. \}  
60.   
61. // 销毁树  
62. **void** destory(TNode\* root) \{  
63.     **if** (NULL == root) \{  
64.         **return**;  
65.     \}  
66.     TNode\* child = root->firstChild;  
67.     TNode\* temp;  
68.     **while** (NULL != child) \{  
69.         temp = child->nextSibling;  
70.         destory(child);  
71.         child = temp;  
72.     \}  
73.     //cout << "destory " << root->data << endl;  
74.     free(root);  
75. \}

测试代码如下：

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  TNode\* initTree() \{  
2.      TNode \* root = (TNode\*) malloc(**sizeof**(TNode));  
3.      root->data = 'A';  
4.      root->nextSibling = NULL;  
5.    
6.      TNode \*child = (TNode\*) malloc(**sizeof**(TNode));  
7.      root->firstChild = child;  
8.    
9.      child->data = 'B';  
10.     child->firstChild = NULL;  
11.     child->nextSibling = (TNode\*) malloc(**sizeof**(TNode));  
12.   
13.     child = child->nextSibling;  
14.     child->data = 'C';  
15.     child->firstChild = NULL;  
16.     child->nextSibling = (TNode\*) malloc(**sizeof**(TNode));  
17.   
18.     child = child->nextSibling;  
19.     child->data = 'D';  
20.     child->firstChild = NULL;  
21.     child->nextSibling = NULL;  
22.   
23.     child = root->firstChild->nextSibling;  
24.     child->firstChild = (TNode\*) malloc(**sizeof**(TNode));  
25.     child = child->firstChild;  
26.     child->data = 'E';  
27.     child->firstChild = NULL;  
28.     child->nextSibling = (TNode\*) malloc(**sizeof**(TNode));  
29.   
30.     child = child->nextSibling;  
31.     child->data = 'F';  
32.     child->firstChild = NULL;  
33.     child->nextSibling = NULL;  
34.   
35.     **return** root;  
36. \}  
37.   
38. **int** main() \{  
39.     TNode \* tree = initTree();  
40.   
41.     cout << "PreOrder traversal Tree: " << endl;  
42.     preOrder(tree);  
43.     cout << endl << endl;  
44.   
45.     cout << "PostOrder traversal Tree: " << endl;  
46.     postOrder(tree);  
47.     cout << endl << endl;  
48.   
49.     cout << "InOrder traversal Tree: " << endl;  
50.     inOrder(tree);  
51.     cout << endl << endl;  
52.   
53.     destory(tree);  
54.   
55. \}

测试输出：

**\[plain\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  PreOrder traversal Tree:   
2.  A    B    C    E    F    D      
3.    
4.  PostOrder traversal Tree:   
5.  B    E    F    C    D    A      
6.    
7.  InOrder traversal Tree:   
8.  B    A    E    C    F    D

## 2.3 非递归实现 ##

递归方式实现使用了系统堆栈，效率不高，我们可以利用栈操作消除系统级别的递归，提高程序运行效率。

以下是三种遍历方式的非递归实现。

**前序遍历的非递归**算法相对简单，初始化时候将root入栈，对栈进行循环操作：先取栈顶节点为根节点，访问该节点并弹栈，然后将其子节点 ** 逆序** 入栈即可，如此循环直至栈为空。

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 非递归前序遍历  
2.  **void** nr\_preOrder(TNode\* tree) \{  
3.      **if** (NULL == tree) \{  
4.          **return**;  
5.      \}  
6.      stack<TNode\*> majorStack; // 主栈  
7.      stack<TNode\*> tempStack; // 辅助栈，子树根节点入主栈前逆序  
8.      majorStack.push(tree);  
9.      TNode\* p;  
10.     TNode\* child;  
11.   
12.     **while** (!majorStack.empty()) \{  
13.         p = majorStack.top();  
14.         majorStack.pop();  
15.         visitNode(p); // 访问该节点  
16.   
17.         // 将该节点的子节点入栈  
18.         child = p->firstChild;  
19.         **while** (NULL != child) \{  
20.             tempStack.push(child);  
21.             child = child->nextSibling;  
22.         \}  
23.         **while** (!tempStack.empty()) \{  
24.             majorStack.push(tempStack.top());  
25.             tempStack.pop();  
26.         \}  
27.     \}  
28.     p = child = NULL;  
29. \}

**后序遍历的非递归**算法过程中，从树根开始，对每个节点先顺着第一个孩子节点依次入栈，直到叶子节点，这时，取栈顶节点，访问该节点并弹栈，然后取该节点的下一个兄弟节点作为初始节点循环上述操作，直至栈为空。

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 非递归后序遍历  
2.  **void** nr\_postOrder(TNode\* tree) \{  
3.      **if** (NULL == tree) \{  
4.          **return**;  
5.      \}  
6.      //  
7.      stack<TNode\*>\* mStack = **new** stack<TNode\*>; // 主栈  
8.      TNode\* pNode = tree;  
9.      **while** (pNode != NULL || !mStack->empty()) \{  
10.         **while** (pNode != NULL) \{  
11.             mStack->push(pNode);  
12.             pNode = pNode->firstChild;  
13.         \}  
14.         **if** (!mStack->empty()) \{  
15.             pNode = mStack->top();  
16.             mStack->pop();  
17.             visitNode(pNode);  
18.             pNode = pNode->nextSibling;  
19.         \}  
20.     \}  
21.     pNode = NULL;  
22.     **delete** mStack;  
23. \}

**中序遍历非递归算法**实现相对复杂，主要是因为其父节点和第一个孩子及节点之外的孩子节点之间缺少直接联系（连续性）。

需要注意的是：孩子节点要先于根节点处理，所以要标记根节点的孩子节点是否已经处理过，这样才能避免无限循环。

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 非递归中序遍历  
2.  **void** nr\_inOrder(TNode\* tree) \{  
3.      **if** (NULL == tree) \{  
4.          **return**;  
5.      \}  
6.    
7.      stack<TNode\*> majorStack; // 主栈  
8.      stack<TNode\*> tempStack; // 辅助栈  
9.      stack<**bool**> flagStack; // 标志栈,记录根节点的第一个孩子节点是否处理过  
10.     majorStack.push(tree);  
11.     flagStack.push(tree->firstChild == NULL);  
12.   
13.     TNode\* p;  
14.     TNode\* temp;  
15.     **bool** flag;  
16.   
17.     **while** (!majorStack.empty()) \{  
18.         p = majorStack.top();  
19.         flag = flagStack.top();  
20.         **if** (!flag) \{  
21.             // 修改标记，表示该节点的孩子节点已经处理过  
22.             flagStack.pop();  
23.             flagStack.push(**true**);  
24.             // 将首个孩子节点入栈  
25.             temp = p->firstChild;  
26.             majorStack.push(temp);  
27.             flagStack.push(temp->firstChild == NULL);  
28.             **continue**;  
29.         \}  
30.   
31.         // 如果第一个孩子节点已经处理过  
32.         visitNode(p);  
33.         majorStack.pop();  
34.         flagStack.pop();  
35.   
36.         // 接着处理后序孩子节点  
37.         temp = p->firstChild;  
38.         **if** (temp != NULL) \{  
39.             temp = temp->nextSibling;  
40.         \}  
41.         **while** (NULL != temp) \{  
42.             tempStack.push(temp);  
43.             temp = temp->nextSibling;  
44.         \}  
45.         **while** (!tempStack.empty()) \{  
46.             temp = tempStack.top();  
47.             majorStack.push(temp);  
48.             flagStack.push(temp->firstChild == NULL);  
49.             tempStack.pop();  
50.         \}  
51.   
52.     \}  
53.     p = temp = NULL;  
54. \}

# 3. 树的搜索 #

## 3.1 深度优先 ##

深度搜索思路同树的前序遍历，在此基础上略微修改就可以了.

## 3.2 广度优先 ##

树的广度优先搜索策略是从根节点开始往下，逐层遍历访问，其实现方式是借助队列FIFO特性实现。

**\[cpp\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  // 广度优先搜索（Breadth-first search）  
2.  **int** bfs\_search(TNode\* tree, Element ele) \{  
3.      **if** (NULL == tree) \{  
4.          **return** 0;  
5.      \}  
6.      queue<TNode\*>\* sehQueue = **new** queue<TNode\*>;  
7.      TNode\* aNode;  
8.      TNode\* temp;  
9.      **int** flag = 0;  
10.   
11.     sehQueue->push(tree);  
12.     **while** (!sehQueue->empty()) \{  
13.         aNode = sehQueue->front();  
14.         cout << aNode->data << "\\t";  
15.         sehQueue->pop();  
16.         **if** (aNode->data == ele) \{  
17.             flag = 1;  
18.             **break**;  
19.         \}  
20.         temp = aNode->firstChild;  
21.         **while** (NULL != temp) \{  
22.             sehQueue->push(temp);  
23.             temp = temp->nextSibling;  
24.         \}  
25.     \}  
26.     **delete** sehQueue;  
27.     aNode = temp = NULL;  
28.   
29.     **return** flag;  
30. \}

链接：http://blog.csdn.net/whucyl/article/details/15513471

[view plain]: http://blog.csdn.net/whucyl/article/details/15513471#
[SouthEast]: /images/20220731/f25df06f0f75420c9c926ed21ee88262.png