二叉树的静态实现

/*
    二叉树的静态实现
*/
struct node{
    typename data;//数据域 
    int lchild;//指向左孩子的指针域 
    int rchild;//指向右孩子的指针域 
}Node[maxn];//结点数组,maxn为结点上限个数 

//二叉树的建立,函数返回根节点root的下标 
int create(/*typename data[],int n*/){//每个节点所对应的值(当然了,也可以在设置为全局变量),以及总的结点个数 
    int root = -1;
    for(int i=0; i<n; i++){
        insert(root,data[i]);//将节点数据插入二叉树中 
    }
    return root;//返回二叉树的根节点下标 
} 

//插入,root为根节点在数组中的下标 
void insert(int &root,typename x){//记得加引用 
    if(root == -1){//空树,查找失败,即也是插入的位置 
        root = newNode(x);//给root赋以新的结点 
        return;
    } 
    if(/*由二叉树的性质,x应该插在左子树*/){
        insert(Node[root].lchild,x);//往左子树搜索(递归式) 
    }else{
        insert(Node[root].rchild,x);//往右子树搜索(递归式) 
    }
} 

int index = 0;//1还是0,由题目意思决定,从零开始还是从一开始
int newNode(typename v){//分配一个Node数组中的结点给新的结点,index为其下标 
    Node[index].data = v;//数据域 
    Node[index].lchild = -1;//-1或者maxn为空 
    Node[index].rchild = -1;
    return index++;
} 

//查找和修改,root为根节点在数组中的下标 
void search(int root, typename x, typename newdata){
    if(root == -1){
        return;//边界 
    } 
    if(Node[root].data == x){
        //输出或者修改
        Node[root].data = newdata;
    }
    //递归搜索 
    search(Node[root].lchild,x,newdata); 
    search(Node[root].rchild,x,newdata);
} 

//关于二叉树的遍历
//前序遍历
void preorder(int root){
    if(root == -1){
        return;
    }
    cout << Node[root].data;
    preorder(Node[root].lchild);
    preorder(Node[root].rchild);
} 

//中序遍历
void inorder(int root){
    if(root == -1){
        return;
    }
    inorder(Node[root].lchild);
    cout << Node[root].data;
    inorder(Node[root].rchild);
}

//后序遍历
void postorder(int root){
    if(root == -1){
        return;
    }
    postorder(Node[root].lchild);
    postorder(Node[root].rchild);
    cout << Node[root].data;
} 

//层序遍历
void layerOrder(int root){
    queue<int> q;
    q.psuh(root);
    while(!q.empty()){
        int now = q.front();
        q.pop();
        cout << Node[now].data << " ";
        if(Node[now].lchild != -1){
            q.push(Node[now].lchild);
        }
        if(Node[now].rchild != -1){
            q.push(Node[now].rchild);
        }
    }
}