静态树定义常用操作无测试

const int maxn = 100;
struct node{
    int data;//数据域
    int lchild; //指向左子树的指针域
    int rchild; //指向右子树的指针域
}Node[maxn];

int index = 0;
int newNode(int v){
    Node[index].data = v;
    Node[index].lchild = -1;
    Node[index].rchild = -1;
    return index++;
}

void search(int root,int x,int newdata){
    if(root == -1){
        return ;
    }
    if(Node[root].data == x){
        Node[root].data = newdata;
    }
    search(Node[root].lchild, x, newdata); //往左子树搜索x(递归式)
    search(Node[root].rchild, x, newdata); //往右子树搜索x(递归式)
}

//插入,root为根节点在数组中的下标
void insert(int &root,int x){
    if(root == -1){
        root = newNode(x);
        return ;
    }
    if(1){
        insert(Node[root].lchild,x);
    }else{
        insert(Node[root].rchild,x);
    }
}

//二叉树的建立,函数返回根结点root的下标
int Create(int data[],int n) {
    int root = -1; //新建根结点
    for(int i = 0;i< n;i++){
        insert(root,data[i]);
    }
    return root;
}

//先序遍历
void preorder(int root){
    if(root == -1){
        return ;//到达空数，递归边界
    }
    printf("%d\n",Node[root].data);
    preorder(Node[root].lchild);
    preorder(Node[root].rchild);
}
//中序遍历
void inorder(int root){
    if(root == -1){
        return ;
    }
    //访问左子树
    inorder(Node[root].lchild);
    printf("%d\n",Node[root].data);

    inorder(Node[root].rchild);
}
void postorder(int root){
    if(root == -1){
        return ;
    }
    postorder(Node[root].lchild);

    postorder(Node[root].rchild);
    printf("%d\n",Node[root].data);
}
//层序遍历
void LayerOrder(int root){
    queue<int> q;
    q.push(root);
    while(!q.empty()){
        int now = q.front();
        q.pop();
        printf("%d ",Node[now].data); //访问队首元素
        if(Node[now].lchild != -1) q.push(Node[now].lchild);
        if(Node[now].rchild != -1) q.push(Node[now].rchild);
    }
}
int main(){
    //存储1号节

    return 0;
}

标签：Node,lchild,定义,静态,data,int,测试,rchild,root
来源： https://blog.csdn.net/m0_37149062/article/details/122702432