11二叉树的层次遍历

二叉树的层次遍历

使用队的数据结构来实现

层次遍历：ABCDEFG，一层一层的遍历
实现原理：使用队，每进队一个根就出队一个根，并且进队这个根的左孩子和右孩子

实现

初始化

#include <stdio.h>
#include <stdlib.h>

typedef struct TreeNode {
    char data;
    struct TreeNode* lchild;
    struct TreeNode* rchild;
} TreeNode;

typedef struct QueueNode {
    TreeNode* data;
    struct Queue* pre;
    struct Queue* next;
} QueueNode

void createTree(TreeNode** T, char* data; int * index) {
    char ch;
    ch = data[*index];
    *index += 1;
    if (ch == '#') {
        *T = NULL;
    } else {
        *T = (TreeNode*)malloc(sizeof(TreeNode));
        (*T) -> data = ch;
        createTree(&((*T) -> lchild), data, index);
        createTree(&((*T) -> rchild), data, index);
    }
}

QueueNode* initQueue() {
    QueueNode* Q = (QueueNode*)malloc(sizeof(QueueNode));
    Q -> data =NILL;
    Q -> next = Q;
    Q -> pre = Q;
    //实现队用双链表
    return Q;
}

void enQueue(TreeNode*data, QueueNode* Q) {
    QueueNode* node = (QueueNode*)malloc(sizeof(QueueNode));
    node -> data = data;
    node -> pre = Q -> pre;
    node -> next = Q;
    Q -> pre -> next = node;
    Q -> pre = node;
}


int isEmpty(Queue* Q) {
    if (Q -> next == Q) {
        rturn 1;
    } else {
        return 0;
    }
}

QueueNode* deQueue(QueueNode* Q) {
    if (isEmpty(Q)) {
        return NULL;
    } else {
        QueueNode* p = Q -> next;
        Q -> next -> next -> pre = Q;
        Q -> next = Q -> next -> next;
        return p;
    }
}

int main(int argc, char* argv[])
{
    TreeNode* T;
    QueueNode* Q = initQueue();
    int index = 0;
    createTree(&T, argv[1], &index);
    levelTraverse(Q, T);
    
    return 0;
}

算法实现

void levelTraverse(QueueNode* Q, TreeNode* T) {
    enQueue(T, Q);
    while(!isEmpty(Q)) {
        QueueNode* node = deQueue(Q);
        printf("%c ", node -> data -> data);
        if (node -> data -> lchild) {
            enQueue(node -> data -> lchild, Q);
        }
        if (node -> data -> rchild) {
            enQueue(node -> data -> rchild, Q);
        }
    }
}