二叉搜索树建立与层序遍历（BFS）

二叉搜索树，根据树的基础，小于当前节点，插入节点的左边；数据大于当前节点，插入节点的右边。

层序遍历：每次遍历树的一层，当这一层的所有节点都遍历完再遍历下一层。

与先序遍历的区别：先序遍历是从一条路一直走到底（也就是最后一层的某个节点）。

DFS：一条路走到底，走到尽头再回退再走。（走迷宫，一条路走到底，行不通就回到上一个岔路口，回溯）

BFS：将下一步可以走的可能全部走一遍，走完后，再走下一步走后，所有的可能。（例如眼镜掉地上，先把一米内的范围找一遍，再找1-2米范围内的地区）

代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
//树节点的结构体
typedef struct mytree 
{
    int data; //数据
    struct mytree* l; //左子节点
    struct mytree* r;  //右子节点
}TREE;

TREE* Build(TREE* root);//建立二叉搜索树

vector<TREE*> queue;  //队列，储存的是某个节点的结构体  
void BFS(TREE* root);  //广搜的函数，将树层序遍历的结果入队

int main(void)
{
    TREE* root = NULL;
    int n;//n个节点
    cin >> n;
    //建立树
    for (int i = 1; i <= n; i++)
        root = Build(root);

    //层序遍历
    BFS(root);

    return 0;
}

TREE* Build(TREE* root)
{
    TREE* node = new TREE;
    int data;
    cin >> data;
    node->data = data;
    node->l = NULL;
    node->r = NULL;


    //寻找合适的位置插入新节点
    if (root == NULL)  //如果根节点为空
        root = node;
    else
    {
        //p用于遍历，p1记录p之前的位置
        TREE* p = root;  
        TREE* p1 = p;

        while (p != NULL) //循环直到找到可以插入的节点
        {
            if (data < p->data)
            {
                p1 = p;
                p = p->l;
            }
            else
            {
                p1 = p;
                p = p->r;
            }
        }
        //插入节点
        if (data < p1->data) p1->l = node;
        else p1->r = node;

        
    }

    return root;
}

void BFS(TREE* root)
{
    queue.push_back(root); //插入根节点，因为第一个输出必然为根节点
    while (!queue.empty())//如果队列非空
    {
        //当前节点的左右子节点入队
        if (queue.front()->l != NULL)
            queue.push_back(queue.front()->l);
        if (queue.front()->r != NULL)
            queue.push_back(queue.front()->r);

        cout << queue.front()->data << ' ';
        queue.erase(queue.begin()); //打印后弹出第一个元素
    }
}