1 先序和中序构造二叉树 按层遍历二叉树

用先序和中序序列构造一棵二叉树（树中结点个数不超过10个），通过用队记录结点访问次序的方法实现对二叉树进行按层遍历，即按层数由小到大、同层由左到右输出按层遍历序列。

输入格式:

第一行输入元素个数

第二行输入先序序列，以空格隔开

第三行输入中序序列，以空格隔开

输出格式:

输出此二叉树的按层遍历序列，以空格隔开，最后也有一个空格。

输入样例:

5
10 20 40 30 50
20 40 10 50 30

输出样例:

10 20 30 40 50 

/*#include<stdio.h>
#include<malloc.h>
#define MaxSize 10
typedef struct BTNode
{
    int data;
    struct node *lchild;
    struct node *rchild;
}BTNode;

BTNode* CreatBT(int *pre,int *in,int n)
{
    //pre为先序序列，in为中序，n为结点个数
    BTNode *b;
    int *p;
    int k;
    if(n<=0)
        return NULL;
    b=(BTNode*)malloc(sizeof(BTNode));
    b->data=*pre;
    for(p=in;p<in+n;p++)
        if(*p==*pre)
            break;
    k=p-in;
    b->lchild=CreatBT(pre+1,in,k);
    b->rchild=CreatBT(pre+k+1,p+1,n-k-1);
    return b;
}

int main()
{
    int n;
    scanf("%d",&n);
    int pre[MaxSize];
    int in[MaxSize];
    for(int i=0;i<n;i++)
    {
        scanf("%d",&pre[i]);
    }
    for(int i=0;i<n;i++)
    {
        scanf("%d",&in[i]);
    }
    BTNode *b;
    
    return 0;
}*/
#include <stdio.h>
#include <stdlib.h>

// 定义二叉树节点结构体
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

// 创建新节点
struct TreeNode* createNode(int val) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        exit(1);
    }
    newNode->val = val;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 根据先序和中序序列构建二叉树
struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize) {
    if (preorderSize <= 0 || inorderSize <= 0) {
        return NULL;
    }
    
    int root_val = preorder[0];
    struct TreeNode* root = createNode(root_val);
    
    int inorder_index;
    for (inorder_index = 0; inorder_index < inorderSize; inorder_index++) {
        if (inorder[inorder_index] == root_val) {
            break;
        }
    }
    
    root->left = buildTree(preorder + 1, inorder_index, inorder, inorder_index);
    root->right = buildTree(preorder + 1 + inorder_index, preorderSize - 1 - inorder_index, 
                            inorder + inorder_index + 1, inorderSize - 1 - inorder_index);
    
    return root;
}

// 定义队列节点
struct QueueNode {
    struct TreeNode* data;
    struct QueueNode* next;
};

// 定义队列结构体
struct Queue {
    struct QueueNode *front, *rear;
};

// 创建队列
struct Queue* createQueue() {
    struct Queue* queue = (struct Queue*)malloc(sizeof(struct Queue));
    if (queue == NULL) {
        printf("Memory allocation failed\n");
        exit(1);
    }
    queue->front = queue->rear = NULL;
    return queue;
}

// 入队
void enqueue(struct Queue* queue, struct TreeNode* data) {
    struct QueueNode* newNode = (struct QueueNode*)malloc(sizeof(struct QueueNode));
    if (newNode == NULL) {
        printf("Memory allocation failed\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    if (queue->rear == NULL) {
        queue->front = queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

// 出队
struct TreeNode* dequeue(struct Queue* queue) {
    if (queue->front == NULL) {
        return NULL;
    }
    struct QueueNode* temp = queue->front;
    struct TreeNode* data = temp->data;
    queue->front = queue->front->next;
    if (queue->front == NULL) {
        queue->rear = NULL;
    }
    free(temp);
    return data;
}

// 按层遍历并输出结果
void levelOrderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    
    struct Queue* queue = createQueue();
    enqueue(queue, root);
    
    while (queue->front != NULL) {
        struct TreeNode* node = dequeue(queue);
        printf("%d ", node->val);
        
        if (node->left) {
            enqueue(queue, node->left);
        }
        if (node->right) {
            enqueue(queue, node->right);
        }
    }
    free(queue);
}

int main() {
    int n;
    scanf("%d", &n);
    
    int preorder[n];
    int inorder[n];
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &preorder[i]);
    }
    for (int i = 0; i < n; i++) {
        scanf("%d", &inorder[i]);
    }
    
    struct TreeNode* root = buildTree(preorder, n, inorder, n);
    
    levelOrderTraversal(root);
    
    return 0;
}