层次遍历-二叉搜索树

①层次遍历的核心思想

就是利用队列化二叉树结构为线性结构 ， 先进的先输出 ， 后来的后处理
先把父节点入队 ， 输出父节点 ， 删除父节点 ， 返回父节点指针 ，
利用 指针 把左右儿子都入队
接着把新得到的指针的左右儿子再次入队 ， 输出以前的左儿子 ，
然后到了以前的右儿子，把以前右儿子的两个儿子入队，重复此套路

②图片示例说明

③层次遍历代码

树的头文件

#ifndef TREE_H_INCLUDED
#define TREE_H_INCLUDED
using namespace std;
typedef class Tree *PtrTree;
class Tree
{
public :
    int      Data;
    PtrTree  Left;
    PtrTree Right;
    PtrTree  Next;
    Tree() : Data(0) , Left(nullptr) , Right(nullptr) , Next(nullptr){}
    explicit Tree(int Data_) : Data(Data_) , Left(nullptr) , Right(nullptr) , Next(nullptr){}
    Tree(const Tree & t)
    {
        Data = t.Data;
        Left = t.Left;
        Right= t.Right;
    }
    void add(Tree & t)
    {
        if(t.Data < Data)
        {
            if(Left == nullptr)
                Left = &t;
            else
                Left->add(t);
        }
        else if(t.Data > Data)
        {
            if(Right == nullptr)
                Right = &t;
            else
                Right->add(t);
        }
    }
    Tree & operator=(const Tree & source)
    {
        if(&source == this)
            return *this;
        Data = source.Data;
        return *this;
    }
    friend ostream & operator<<(ostream & os , const Tree & t)
    {
        os << t.Data << '\n';
        return os;
    }
    bool isLeftNull() {return Left == nullptr;}
    bool isRightNull(){return Right == nullptr;}
};
#endif // TREE_H_INCLUDED

队列的头文件

#ifndef QUEUE_H_INCLUDED
#define QUEUE_H_INCLUDED
#include "Tree.h"
class Queue
{
private:
    int      Size;
    PtrTree  Rear;
    PtrTree Front;
public:
    Queue() : Size(0) , Rear(nullptr) , Front(nullptr){}
    bool isEmpty()const
    {
       return Size == 0;
    }
    void enQueue(PtrTree source)
    {
        if(Front == nullptr)
            Front = source;
        else
            Rear->Next = source;
        Rear = source;
        Size++;
    }
    PtrTree  deQueue()
    {
        if(isEmpty())
            return nullptr;
        PtrTree tmp = Front;
        Front = Front->Next;
        Size--;
        if(Size == 0)
            Rear = nullptr;
        return tmp;
    }
};


#endif // QUEUE_H_INCLUDED

主函数

#include <iostream>
#include "Tree.h" // 因为是自定义的头文件 ， 因此需要加上双引号 ， 否则找不到头文件
#include "Queue.h"
using namespace std;
const int MAX = 10;
using namespace std;
Tree t[MAX] =
{ //调用默认构造函数 ， 自定义有参数的构造器 ，复制构造函数 ， 和赋值运算符 ， 因此我头文件全部都是自定 义的
   Tree(100) , Tree(80) , Tree(90) , Tree(95) , Tree(98) , Tree(110) , Tree(120) , Tree(70)  , Tree(88) , Tree(86)
};
Queue q = Queue();
void  Layer();
int main()
{
    for(int i = 1 ; i < MAX ; i++)
        t[0].add(t[i]);
    PtrTree Iterator = &t[0];
    q.enQueue(Iterator);
    Layer();
    return 0;
}
void  Layer()
{
    while(!q.isEmpty())
    {
        PtrTree T = q.deQueue();
        cout << T->Data << endl;
        if(!T->isLeftNull())
            q.enQueue(T->Left);
        if(!T->isRightNull())
            q.enQueue(T->Right);
    }
}

输出结果