Problem:
  实现二叉树的先序、中序、后序遍历,包括递归方式和非递归方式

Solution:
  切记递归规则:
  先遍历根节点,然后是左孩子,右孩子,
  根据不同的打印位置来确定中序、前序、后续遍历。

Code:

  

 #pragma once
 #include <iostream>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <string>
 #include <sstream>

 using namespace std;

 struct Node
 {
     int val;
     Node* lchild;
     Node* rchild;
     Node() :val(a), lchild(NULL), rchild(NULL) {}
 };

 void Create1(Node*& root, vector<int>num, int i)//前序构造树
 {
     )
         root = NULL;
     else if (i < num.size())
     {
         root = new Node(num[i]);
         Create1(root->lchild, num, i + );
         Create1(root->rchild, num, i + );
     }
 }

 void Create2(Node*& root, vector<int>num)//层序构造树
 {
     queue<Node*>q;
     root = ]);
     q.push(root);
     ;
     while (i < num.size() && !q.empty())
     {
         Node* p = q.front();
         q.pop();
         if (!p)//空节点p
             break;
         )
             p->lchild = new Node (num[i++]);
         )
             p->rchild = new Node (num[i++]);
         q.push(p->lchild);
         q.push(p->rchild);
     }
 }

 void PreTravel(Node* root)//前序遍历
 {
     if (!root)
         return;
     cout << root->val << "  ";
     PreTravel(root->lchild);
     PreTravel(root->rchild);
 }

 void NotPreTravel(Node* root)//非递归前序遍历
 {
     stack<Node*>s;
     if (root)
     {
         s.push(root);
         while (!s.empty())
         {
             root = s.top();
             cout << root->val << "  ";
             s.pop();
             if (root->rchild)
                 s.push(root->rchild);
             if (root->lchild)
                 s.push(root->lchild);
         }
     }
 }

 void MidTravel(Node* root)//中序遍历
 {
     if (!root)
         return;

     MidTravel(root->lchild);
     cout << root->val << "  ";
     MidTravel(root->rchild);
 }

 void NotMidTravel(Node* root)//非递归中序遍历
 {
     stack<Node*>s;
     if (root)
     {
         while (!s.empty() || root)
         {
             if (root)
             {
                 s.push(root);
                 root = root->lchild;
             }
             else
             {
                 root = s.top();
                 s.pop();
                 cout << root->val << "  ";
                 root = root->rchild;
             }
         }
     }
 }

 void LastTravel(Node* root)//后序遍历
 {
     if (!root)
         return;
     LastTravel(root->lchild);
     LastTravel(root->rchild);
     cout << root->val << "  ";
 }

 void NotLastTravel(Node* root)//非递归后序遍历
 {
     stack<Node*>s1;
     stack<Node*>s2;
     if (root)
     {
         s1.push(root);
         while (!s1.empty())
         {
             root = s1.top();
             s1.pop();
             s2.push(root);
             if (root->lchild)
                 s1.push(root->lchild);
             if(root->rchild)
                 s1.push(root->rchild);
         }
         while (!s2.empty())
         {
             root = s2.top();
             s2.pop();
             cout << root->val << "  ";
         }
     }
 }

 void NotLastTravel2(Node* root)//非递归后序遍历,使用一个栈
 {
     stack<Node*>s;
     if (root)
     {
         s.push(root);
         Node* p;
         while (!s.empty())
         {
             p = s.top();
             if (p->lchild && root != p->lchild && root != p->rchild)
                 s.push(p->lchild);
             else if (p->rchild && root != p->rchild )
                 s.push(p->rchild);
             else
             {
                 cout << p->val << "  ";
                 s.pop();
                 root = p;
             }
         }

     }
 }

 string getSpace(int num)
 {
     string space = " ";
     ; i < num; ++i)
         space.append(" ");
     return space;
 }

 void PrintShape(Node* root, int h, string c, int len)
 {
     if (root)
     {
         PrintShape(root->rchild, h + , "v", len);
         string val;
         stringstream ss;
         ss << root->val;
         ss >> val;
         val = c + val + c;
         int lenM = val.length();
         ;
         int lenR = len - lenM - lenL;
         val = getSpace(lenL) + val + getSpace(lenR);
         cout << getSpace(h*len) + val << endl;
         PrintShape(root->lchild, h + , "^", len);
     }

 }

 //直观地打印一颗树,即打印一横向的树,每个节点的左上角节点为其父节点
 void PrintTree(Node* root)
 {
     cout << "The shape of tree is: " << endl;
     cout << "===============================================" << endl;
     PrintShape(root, , );
     cout << "===============================================" << endl;
 }

 void Test()
 {
     //我们使用多种方法来构造一颗树:
     //                 1
     //            2            3
     //         4     5     6     7
     //        8 9  10 11 12 N  N  NULL
     //  使用层序遍历来打印树

     Node* root1 = NULL;
     vector<,,,,,,,,,,,-,,-,- };
     Create1(root1, num1, );//前序构造树

     Node* root2 = NULL;
     vector<,,,,,,,,,,,,-,-,-};
     Create2(root2, num2);//层序构造树

     cout << endl << "==============前序遍历============" << endl;
     PreTravel(root2);//前序遍历

     cout << endl << "===============中序遍历=============" << endl;
     MidTravel(root2);//中序遍历

     cout << endl << "===============后序遍历============" << endl;
     LastTravel(root2);//后序遍历

     cout << endl << "===============非递归前序遍历============" << endl;
     NotPreTravel(root2);//非递归前序遍历

     cout << endl << "===============非递归中序遍历============" << endl;
     NotMidTravel(root2);//非递归中序遍历

     cout << endl << "===============非递归后序遍历============" << endl;
     NotLastTravel2(root2);//非递归后序遍历

     cout << endl << "===============打印树============" << endl;
     PrintTree(root2);

     ;

 }

左神算法基础班4_1&2实现二叉树的先序、中序、后序遍历,包括递归方式和非递归的更多相关文章

  1. 左神算法基础班5_1设计RandomPool结构

    Problem: 设计RandomPool结构 [题目] 设计一种结构,在该结构中有如下三个功能: insert(key):将某个key加入到该结构,做到不重复加入. delete(key):将原本在 ...

  2. 左神算法进阶班1_5BFPRT算法

    在无序数组中找到第k大的数1)分组,每N个数一组,(一般5个一组)2)每组分别进行排序,组间不排序3)将每个组的中位数拿出来,若偶数,则拿上 / 下中位数, 成立一个一个新数组.4)新数组递归调用BF ...

  3. 左神算法进阶班3_1构造数组的MaxTree

    题目 一个数组的MaxTree定义: 数组必须没有重复元素 MaxTree是一棵二叉树,数组的每一个值对应一个二叉树节点 包括MaxTree树在内且在其中的每一棵子树上,值最大的节点都是树的头 给定一 ...

  4. 左神算法进阶班1_4Manacher算法

    #include <iostream> #include <string> using namespace std; //使用manacher算法寻找字符中最长的回文子串 in ...

  5. 左神算法进阶班1_1添加最少字符得到原字符N次

    Problem: 给定一个字符串str1,只能往str1的后面添加字符变成str2. 要求1:str2必须包含两个str1,两个str1可以有重合,但是不能以同一个位置开头. 要求2:str2尽量短最 ...

  6. 左神算法进阶班5_4设计可以变更的缓存结构(LRU)

    [题目] 设计一种缓存结构,该结构在构造时确定大小,假设大小为K,并有两个功能: set(key, value):将记录(key, value)插入该结构. get(key):返回key对应的valu ...

  7. 左神算法进阶班4_2累加和为aim的最长子数组

    [题目] 给定一个数组arr,和一个整数aim,求在arr中,累加和等于num的最长子数组的长度 例子: arr = { 7,3,2,1,1,7,7,7 } aim = 7 其中有很多的子数组累加和等 ...

  8. 左神算法进阶班8_1数组中累加和小于等于aim的最长子数组

    [题目] 给定一个数组arr,全是正数:一个整数aim,求累加和小于等于aim的,最长子数组,要求额外空间复杂度O(1),时间复杂度O(N) [题解] 使用窗口: 双指针,当sum <= aim ...

  9. 左神算法进阶班6_1LFU缓存实现

    [题目] LFU也是一个著名的缓存算法,自行了解之后实现LFU中的set 和 get 要求:两个方法的时间复杂度都为O(1) [题解] LFU算法与LRU算法很像 但LRU是最新使用的排在使用频率最前 ...

随机推荐

  1. jq-demo-放大镜

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...

  2. 打开桌面上的图标就会弹出"打开些文件可能会对您的计算机有害"解决方案

    问题截图 方案步骤 运行 gpedit.msc 用户配置--管理模板--windows组件--附件管理器 找到中等危险文件类型抱含列表后右键-编辑 在指定中等风险扩展名中加入你文件的扩展名 应用, 确 ...

  3. 【NOI2019模拟2019.7.4】朝夕相处 (动态规划+BM)

    Description: 题解: 这种东西肯定是burnside引理: \(\sum置换后不动点数 \over |置换数|\) 一般来说,是枚举置换\(i\),则\(对所有x,满足a[x+i]=a[i ...

  4. thinkphp环境要求

    框架本身没有什么特别模块要求,具体的应用系统运行环境要求视开发所涉及的模块.ThinkPHP底层运行的内存消耗极低,而本身的文件大小也是轻量级的,因此不会出现空间和内存占用的瓶颈. PHP版本要求 P ...

  5. 判断语句 (a>b)?a:b【转载】

    文章转载自https://blog.csdn.net/hyj1996818/article/details/81783513 今天刷题有看到一种我没学过的判断语句 感觉很高级的样子 我跟大家分享下我的 ...

  6. csp-s模拟测试98

    csp-s模拟测试98 $T1$??不是我吹我轻松手玩20*20.$T2$装鸭好像挺可做?$T3$性质数据挺多提示很明显? $One$ $Hour$ $Later$ 这$T1$什么傻逼题真$jb$难调 ...

  7. ps-使用通道抠图为XX换背景

    第一步先载入图片 点击通道,复制蓝色通道 然后点击新的蓝色通道,图像-调整-曲线-改变输入输出, 然后用历史画笔全部填黑.  然后载入选区,复制.在图层中新建蒙版 黏贴,反向(CTRL+I)就可以了. ...

  8. Spring核心接口之InitializingBean

    一.InitializingBean接口说明 InitializingBean接口为bean提供了属性初始化后的处理方法,它只包括afterPropertiesSet方法,凡是继承该接口的类,在bea ...

  9. 如何读懂Web服务的系统架构图

    Web服务的一个重要特点就是流量大.数据多,仅靠一台服务器肯定难以支撑大规模的服务. 所以我们经常会看到诸如以下的一些术语,教人好生不懂: *:系统架构.物理架构.Web服务基础设施 *:应用服务器 ...

  10. JAVA时间工具类用法

    1.获得N天前的TIMESTAMP Calendar cl = Calendar.getInstance(); cl.add(Calendar.DAY_OF_YEAR, -7); Date date ...