静态二叉链表，（多个子节点的存储方式也用静态多叉链表来实现）

   静态二叉链表：节点的左右指针域用 int 代替，用来表示左右子树的根节点在数组中的下标；
所有动态生成的结点（链表实现）都用数组中的节点代替，所以对指针的操作都改为对数组下标的访问；

/**
    静态二叉链表：节点的左右指针域用 int 代替，用来表示左右子树的根节点在数组中的下标；
    所有动态生成的结点（链表实现）都用数组中的节点代替，所以对指针的操作都改为对数组
    下标的访问；
*/

/**
#include <iostream>
#include <queue>

using namespace std;

struct TNode
{
    int data;
    int lchild,rchild;
};

const int maxn = 1100;

struct TNode Bin[maxn];

int idx = 0;
int NewNode(int v) ;  //申请一个节点
void Search(int root,int x,int newdata) ;//将值等于 x 的结点的值换成 newdata
void Insert(int &root,int x);    //在合适的位置插入一个节点
int Create(int *d,int n);    //建一棵二叉树
void preorder(int root); //前序遍历一棵树
void midorder(int root); //中序遍历一棵树
void behorder(int root); //后序遍历一棵树
void layorder(int root); //层次遍历一棵树

int main()
{
    int n;
    cin >> n;
    int a[n];
    for(int i=0;i<n;++i)
        cin >> a[i];
    int root = Create(a,n);
    puts("\n前序遍历：");
    preorder(root);

    puts("\n中序遍历:");
    midorder(root);

    puts("\n后序遍历：");
    behorder(root);

    puts("\n层次遍历：");
    layorder(root);

    return 0;

}

int NewNode(int v)  //申请一个节点
{
    Bin[idx].data = v;
    Bin[idx].lchild = Bin[idx].rchild = -1;
    return idx++; //返回这个结点下标，并将结点的下标加一
}

void Search(int root,int x,int newdata) //将值等于 x 的结点的值换成 newdata
{
    if(root != -1)
    {
        if(Bin[root].data == x)
            Bin[root].data = newdata;
        Search(Bin[root].lchild , x , newdata);
        Search(Bin[root].rchild , x , newdata);
    }
}

void Insert(int &root,int x)    //在合适的位置插入一个节点
{
    if(root == -1)
    {
        root = NewNode(x);
        return ;
    }

    
///    if(由二叉树的性质x应该插在左子树)
///        Insert(Bin[root].lchild , x);
///    else
///        Insert(Bin[root].rchild , x);
    

    if(x < Bin[root].data)
        Insert(Bin[root].lchild , x);
    else
        Insert(Bin[root].rchild , x);
}

int Create(int *d,int n)    //建一棵二叉树
{
    int root = -1;
    for(int i=0;i<n;++i)
        Insert(root , d[i]);
    return root;
}

void preorder(int root) //前序遍历一棵树
{
    if(root != -1)
    {
        printf("%d ",Bin[root].data);
        preorder(Bin[root].lchild);
        preorder(Bin[root].rchild);
    }
}


void midorder(int root) //中序遍历一棵树
{
    if(root != -1)
    {
        midorder(Bin[root].lchild);

        printf("%d ",Bin[root].data);

        midorder(Bin[root].rchild);
    }
}


void behorder(int root) //后序遍历一棵树
{
    if(root != -1)
    {
        behorder(Bin[root].lchild);

        behorder(Bin[root].rchild);

        printf("%d ",Bin[root].data);
    }
}

void layorder(int root) //层次遍历一棵树
{
    queue<int> q;
    q.push(root);

    while(q.size())
    {
        int top = q.front();
        q.pop();

        printf("%d ",Bin[top].data);
        if(Bin[top].lchild != -1)
            q.push(Bin[top].lchild);
        if(Bin[top].rchild != -1)
            q.push(Bin[top].rchild);
    }
}
*/

 当节点的孩子结点超过两个时，此时使用二叉树的静态写法最合适，此时的孩子节点用一个 vector 容器来存储；

/// DFS 遍历一棵树时与采用树的先序遍历得到的序列是一样的；

/// BFS遍历一棵树与用层次遍历一棵树时得到的序列是一样的；

/**
    当节点的孩子结点超过两个时，此时使用二叉树的静态写法最合适，此时的孩子节点用一个 vector 容器来存储；
*/


#include <iostream>
#include <queue>

using namespace std;

struct TNode
{
    int data;
    vector<int> child;
};

const int maxn = 1100;

struct TNode Bin[maxn];

int idx = 0;
int NewNode(int v) ;  //申请一个节点
void preorder(int root); //前序遍历一棵树
void layorder(int root); //层次遍历一棵树

int main()
{
    int n;
    cin >> n;
    int a[n];
    for(int i=0;i<n;++i)
        cin >> a[i];

    puts("\n前序遍历：");
    int root=0;
    preorder(root);

    puts("\n层次遍历：");
    layorder(root);

    return 0;

}

int NewNode(int v)  //申请一个节点
{
    Bin[idx].data = v;
    Bin[idx].child.clear(); //清空子节点
    return idx++; //返回这个结点下标，并将结点的下标加一
}


/// DFS 遍历一棵树时与采用树的先序遍历得到的序列是一样的；
void preorder(int root) //前序遍历一棵树
{
    printf("%d ",Bin[root].data);
    for(int i=0;i<Bin[root].child.size();++i)
        preorder(Bin[root].child[i]);
}


/// BFS遍历一棵树与用层次遍历一棵树时得到的序列是一样的；
void layorder(int root) //层次遍历一棵树
{
    queue<int> q;
    q.push(root);

    while(q.size())
    {
        int top = q.front();
        q.pop();

        printf("%d ",Bin[top].data);

        for(int i=0;i<Bin[top].child.size();++i)
            q.push(Bin[root].child[i]);
    }
}