二叉树的遍历

因为顺序存储只需要遍历数组即可，所以这里只给出链式存储情况下的遍历

分为三种遍历：前序遍历，中序遍历和后序遍历，还有深度优先遍历和广度优先遍历（层次遍历）

前，中，后指的根的_date的位置

前序遍历：

void Pre_order(point e)
{
    if(e != nullptr)
    {
        cout << e->_data << endl;
        Pre_order(e->_left);
        Pre_order(e->_right);
    }
}

中序遍历：

void Ino_order(point e)
{
    if(e != nullptr)
    {
        Pre_order(e->_left);
        cout << e->_data << endl;
        Pre_order(e->_right);
    }
}

后序遍历：

void Pos_order(point e)
{
    if(e != nullptr)
    {
        Pre_order(e->_left);
        Pre_order(e->_right);
        cout << e->_data << endl;
    }
}

可以看到只有输出位置变化了，其他没有变化

#include <bits/stdc++.h>

using namespace std;

typedef struct list_point
{
    int _date;
    struct list_point *_left,*_right;
}*point;

void Pre_order(point e)
{
    if(e != nullptr)
    {
        cout << e->_date << endl;
        Pre_order(e->_left);
        Pre_order(e->_right);
    }
}

void Ino_order(point e)
{
    if(e != nullptr)
    {
        Pre_order(e->_left);
        cout << e->_date << endl;
        Pre_order(e->_right);
    }
}

void Pos_order(point e)
{
    if(e != nullptr)
    {
        Pre_order(e->_left);
        Pre_order(e->_right);
        cout << e->_date << endl;
    }
}


int main()
{
    point head = (point)malloc(sizeof(list_point));
    head->_left = nullptr;
    head->_right = nullptr;
    head->_date = 1;

    point left = (point)malloc(sizeof(list_point));
    left->_left = nullptr;
    left->_right = nullptr;
    left->_date = 2;

    point right = (point)malloc(sizeof(list_point));
    right->_left = nullptr;
    right->_right = nullptr;
    right->_date = 3;

    head->_left = left;
    head->_right = right;

    Pre_order(head);
    Ino_order(head);
    Pos_order(head);
    return 0;
}

 另外，BFS和DFS也经常用到

BFS（层次遍历）：

void BFS(point e)
{
    deque<point> d;
    d.push_back(e);
    while(!d.empty())
    {
        auto t = d.front();
        cout << t->_date << endl;
        if(t->_left != nullptr) d.push_back(t->_left);
        if(t->_right != nullptr) d.push_back(t->_right);
        d.erase(d.begin());
    }
}

DFS：

void DFS(point e)
{
    if(e != nullptr)
    {
        cout << e->_date << endl;
        if(e->_left != nullptr) DFS(e->_left);
        if(e->_right != nullptr) DFS(e->_right);
    }
    else
    {
        return;//其实没有必要，这一步压根进不去
    }
}

 他们一个是进行到底，一个是全面进行

#include <bits/stdc++.h>

using namespace std;

typedef struct list_point
{
    int _date;
    list_point *_left,*_right;
}*point;

void BFS(point e)
{
    deque<point> d;
    d.push_back(e);
    while(!d.empty())
    {
        auto t = d.front();
        cout << t->_date << endl;
        if(t->_left != nullptr) d.push_back(t->_left);
        if(t->_right != nullptr) d.push_back(t->_right);
        d.erase(d.begin());
    }
}

void DFS(point e)
{
    if(e != nullptr)
    {
        cout << e->_date << endl;
        if(e->_left != nullptr) DFS(e->_left);
        if(e->_right != nullptr) DFS(e->_right);
    }
    else
    {
        return;
    }
}

int main()
{
    point head = (point)malloc(sizeof(list_point));
    head->_left = nullptr;
    head->_right = nullptr;
    head->_date = 1;

    point left = (point)malloc(sizeof(list_point));
    left->_left = nullptr;
    left->_right = nullptr;
    left->_date = 2;

    point right = (point)malloc(sizeof(list_point));
    right->_left = nullptr;
    right->_right = nullptr;
    right->_date = 3;

    head->_left = left;
    head->_right = right;

    BFS(head);
    DFS(head);

    return 0;
}