分层遍历二叉树

最新推荐文章于 2021-11-09 21:51:50 发布
最新推荐文章于 2021-11-09 21:51:50 发布
阅读量67 收藏
点赞数
文章标签： 数据结构与算法 c/c++

分层遍历二叉树
《编程之美》3.10
问题：给定一颗二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树（每一层单独输出一行），每一层要求访问的顺序为从左到右，并将节点依次编号。
解：
算法1
printNodeAtLevel(Node *root, int level)
if(level == 0 && root)
   输出root->data
   return
if(root==NULL)
   return
printNodeAtLevel(root->left, level-1)
printNodeAtLevel(root->right, level-1)
如果写成：
printNodeAtLevel(Node *root, int level)
if(level == 0)
   输出root->data
   return
if(root->left)
   printNodeAtLevel(root->left, level-1)
if(root->right)
   printNodeAtLevel(root->right, level-1)
可能出现的问题是：当二叉树为空时，在调用printNodeAtLevel的函数中需要判断：
if(root)
printNodeAtLevel(root,level)
而如果写成第一种形式，则无需判断
设二叉树的深度是deep
printTreeByLevel()
for(i=0;i<deep;i++)
   printfNodeAtLevel(root,i)
算法2
分析该算法，需额外求出二叉树的深度deep。
遍历每层节点均从根root开始，造成效率低下。在访问第k层节点的时候，只需要第k-1层的节点信息。因此，可以在打印第k-1层节点时，保留第k-1层的节点信息，从而避免每层遍历都从root开始。
vector<Node*> vecs; //用于保存各层节点信息
printNodeAtLevel(Node *root, int level)
if(level == 0 && root)
   输出root->data
   return
if(root==NULL)
   return
vec.push_back(root)
printNodeAtLevel(root->left, level-1)
printNodeAtLevel(root->right, level-1)
printTreeByLevel(Node *root)
vec.push_back(root)
cur=0
while(cur != vec.size())
   last = vec.size()
   while(cur != last)
    cout << vec[cur]->data<< “ ”;
    if(root->left)
     vec.push_back(root->left)
    if(root->right)
     vec.push_back(root->right)
    cur ++
   输出换行符
算法3：BFS
使用BFS的关键问题在于：输出换行符。采用了两种方法：一种是在每一行后插入一个空指针NULL来表示一行的结束；另一种方法使用两个队列，一个que1用来表示当前层的节点，另一个que2用来表示下一层的节点。
方法1
que.push(root)
while(true)
last=vec.size()
while(cur < lase)
   p=que[cur++]
   if(!p)
    cout << endl
    vec.push(0)
    break
   cout<<p->data
   if(p->left)
    vec.push(p->left)
   if(p->right)
    vec.push(p->right)
if(cur == que.size()-1 && que[cur]==NULL)
   break
方法2：使用两个队列
que1.push(root)
while(true)
while(que1非空)
   p= que1.pop()
   输出p
   if(p->left)
    que2.push(p->left)
   if(p->right)
    que2.push(p->right)
输出换行符
que1.swap(que2)
if(que1为空)
break
扩展问题：
要求按深度从下到上访问二叉树，每层的访问顺序依然是从左到右。
解：首先把各层节点（以0作为层的分隔符）存放在一个vec中，然后反向遍历vec
此时，需要注意的地方是：节点入vec的顺序是先右节点再左节点。

具体代码如下：
#include <iostream>
#include <vector>
#include <queue>
#include <deque>

using namespace std;

class Node{
public:
Node(int d):data(d), left(NULL), right(NULL){}

int data;
Node *left;
Node *right;
};

//algorithm 1
void printNodeAtLevelRecursion(Node *root, int level){
if (level == 0 && root)
{
   cout << root->data << " ";
   return;
}

if (root == NULL)
   return;

if (root->left)
   printNodeAtLevelRecursion(root->left, level-1);
if (root->right)
   printNodeAtLevelRecursion(root->right, level - 1);
}

int comDeep(Node *root){
if (root == NULL)
   return 0;
int leftDeep = comDeep(root->left);
int rightDeep = comDeep(root->right);
return leftDeep > rightDeep ? leftDeep + 1 : rightDeep + 1;
}

void printNode(Node *root){
int deep = comDeep(root);

for (int level = 0; level < deep; level ++){
   printNodeAtLevelRecursion(root, level);
   cout << endl;
}
}

// algorithm2
void printNodeAtLevel2(Node *root){
vector<Node*> vec;
vec.push_back(root);
int cur = 0;
int last;

while (true)
{
   last = vec.size();
   while (cur < last)
   {
    Node *p = vec[cur];
    cout << p->data << " ";
    cur ++;
    if (p->left)
     vec.push_back(p->left);
    if (p->right)
     vec.push_back(p->right);
   }
   cout << endl;

   if (cur == vec.size())
    break;
}
}

//algorithm3:BFS
void printNodeAtLevelBFS1(Node *root){
queue<Node*> que;
que.push(root);
que.push(0);

while (true)
{
   int size = que.size();
   while (true)
   {
    Node *p = que.front();
    que.pop();
    if (p == NULL){
     cout << endl;
     que.push(0);
     break;
    }

    cout << p->data << " ";
    if (p->left)
     que.push(p->left);
    if (p->right)
     que.push(p->right);
   }

   if (que.size() == 1 && que.front() == NULL)
    break;
}
}

void printNodeAtLevelBFS2(Node *root){
deque<Node*> que1, que2;
que1.push_back(root);

while (true)
{
   while (!que1.empty())
   {
    Node *p = que1.front();
    que1.pop_front();

    cout << p->data << " ";
    if (p->left)
     que2.push_back(p->left);
    if (p->right)
     que2.push_back(p->right);
   }

   cout << endl;
   que1.swap(que2);
   if (que1.empty())
    break;
}
}

//extensive question1:print node at level form down to up;point at each level: from left to right
void printNodeAtLevelDown2UpLeft2Right(Node *root){
vector<Node *> vec;
vec.push_back(root);
vec.push_back(0);
int cur = 0;

while (true)
{
   while (true)
   {
    Node *p = vec[cur ++];
    if (p == NULL)
    {
     vec.push_back(0);
     break;
    }

    if (p->right)
     vec.push_back(p->right);
    if (p->left)
     vec.push_back(p->left);
   }

   if (cur == vec.size()-1 && vec[cur] == 0)
    break;
}

vec.pop_back();
//traverse the vec in reverse order
cur = vec.size() - 2;
while (cur >= 0)
{
   if (vec[cur] == NULL)
   {
    cout << endl;
   }
   else{
    cout << vec[cur]->data << " ";
   }
   cur --;
}
cout << endl;
}

//extensive question1:print node at level form down to up;point at each level: from right to left
void printNodeAtLevelDown2UpRight2Left(Node *root){
vector<Node *> vec;
vec.push_back(root);
vec.push_back(0);
int cur = 0;

while (true)
{
   while (true)
   {
    Node *p = vec[cur ++];
    if (p == NULL)
    {
     vec.push_back(0);
     break;
    }
   
    if (p->left)
     vec.push_back(p->left);
    if (p->right)
     vec.push_back(p->right);
   }
  
   if (cur == vec.size()-1 && vec[cur] == 0)
    break;
}

vec.pop_back();
//traverse the vec in reverse order
cur = vec.size() - 2;
while (cur >= 0)
{
   if (vec[cur] == NULL)
   {
    cout << endl;
   }
   else{
    cout << vec[cur]->data << " ";
   }
   cur --;
}
cout << endl;
}


int main(){
Node *p1 = new Node(1);
Node *p2 = new Node(2);
Node *p3 = new Node(3);
Node *p4 = new Node(4);
Node *p5 = new Node(5);
Node *p6 = new Node(6);
Node *p7 = new Node(7);
Node *p8 = new Node(8);
p1->left = p2;
p1->right = p3;
p2->left = p4;
p2->right = p5;
p3->right = p6;
p5->left = p7;
p5->right = p8;
Node *root = p1;

cout << "test printNode***********" << endl;
printNode(root);
cout << "test printNodeAtLevel2************" << endl;
printNodeAtLevel2(root);
cout << "test printNodeAtLevelBFS1**************" << endl;
printNodeAtLevelBFS1(root);
cout << "test printNodeAtLevelBFS2**************" << endl;
printNodeAtLevelBFS2(root);
cout << "test printNodeAtLevelDown2UpLeft2Right**************" << endl;
printNodeAtLevelDown2UpLeft2Right(root);
cout << "test printNodeAtLevelDown2UpRight2Left**************" << endl;
printNodeAtLevelDown2UpRight2Left(root);
return 0;
}

 

 

之前重温本书写书评时，也尝试找寻更好的编程解法。今天把另一个问题的实现和大家分享。

问题定义

给定一棵二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树(每一层将单独输出一行)，每一层要求访问的顺序为从左到右，并将节点依次编号。下面是一个例子:

 

输出:

1

2 3

4 5 6

7 8

节点的定义:

?

1

2

3

4

5

struct Node {

    Node *pLeft;

    Node *pRight;

    int data;

};

书上的解法

书上举出两个解法。第一个解法是用递归方式，搜寻并打印某一层的节点，再打印下一层的节点。这方法简单但时间效率不高(但不需要额外空间)，因此书中亦提供了第二个解法。

书中第二个解法，使用vector容器来储存n个节点信息，并用一个游标变量last记录前一层的访问结束条件，实现如下:

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

void PrintNodeByLevel(Node* root) {

     vector<Node*> vec; // 这里我们使用STL 中的vector来代替数组，可利用到其动态扩展的属性

     vec.push_back(root);

     int cur = 0;

     int last = 1;

     while(cur < vec.size()) {

          Last = vec.size(); // 新的一行访问开始，重新定位last于当前行最后一个节点的下一个位置

          while(cur < last) {

               cout << vec[cur] -> data << " "; // 访问节点

               if(vec[cur] -> lChild) // 当前访问节点的左节点不为空则压入

                   vec.push_back(vec[cur] -> lChild);

               if(vec[cur] -> rChild) // 当前访问节点的右节点不为空则压入，注意左右节点的访问顺序不能颠倒

                   vec.push_back(vec[cur] -> rChild);

               cur++;

          }

          cout << endl; // 当cur == last时,说明该层访问结束，输出换行符

     }

}

广度优先搜索

书中没有提及，本问题其实是以广度优先搜索(breath-first search, BFS)去遍历一个树结构。广度优先搜索的典型实现是使用队列(queue)。其伪代码如下:

?

1

2

3

4

5

6

7

enqueue(Q, root)

do

    node = dequeue(Q)

    process(node) //如把内容列印

    for each child of node

        enqueue(Q, child)

while Q is not empty

书上的解法，事实上也使用了一个队列。但本人认为，使用vector容器，较不直觉，而且其空间复杂度是O(n)。

如果用队列去实现BFS，不处理换行，能简单翻译伪代码为C++代码:

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

void PrintBFS(Node* root) {

    queue<Node*> Q;

    Q.push(root);

    do {

        Node *node = Q.front();

        Q.pop();

        cout << node->data << " ";

        if (node->pLeft)

            Q.push(node->pLeft);

        if (node->pRight)

            Q.push(node->pRight);

    }

    while (!Q.empty());

}

本人觉得这样的算法实现可能比较清楚，而且空间复杂度只需O(m)，m为树中最多节点的层的节点数量。最坏的情况是当二叉树为完整，m = n/2。

之后的难点在于如何换行。

本人的尝试之一

第一个尝试，利用了两个队列，一个储存本层的节点，另一个储存下层的节点。遍历本层的节点，把其子代节点排入下层队列。本层遍历完毕后，就可换行，并交换两个队列。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

void PrintNodeByLevel(Node* root) {

    deque<Node*> Q1, Q2;

    Q1.push_back(root);

    do {

        do {

            Node* node = Q1.front();

            Q1.pop_front(); // Removes the first element in the list container, effectively reducing the list size by one.

            cout << node->data << " ";

            if (node->pLeft)

                Q2.push_back(node->pLeft);

            if (node->pRight)

                Q2.push_back(node->pRight);

        } while (!Q1.empty()); //q1不为空时把下一层的值都压入到q2中

        cout << endl;

        Q1.swap(Q2);  //交换q1，q2，此时q2为空，q1是上层的值

    } while(!Q1.empty());

}

本实现使用deque而不是queue，因为deque才支持swap()操作。注意，swap()是O(1)的操作，实际上只是交换指针。

这实现要用两个循环(书上的实现也是)，并且用了两个队列。能够只用一个循环、一个队列么?

本人的尝试之二

换行问题其实在于如何表达一层的结束。书上采用了游标，而第一个尝试则用了两个队列。本人想到第三个可行方案，是把一个结束信号放进队列里。由于使用queue<Node*>，可以插入一个空指针去表示一层的遍历结束。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

void PrintNodeByLevel(Node* root) {

    queue<Node*> Q;

    Q.push(root);

    Q.push(0);

    do {

        Node* node = Q.front();

        Q.pop();

        if (node) {

            cout << node->data << " ";

            if (node->pLeft)

                Q.push(node->pLeft);

            if (node->pRight)

                Q.push(node->pRight);

        }

        else if (!Q.empty()) {

            Q.push(0);

            cout << endl;

        }

    } while (!Q.empty());

}

这个实现的代码很贴近之前的PrintBFS()，也只有一个循环。注意一点，当发现空指针(结束信号)时，要检查队列内是否还有节点，如果没有的话还插入新的结束信号，则会做成死循环。

测试代码

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

void Link(Node* nodes, int parent, int left, int right) {

    if (left != -1)

        nodes[parent].pLeft = &nodes[left]; 

  

    if (right != -1)

        nodes[parent].pRight = &nodes[right];

}

  

void main()

{

    Node test1[9] = { 0 };

      

    for (int i = 1; i < 9; i++)

        test1[i].data = i;

  

    Link(test1, 1, 2, 3);

    Link(test1, 2, 4, 5);

    Link(test1, 3, 6, -1);

    Link(test1, 5, 7, 8);

  

    PrintBFS(&test1[1]);

    cout << endl << endl;

  

    PrintNodeByLevel(&test1[1]);

    cout << endl;

}

结语

第一个尝试是几个月前做的，没想到今晚写博文又想到了第二个尝试。两个尝试难分优劣，但两种思维或许也可以解决其他问题。还有其他方法么？

 

weixin_34186931
关注
CSDN每日一练 |『小艺读书』『小Q的鲜榨柠檬汁』『分层遍历二叉树』2023-10-19
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
10-19 3652
🟢 编程路上，每日一练，不断精进！🔊『小艺读书』『小Q的鲜榨柠檬汁』『分层遍历二叉树
二叉树的分层遍历
无他
06-10 1825
二叉树的分层遍历 二叉树的分层遍历， 换行打印。 下面的代码将解释如何实现换行打印。 分层遍历使用队列queue，按层次将节点推入队列，并在弹出时将节点的左右节点推入队列。 换行打印使用for循环，定义n=队列长度，遍历该行的所有节点后，跳出for循环，打印换行，再重新赋值队列长度n,重新进入下一行的for循环。 //定义Treenode class Treenode{ int val;...
面试题23：从上到下层次遍历二叉树
wakaka的博客
07-14 648
给定一棵二叉树，从上到下，从左到右打印二叉树的结点，层次遍历。
编程之美-分层遍历二叉树
My_Jobs的专栏
02-03 1989
问题：给定一个二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树（每一层将单独输出一行），每一层要求访问的顺序为从左到右，并将节点依次编号。那么分层遍历如图的二叉树，正确的输出应该为：
关于二叉树的分层遍历及其笔试题延伸（数据结构）
m0_51405559的博客
11-09 182
文章目录一、二叉树的分层遍历二、二叉树的层序遍历（LeetCode）1.题目描述2.输入输出示例3.思路分析4.代码实现三、层序遍历Ⅱ（LeetCode）1.题目描述2.输入输出示例3.思路分析4.代码实现 一、二叉树的分层遍历 直接遍历不现实，因为越往后结点越多，而且并不是每层结点都是2k-1。 如果遍历一个结点后，将该结点的孩子保存起来，下一次从结构中获取，这里保存孩子采用队列（先放入空间中的结点先被访问）来实现。 步骤： 1.先需要new一个队列—>将来队列中放置的元素就是结点的引用 ..
二叉树------层序遍历
风月冷
05-31 255
题目描述： 给定一棵二叉树，要求从上到下按层输出。（每一层按从左到右的顺序） 思路： 按照按层创建二叉树的方法，使用一个队列。先将根节点入队，然后每次从队中取出队首元素，并将其左右子节点入队，持续此过程知道队列为空。（NULL不入队）#include <iostream> #include <deque> #include <stdio.h> using namespace std; #def
编程之美 - 分层遍历二叉树
NGC 6786
10-31 1262
问题描述 一棵二叉树，按从上到下，从左到右的方式进行遍历，打印它的所有的节点。 例如二叉树 输出的结果为 a bc def   思路: 二叉树遍历的方式为分层方式 每一层都可以看做是一个链表，根节点level 0可以看做只有一个元素的链表。当遍历level 0时，可以同时将根节点的左右子树放入level 1的链表中。当遍历level1的链表时可以同理生成
二叉树层次遍历c语言_每日一LeetCode题（107二叉树的层次遍历 II）
weixin_39752828的博客
12-10 195
给定一个二叉树，返回其节点值自底向上的层次遍历。(即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历)例如：给定二叉树[3,9,20,null,null,15,7], 3 /\ 920/\157返回其自底向上的层次遍历为：[ [15,7], [9,20], [3] ]链接：...
【树】二叉树的镜像（递归）、树的子结构（递归）难、从上往下打印二叉树（层次遍历）、二叉搜索树的后序遍历序列（递归）难、二叉树的深度（递归）
努力努力再努力0.0的博客
03-16 209
题目描述 操作给定的二叉树，将其变换为源二叉树的镜像。 输入描述: 二叉树的镜像定义：源二叉树 8 / \ 6 10 / \ / \ 5 7 9 11 镜像二叉树 8 / \ 10 6 / \ / \ 11 9 7 5 ...
有关二叉树的广义表建立和按层次遍历
xiaoling_315的专栏
05-08 584
<br />#include "stdio.h"<br />#include "malloc.h"<br />#include "string.h"<br />#include "stdlib.h"<br />#define OK 1<br />#define ERROR 0<br />#define OVERFLOW -1<br />#define MAXSIZE 100<br />typedef char ElemType;<br />struct BiNode{<br /> ElemType data
3.10 分层遍历二叉树
_今已亭亭如盖矣
06-02 473
题目：给定一棵二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树(每一层将单独输出一行)，每一层要求访问的顺序为从左到右，并将节点依次编号。下面是一个例子:输出:1 2 3 4 5 6 7 8代码：结构体的定义：struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int
从下至上按层遍历二叉树
qiaoXiong的技术博客
11-16 4255
题目来源：北航14级5系数据结构作业 问题描述】  给定一颗二叉树，要求从下至上按层遍历二叉树，每层的访问顺序是从左到右，每一层单独输出一行。 【输入形式】  广义表表示的二叉树，结点元素类型为整型，且都大于0，例如：1( 2( 3 ( 4, 5 ) ), 6( 7, 8( 9, 10 ) ) ) 【输出形式】  从下至上，打印每一层的结点元素值，元素间以空格隔开。每层的访
leetcode----给定一个二叉树，返回该二叉树由底层到顶层的层序遍历，（从左向右，从叶子节点到根节点，一层一层的遍历）
sunnnnh的博客
10-01 1875
知识点： 1.list.add(下标，值)。 每次在下标0处插入元素时，自动将列表中的元素后移 例如，依次向列表中的0位置插入12 13 14 import java.util.ArrayList; public class TestOne { public static void main(String[] args) { // TODO Auto-generated method stub ArrayList<Integer> list = new ArrayList
迭代实现二叉树分层遍历：层次结构与广度优先探索
分层遍历二叉树是一种在二叉树中按照层级顺序访问节点的算法，它遵循从上到下、从左到右的规则。在计算机科学中，这种遍历方式特别适用于需要按层次展示数据结构的应用，例如在图形用户界面（GUI）中的树状视图或者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值