《剑指Offer》面试题：从上往下打印出二叉树的每个节点

/*
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
输入：
输入可能包含多个测试样例，输入以EOF结束。
对于每个测试案例，输入的第一行一个整数n(1<=n<=1000, ：n代表将要输入的二叉树元素的个数（节点从1开始编号）。接下来一行有n个数字,代表第i个二叉树节点的元素的值。接下来有n行，每行有一个字母Ci。
Ci=’d’表示第i个节点有两子孩子，紧接着是左孩子编号和右孩子编号。
Ci=’l’表示第i个节点有一个左孩子，紧接着是左孩子的编号。
Ci=’r’表示第i个节点有一个右孩子，紧接着是右孩子的编号。
Ci=’z’表示第i个节点没有子孩子。
输出：
对应每个测试案例，
按照从上之下，从左至右打印出二叉树节点的值。
样例输入：
7
8 6 5 7 10 9 11
d 2 5
d 3 4
z
z
d 6 7
z
z
样例输出：
8 6 10 5 7 9 11
思路：
二叉树的层序遍历的实现还是比较简单的，由于其层级的关系，很明显要用到队列来辅助实现，
主要是从左向右，自上而下，依次将二叉树的各节点入队，这样便可以保证输出的顺序是层序排列的。

下面是算法的实现思想：

先将树的根节点入队，

如果队列不空，则进入循环

{

  将队首元素出队，并输出它；

  如果该队首元素有左孩子，则将其左孩子入队；

  如果该队首元素有右孩子，则将其右孩子入队

} 

*/

上面的思想很简单，但是用C来实现还是有一定的难度 ，明天再弄

说好的明天再弄，没想到又拖了两天，哎

/*
思路：
二叉树的层序遍历的实现还是比较简单的，由于其层级的关系，很明显要用到队列来辅助实现，
主要是从左向右，自上而下，依次将二叉树的各节点入队，这样便可以保证输出的顺序是层序排列的。

下面是算法的实现思想：

    先将树的根节点入队，

    如果队列不空，则进入循环

    {

      将队首元素出队，并输出它；

      如果该队首元素有左孩子，则将其左孩子入队；

      如果该队首元素有右孩子，则将其右孩子入队

    } 

    上面的思想很简单，但是用C来实现还是有一定的难度 
*/ 

#include<stdio.h>
#include<stdlib.h>
#define MAX  1000

//二叉树的存储结构 
typedef struct BTreeNode{
    int value;
    int leftIndex;
    int rightIndex;
}BTreeNode;
//队列的存储结构 
typedef struct Node{
    BTreeNode  btNode;
    struct Node *pNext; 
}Node;

typedef struct Queue{
    Node* pHead;//头指针 
    Node*  pTail;//尾指针 
}Queue;

//创建一个队列 
Queue*  createQueue(){
    Queue* q=(Queue*)malloc(sizeof(Queue));//为队列开辟一段空间 
    q->pHead=(Node*)malloc(sizeof(Node));//为队列中的结点开辟一段空间 
    if(q==NULL||q->pHead==NULL){
        exit(EXIT_FAILURE);
    }

    q->pTail=q->pHead;//头指针和尾指针指向相同的位置
    q->pHead->pNext=NULL;

    return q; 
}
/*功能：入队列 
参数的说明
@param q:队列指针
@param btreeNode:即将要入队列的树节点 
*/
void enQueue(Queue *q,BTreeNode btreeNode){
    if(q==NULL)
        return;
    //根据btreeNode来构造一个Node出来，Node才是Queue的单元
    Node *pNewNode=(Node *)malloc(sizeof(Node));
    if(pNewNode==NULL){
        exit(EXIT_FAILURE);
    }
    else{
        pNewNode->btNode=btreeNode;
        pNewNode->pNext=NULL;
        q->pTail->pNext=pNewNode;//将要入队列的节点放入队尾，q->pHead位置是没有放任何元素的，只是作为一个头指针，即队首元素的获取方式为：q->pHead->pNext;
        q->pTail=pNewNode;//移动队尾指针到新节点的位置
    }
    return;
} 
//判断队列是否为空
bool isEmpty(Queue *q){
    if(q==NULL){
        return true;
    }
    if(q->pHead==q->pTail){
        return true;
    }

    return false;//若上面两个if都不满足，则说明此队列不为空 
}
/*
功能：出队列
参数的说明：
@param q:队列指针
@param pBTNode:即将要出队列的树节点的指针

注意：出队函数，从队头出队，队尾指针保持不变，但当最后一个元素出队时， 
需要对队尾指针重新赋值，使其指向头结点
*/
void deQueue(Queue *q,BTreeNode *pBTNode){//可能这里还有点问题 
    if(q==NULL||q->pHead==q->pTail){
        return  ;
    }
    //Node * tempNode=q->pHead->pNext;
    //*pBTNode=tempNode 

    //(*pBTNode)=q->pHead->btNode;q->pHead位置是没有放任何元素的，只是作为一个头指针，即队首元素的获取方式为：q->pHead->pNext;
    Node * pTemp=q->pHead->pNext;
    *pBTNode=pTemp->btNode;
    //q->pHead=q->pHead->pNext;写法也不正确
    q->pHead->pNext=pTemp->pNext;

    //这里是队列头元素出队的特殊情况，一般情况下，删除队头元素时  
    //仅需修改头结点中的指针，但当队列中最后一个元素被删除时，  
     //队列尾指针也丢失了，因此需对队尾指针重新赋值（指向头结点）。
    if(q->pTail==pTemp){//即是最后一个节点，为避免删除最后一个节点时，尾指针也丢失了，因此需要将头节点赋值给尾结点
        q->pTail=q->pHead;

    }
    free(pTemp);
    return;


} 
/*
摧毁队列及其中的所有结点，其中的结点用while循环依次来摧毁 
*/
void destoryQueue(Queue *q){
    if(isEmpty(q)){
        return;
    }
    else{
        while(q->pHead){
            Node *node;
            node=q->pHead->pNext;
            free(q->pHead);
            q->pHead=node;
        }

    }

    free(q);
    q=NULL;

}

void printTree(BTreeNode *pBTNode,int index,int len,int *tempNum){
    if(pBTNode==NULL||index==-1||len<=0||tempNum==NULL){
        return ;
    }
    //第一步，先创建一个队列
    Queue* q=createQueue(); 
    //第二步：将头结点放入到队列中 

    enQueue(q,pBTNode[index]);//将头结点放入到队列中

    //第三步：将头结点出队列打印，并将左右子节点入队列。
    int i=0;
    while(!isEmpty(q)&&i<len){//判断队列中是否为空，若不为空，则说明队列中有元素，则直接取出打印，并将其左右节点入队列
         //将队列中的头元素出队列打印，如此节点存在左右节点，则在队尾入队列。再继续取出队首元素进行研究
         BTreeNode  *btNode=(BTreeNode *)malloc(sizeof(BTreeNode));//要初始化
         deQueue(q,btNode);//取出队首的节点保存在btNode中
         tempNum[i++]=btNode->value; 
         if (btNode->leftIndex!=-1) {//将该节点的左节点在队尾入队列 
            enQueue(q,pBTNode[btNode->leftIndex]);
         }
         if(btNode->rightIndex!=-1){//将该节点的左节点在队尾入队列 
            enQueue(q,pBTNode[btNode->rightIndex]);
         } 


    }
    //第四步：摧毁队列
    destoryQueue(q);    
}

int main(void){
    int n;
    while(scanf("%d",&n)!=EOF){
        if(n>0){
            BTreeNode *pNode=(BTreeNode *)malloc(n*sizeof(BTreeNode));
            if(pNode==NULL){
                exit(EXIT_FAILURE);
            }
            int val;
            for(int i=0;i<n;i++){//保存各个节点的值 
                scanf("%d",&val);
                pNode[i].value=val;
                pNode[i].leftIndex=-1;
                pNode[i].rightIndex=-1;
            }

            for(int i=0;i<n;i++){//将保存在pNode中的节点之间建立关系 
                while(getchar()!='\n'){//跳过缓冲流中的'\n' 
                continue;
                }

                char ch;
                scanf("%c",&ch);
                if(ch=='d'){
                    int leftIndex;
                    int rightIndex;
                    scanf("%d",&leftIndex);
                    scanf("%d",&rightIndex);
                    pNode[i].leftIndex=leftIndex-1;//由于是用数组来保存节点，而节点是从1 开始的，因此需要进行减 1 操作 
                    pNode[i].rightIndex=rightIndex-1;

                }
                else if(ch=='l'){
                    int leftIndex;
                    scanf("%d",&leftIndex);
                    pNode[i].leftIndex=leftIndex-1;

                }
                else if(ch=='r'){
                    int rightIndex;
                    scanf("%d",&rightIndex);
                    pNode[i].rightIndex=rightIndex-1;
                } 
                else if(ch=='z'){
                    continue;
                }

            }
            //将遍历的元素保存在tempNum中 
            int *tempNum=(int *)malloc(n*sizeof(int));//用来保存树的每层节点的值 
            if(tempNum==NULL){
                exit(EXIT_FAILURE);
            }
        //  printTree(pNode,0,n);
            printTree(pNode,0,n,tempNum);
            for(int i=0;i<n;i++){
                printf("%d ",tempNum[i]);
            } 
            free(tempNum);
            free(pNode);
            pNode=NULL;
            tempNum=NULL;

        }
        if(n<=0){
            printf("NULL\n");
        } 

    }
    return 0;
} 

运行结果如下

此题用C实现起来还是有一定的难度，因为需要我们自己创建一个队列，如果用java或者C++，我们就可以直接利用STL提供的队列，这样实现可能就简单点。以后再用C++来实现此功能。