树以及树的遍历和搜索

最新推荐文章于 2023-05-21 16:47:47 发布
最新推荐文章于 2023-05-21 16:47:47 发布
阅读量489 收藏 1
点赞数
分类专栏： 数据结构与算法




1. 数据结构定义

树是由一系列节点和节点之间的关系组成，递归定义描述如下：
  • 若节点集合为空集，可以是一棵树；
  • 若节点集合非空，则由树根（root）以及零个或多个非空的子树（T1,T2...Tk）组成，root与其每棵子树的树根之间有一条边关联；

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

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

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


2. 树的遍历


2.1 三种遍历方式

树的 三种遍历方式 都是以树的  根节点为基准 定义的，具体如下：
  • 前序遍历:  
    先访问根节点，然后依次访问子树；
  • 中序遍历:
         先访问根节点的第一个孩子节点，然后访问根节点，最后依次访问剩下根节点的孩子节点；
  • 后序遍历:
         先依次访问根节点的孩子节点，最后访问根节点.

2.2 递归实现

[cpp]  view plain copy print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  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 print ?
  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







tkp2014
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构visit函数_第10篇:C++ 数据结构-二叉树的遍历模式
weixin_39640262的博客
01-29 3303
二叉树的遍历方式树的遍历操作：就是以特定的顺序访问树中每个节点的过程，通过查找树中特定的节点，以便执行修改、删除、或获取数据值。我们在前一篇实现BST的查找、插入算法，其实就伴随实现了某种遍历算法。树并不像线性表那样遍历方式那么单一化，只有一个起始节点和结束节点就完事。从维度来理解，链表是一维的数据结构，树是一种二维的数据结构。可以理解树就是多个相关联的链表的超集。因为我们可以从任意一个非空节点沿...
「算法基础」之二叉树的遍历和搜索
码农的博客
02-25 2015
在二叉树相关的算法中，对于二叉树的搜索和遍历是绕不开的话题「绕开了当我没说😬」。如果你对二叉树的搜索、遍历还没有掌握的很清楚，那么咱就一起来康康。内容包括『二叉树的前序、中序、后序遍历的递归和迭代，以及深度优先搜索、广度优先搜索』 ，如果这几种都掌握了，也希望能看看有什么不对的地方，本算法菜鸟不胜感激。💐
JavaScript中的访问者模式
m0_75198698的博客
04-27 181
在上面的例子中，我们首先定义了一个Animal类作为动物的基类，同时也定义了具体的Cat、Dog和Bird类作为不同类型的动物。在上面的例子中，我们首先定义了一个Animal类作为动物的基类，同时也定义了具体的Cat、Dog和Bird类作为不同类型的动物。4. 具体元素(ConcreteElement)角色：实现了元素角色中定义的接受访问者的方法，通常情况下，具体元素角色会调用访问者角色中的方法。2. 具体访问者(ConcreteVisitor)角色：实现了访问者角色中定义的方法，具体实现了对元素的操作。
二叉树（二叉查找树）的遍历（前中后序），添加，查找，删除，节点个数等基础操作，java实现及代码演示。
m0_74000465的博客
05-21 783
二叉树是一种常用的树结构。对于树，我们称每一个节点的子节点个数为度；二叉树就是任意一个度小于等于2树，也就是说，二叉树中任意节点的子节点个数小于等于2；二叉查找树是指按照一定规则次序排列的二叉树，这种二叉树左子树的任意节点的值小于当前节点，右子树的任意节点的值大于当前节点，二叉查找树中不能有重复数据。这是我通过随意数据画出的二叉查找树，之后的操作都将用这组数据作为测试；
cocos 中每个节点的visit与draw函数
u012861978的专栏
05-24 1134
visit函数内会先调用自己的draw函数，然后变量所有子节点递归调用字节的visit： cocos渲染流程是从Director类的主循环mainLoop中开始： 1.调用drawScene()： //精简后的代码，方便理解 void Director::drawScene() { /*此处省略一些代码 ..... */ _renderer->clear(); pushMatrix(MATRIX_STACK_TYPE::MATRIX_ST..
二叉树遍历之后序遍历（非递归、递归）入门详解
热门推荐
sunnyoldboy博客
07-28 2万+
二叉树后序遍历不如先序遍历简单，是相对最复杂的一种遍历方法。访问结点的次序是：“左—>右—>根”，也就是首先访问左子树，之后访问右子树，最后访问树根。对于左、右子树而言，其访问的次序依然是“左—>右—>根”。也就是说，对于每一棵子树，都是最后访问树根。...
二叉搜索树 循环队列 与广度遍历
11-23
拥有良好扩展性的二叉搜索树，可供大学生学习
树的遍历
01-06
目录树的静态写法树的先根遍历树的层次遍历从树的遍历看DFS和BFS深度优先搜索（DFS）与先根遍历广度优先搜索（BFS）与层序遍历题型训练参考文档 树的静态写法 一般意义上的“树”与“二叉树”不太一样，它的子结点的...
xuehaiwuya.zip_树的遍历
09-24
算法有关于树的遍历的，还有图的搜索等等的数据结构相关算法
【剑指Offer】23.二叉搜索树的后序遍历序列（Python实现）
12-22
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。 解法一：递归法 # -*- coding:utf-8 -*- class Solution: def ...
Java实现 LeetCode 669 修剪二叉搜索树（遍历树）
01-20
给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。 示例 1: 输入: 1 ...
dom解析xml
Arthur的专栏
02-26 270
 public class DOMParser { public static void main(String argv[]) {  try {   // 创建XML文档解析器   DocumentBuilderFactory factory = DocumentBuilderFactory     .newInstance();   File xmlFile = new File("cat
如何定义visit函数_visit函数具体代码是什么啊
weixin_32944341的博客
02-05 8037
展开全部Visit函数是对数据元素操作的具体函数。void Visit(TNode *node){cout<value<}这样的样子;或者，比如要交换每个32313133353236313431303231363533e59b9ee7ad9431333431366264节点的左右子树，那就是：void Visit(TNode *node){TNode *temp = node->...
树的前序遍历、中序遍历、后序遍历及查找
Eliot的博客
04-19 2313
树的前序遍历、中序遍历、后序遍历及查找 近日学习了二叉树，之前对其遍历和操作有些疑惑，今天重新打了一遍代码好像悟了些许东西出来，浅浅的讲述一下吧。 首先是中规中矩的树图。 遍历 前序遍历 先上java实现代码 public void preOrder(){ //输出当前节点 System.out.println(this); //如果当前节点的左子树不为空，则递归调用 if (this.left != null){ this.left.preOrder(); } //如果当前节点的右子树不
遍历与搜索
qq_42752343的博客
08-10 419
一、二叉树的遍历 1.深度优先遍历DFT 在先L后R的前提下： 1）前序遍历V-L-R 2）中序遍历L-V-R（递增序列） 3）后续遍历L-R-V 前序遍历递归方式： vector<int> res; vector<int> PreOrderDFS(TreeNode* root) {//先序递归遍历 if(root==nullptr)//递归结束条件 return; res.push_back(root->val); //先访问当前根节点 PreOrd
树的遍历和搜索
mry_603的博客
04-04 354
树的学习记录
二叉树的遍历和查找
weixin_33961829的博客
05-31 216
前序遍历 若二叉树非空，则执行以下操作： 访问根结点； 先序遍历左子树； 先序遍历右子树 中序遍历 若二叉树非空，则执行以下操作： 中序遍历左子树； 访问根结点； 中序遍历右子树。 后序遍历 若二叉树非空，则执行以下操作： 后序遍历左子树； 后序遍历右子树； 访问根结点 实例说明 graph TD 3-->1 3-->5 1-->2 5-->4 5-->6...
关于搜索&遍历
地推
10-18 805
对于搜索来说，我们绝大多数情况下处理的都是叫“所谓的暴力搜索”，或者是说比较简单朴素的搜索，也就是说你在搜索的时候没有任何所谓的智能的情况在里面考虑，很多情况下它做的一件事情就是把所有的结点全部遍历一次，然后找到你要的结果。 基于这样的一个数据结构，如果这个数据结构本身是没有任何特点的，也就是说是一个很普通的树或者很普通的图。那么我们要做的一件事情就是遍历所有的结点。同时保证每个点访问一次且仅访问一次，最后找到结果。 那么我们先把搜索整个先化简情况，我们就收缩到在树的这种情况下来进行搜索...
深度优先遍历和广度优先遍历树
最新发布
09-03
深度优先遍历（Depth-First Search, DFS）和广度优先遍历（Breadth-First Search, BFS）是两种常见的树遍历算法。 深度优先遍历（DFS）是一种先遍历根节点，然后递归地遍历每个子节点的算法。它会尽可能深地探索树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值