分层遍历二叉树

最新推荐文章于 2021-06-25 21:11:12 发布

disappearedgod

最新推荐文章于 2021-06-25 21:11:12 发布

阅读量1.2k

点赞数

分类专栏：数据结构面试文章标签：数据结构面试

本文链接：https://blog.csdn.net/disappearedgod/article/details/24501659

版权

面试同时被 2 个专栏收录

32 篇文章 0 订阅

订阅专栏

数据结构

27 篇文章 0 订阅

订阅专栏

作者：disappearedgod

文章出处：http://blog.csdn.net/disappearedgod/article/details/24501659

时间：2014-4-25

分层遍历二叉树

《编程之美-3.10》P252

题目

给定一棵二叉树，压球按分层遍历该二叉树，即从上到下按层次访问该二叉树（每一层将单独输出一行），每一层要求访问的顺序为从左到右，并将节点依次编号。分层输出二叉树。

example：

GVEditdigraph G{ 1-> 2;1-> 3; 2->4;2->5; 3->6; 3->7; 4->A; 6->B }

struct Node{
  int data;
  Node* lChild;
  Node* rChild;
}

void PrintNodeByLevel(Node* root){};

输出为：

2 3

4 5 6

7 8

并写出另外一个函数，打印二叉树中某层次的节点（从左到右），其中根节点为第0层，函数原型为int PrintNodeAtLevel(Node* root, int level),成功返回1，失败则返回0.

思路

1.二叉树的分层遍历主要看如何递归

2. 先写出针对某层的遍历后，在写针对所有层的遍历。

解法

对于层次遍历

int PrintNodeAtLevel(Node* root, int level){
    int res = -1; 
    res = PrintNodeAtLevelret(root,level);
    return (res>0)?1:0;
}
int PrintNodeAtLevelret(Node* root, int level){
    bool ret =false;
    if(!root||level<0)
        return 0;
    if(level == 0)
    {
        count << root ->data  <<" ";       
    }
    return PrintNodeAtLevel(root->lChild,level -1)+PrintNodeAtLevel(root->lChild,level -1);
}

采用递归算法，思路清晰。

缺点：递归函数调用效率低，时空复杂。

void PrintNodeByLevel(Node* root,int depth){
    for(int level = 0; level<depth; level++){
        PrintNodeAtLevelret(root,level);
    }
}
void PrintNodeByLevel(Node* root){
     for(int level =0; ; level++){
         if(!PrintNodeAtLevelret(root, level))
             break;
         count<<endl;
     }
}

非递归实现

使用vector容器来储存n个节点信息，并用一个游标变量last记录前一层的访问结束条件

void PrintNodeByLevel(Node* root){
     if(!root)
         return;
     vector<Node> vec;
     
     vec.push_back(root);
     int cur = 0;
     int last = 1;
     while(cur<vec.size()){
         last = vec.size();
         while(cur<last){
             cout<<vec[cur]->data<<" ";
             if(vec[cur]->lChild)
                 vec.push_back(vec[cur]->lChild);
             if(vec[cur]->lChild)
                 vec.push_back(vec[cur]->rChild);
             cur++;
         }
         cout<<endl;
     }
}

测试代码

BFS打印

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());
}

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];
}

主程序

int 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;
    return 0;
}