6二叉树的存储结构与遍历

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

typedef struct TreeNode{
    struct TreeNode *left,*right;
    int data;
}node;

//根据输出顺序的不同分为先序，中序，后序
void traverse(Node *node)
{
 	if(node==NULL)
    {
        return;
	}
    //printf("%d",node->data);
    //先中间，再左右
    traverse(node->left);
    //printf("%d",node->data);
    //先左，再中，后右
    traverse(node->right);
    //printf("%d",node->data);
    //先左右，再中间
}

//层序遍历：一层一层输出
//使用队列实现
//实现方法：从根节点入队，出队后将其左右孩子入队，再循环这个操作

//层序遍历：一层一层输出
//使用队列实现
//实现方法：从根节点入队，出队后将其左右孩子入队，再循环这个操作
#include<stdio.h>
#include<stdlib.h>
#define SIZE 5
int *queue;
int front;
int end;
int maxSize;

typedef struct ChildBro{
    int key;
    struct ChildBro *child;
    struct ChildBro *sibling;
}Node;

Node *root;		//根指针


void Initqueue()
{
    queue=(int *)malloc(sizeof(int)*SIZE);
    maxSize=SIZE;
    front=end=0;
}

void insert_queue(int key)
{
    if(isFull())
    {
        return;
	}
    else
    {
        end=(end+1)%maxSize;
        queue[end]=key;
    }
}

void delete_queue(int key)
{
    if(isEmpty())
    {
        return;
	}
    else
    {
        front=(front+1)%maxSize;
        
    }
    
}

int isFull()
{
    if((end+1)%maxSize==front)
    {
        return 1;
	}
    else
        return 0;
}

int isEmpty()
{
    if(end==front)
    {
        return 1;
	}
    else
        return 0;
}


void Init(int key)
{
    root=(Node*)malloc(sizeof(Node));
    root->key=key;
    root->child=NULL;
    root->silbing=NULL;
    
}

void insert(int key,int parent)
{
    //定位结点
    
    Node* temp;
    
    if(temp==NULL)
    {
        
    }
    else
    {
        Node*node=(Node*)malloc(sizeof(Node));
        node->key=key;
        node->child=NULL;
        node->sibling=NULL;
        if(temp->child==NULL)
        {
            temp->child=node;
        }
        else
        {
            node->sibling=temp->child;
            temp->child=node;
        }
    }
}

//层序遍历核心函数
void levelOrder(Node* root)
{
    //传进来的结点不为空
    if(root!=NULL)
    {
        insert_queue(root->key);
        
    }
    while(!isEmpty())//一直循环至队列为空
    {
        int temp=delete_queue();//元素出队
        get_node(root,temp);
        if(tempNode->child!=NULL)
        {
            insert_queue(tempNode->child->key)
                
        }
        if(tempNode->sibling!=NULL)
        {
            insert_queue(tempNode->sibling->key)
                
        }
        
        
    }
}