笔记-静态二叉链表

静态二叉链表

不使用指针，而使用数组完成二叉树所有操作

结点左右指针域使用int代替，用来表示左右子树的根结点在数组中的下标
对指针的操作改为对数组下标的访问

struct node{
    typename data;
    int lchild;   //指向左子树的指针域
    int rchild;   //指向右子树的指针域
}Node[maxn];

int index = 0;

int newNode(int v){  //分配一个Node数组中的结点给新的结点， index为其下标
    Node[index].data = v;
    Node[index].lchild = -1;
    Node[index].rchild = -1;  //-1和maxn表示空   因为数组范围是 0-maxn
    return index++;
}

查找(root为根结点在数组中的下标)

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);  //往左子树递归
    search(Node[root].rchild, x, newdata);  //往右子树递归
}

插入

void insert(int &root, int x){  // root前加&引用
    if(root == -1){  // 空树 查找失败  插入  递归边界
        root = newNode(x);
        return;
    }
    if(){
        insert(Node[root].lchild, x);
    }else{
        insert(Node[root].rchild, x);
    }
}

建立

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);
    }
}

来源：https://blog.csdn.net/qq_41664688/article/details/100124703