C語言實現二叉樹的層次遍歷(隊列)

 

畫畫還真是費時間，主要的思路就是有隊列來完成層次遍歷，首先需要一個遍歷結點的指針p，初始化首尾指針，當p！=null進入循環，讓根節點1入隊，rear指針+1，

下面的循環遍歷條件是首尾指針不等(rear!=front) 標記一下此時的父結點p就是隊列的首結點p=queue[rear],首節點出隊front+1，如果當前父節點的左子樹不是null，那么左結點入隊，rear+1

如果當前父節點的右子樹不是null,那么

---

右節點入隊，rear+1.。這樣一層遍歷就完成了此時隊列里面是2和3，p為2結點。接着第二輪，標記此時的父節點p為隊列的首節點2，2結點出隊front+1，

p的左子樹不為null，4結點入隊，同理5結點入隊。第三輪。標記父節點p為隊列的首節點此時為3結點。3結點出隊，front+1,3結點沒有左右子樹進入第四輪。標記父節點p為隊首4，4出隊

同理下一輪5出隊 。rear==front 隊空結束

 

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 256
typedef struct BitNode{
    int val;
    struct BitNode * Lchild;
    struct BitNode * Rchild;
}*BitTree , TreeNode;


/*
typedef struct Queue{
    int arr[MAXSIZE];
    int rear ;
    int front ;
} ;*/
BitTree creatBitTree(BitTree root);
 void Preorder_traversal(BitTree root);
 void Level_traversal(BitTree root);
 void visit(BitTree root);
int main(){
    BitTree root = NULL ;
    printf("請輸入值0表示NULL\n");
    root =creatBitTree(root);
    printf("先序遍歷是:");
    Preorder_traversal(root);
    printf("\n");
    printf("層次遍歷是:");
    Level_traversal(root);
    printf("\n");
}
BitTree creatBitTree(BitTree root){
    int data ;
    scanf("%d",&data);
    if(data == 0){
        root = NULL;
    }
    else{
        root = (BitTree)malloc(sizeof(TreeNode));
        root->val = data;
        if(!root){
            printf("內存分配失敗\n");
            exit(1);
        }
        root->Lchild =creatBitTree(root->Lchild);
        root->Rchild =creatBitTree(root->Rchild);
    }
    return root;
}
void Preorder_traversal(BitTree root){
    if(root){
        printf("%d ",root->val);
        Preorder_traversal(root->Lchild);
        Preorder_traversal(root->Rchild);
    }
}
void Level_traversal(BitTree root){
    BitTree queue[MAXSIZE];
    int rear =0,front =0;
    BitTree p = root ;
    if(p!=NULL){
        //根結點入隊(是整個結點入隊)
        queue[rear] = p;
        rear=(rear+1)%MAXSIZE ;
        while(rear != front){
            //每次進來首尾指針不同的時候p指向隊列中第一個元素，然后p出隊,front指針+1
            p =queue[front];
            visit(queue[front]);
            front =(front+1)%MAXSIZE;
            if(p->Lchild!=NULL){
                //入隊左子結點
                queue[rear]=p->Lchild;
                rear =(rear+1)%MAXSIZE;
            }
            if(p->Rchild!=NULL){
                //入隊右子結點
                queue[rear]=p->Rchild;
                rear =(rear+1)%MAXSIZE;
                
            }
        }
    }
}
void visit(BitTree root){
    printf("%d ",root->val);
}

 

102. 二叉樹的層序遍歷

給你一個二叉樹，請你返回其按 層序遍歷 得到的節點值。 （即逐層地，從左到右訪問所有節點）。

 

示例：
二叉樹：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其層次遍歷結果：

[
  [3],
  [9,20],
  [15,7]
]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
# define MAX_NUM 10000
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    if(!root){
        *returnSize = 0;
        return NULL;
    }
    struct TreeNode** Queen = (struct TreeNode**)malloc(sizeof(struct TreeNode*)*MAX_NUM);  // 定義指針隊列，用來存儲所有節點的地址
    int** ret = (int**)malloc(sizeof(int*)*MAX_NUM);
    int i = 0, Queen_len, level_len, level_cnt;  // Queen_len：Queen中已有元素個數， level_len：每層的節點個數， level_cnt：每層的節點個數計數，
    *returnColumnSizes = (int*)malloc(sizeof(int)*MAX_NUM);

    // 頭節點入隊
    Queen[0] = root;
    Queen_len++;
    level_len = 1;
    *returnSize = 0;
    (*returnColumnSizes)[*returnSize] = level_len;
    // 遍歷隊列
    while(i<Queen_len){
        ret[*returnSize] = (int*)malloc(sizeof(int)*((*returnColumnSizes)[*returnSize]));
        level_cnt = 0;
        // 遍歷當前層
        for(int j=0; j<level_len; j++){
            // 取出當前節點存入ret
            ret[*returnSize][j] = Queen[i+j]->val; 
            // 取出當前節點的左右節點存入Queen
            if(Queen[i+j]->left){
                Queen[Queen_len++] = Queen[i+j]->left;
                level_cnt++;
            }
            if(Queen[i+j]->right){
                Queen[Queen_len++] = Queen[i+j]->right;
                level_cnt++;
            }
        }
        i += level_len;
        level_len = level_cnt;
        (*returnSize)++;
        (*returnColumnSizes)[*returnSize] = level_len;
    }
    return ret;
}