【数据结构】树与二叉树(廿三):树和森林的遍历——层次遍历(LevelOrder)

文章目录

  • [5.3.1 树的存储结构](#5.3.1 树的存储结构)
    • [5. 左儿子右兄弟链接结构](#5. 左儿子右兄弟链接结构)
  • [5.3.2 获取结点的算法](#5.3.2 获取结点的算法)
  • [5.3.3 树和森林的遍历](#5.3.3 树和森林的遍历)

5.3.1 树的存储结构

5. 左儿子右兄弟链接结构

【数据结构】树与二叉树(十九):树的存储结构------左儿子右兄弟链接结构(树、森林与二叉树的转化)

左儿子右兄弟链接结构通过使用每个节点的三个域(FirstChild、Data、NextBrother)来构建一棵树,同时使得树具有二叉树的性质。具体来说,每个节点包含以下信息:

  1. FirstChild: 存放指向该节点的大儿子(最左边的子节点)的指针。这个指针使得我们可以迅速找到一个节点的第一个子节点。
  2. Data: 存放节点的数据。
  3. NextBrother: 存放指向该节点的大兄弟(同一层中右边的兄弟节点)的指针。这个指针使得我们可以在同一层中迅速找到节点的下一个兄弟节点。

通过这样的结构,整棵树可以用左儿子右兄弟链接结构表示成一棵二叉树。这种表示方式有时候被用于一些特殊的树结构,例如二叉树、二叉树的森林等。这种结构的优点之一是它更紧凑地表示树,而不需要额外的指针来表示兄弟关系。

c 复制代码
   A
  /|\
 B C D
  / \
 E   F
c 复制代码
A
|
B -- C -- D
     |
     E -- F

即:

c 复制代码
      A
     / 
    B   
    \
	  C
  	 / \ 
  	E   D
  	 \
  	  F

5.3.2 获取结点的算法

【数据结构】树与二叉树(二十):树获取大儿子、大兄弟结点的算法(GFC、GNB)

5.3.3 树和森林的遍历

【数据结构】树与二叉树(七):二叉树的遍历(先序、中序、后序及其C语言实现)

1. 先根遍历(递归、非递归)

【数据结构】树与二叉树(廿一):树和森林的遍历------先根遍历(递归算法PreOrder、非递归算法NPO)

2. 后根遍历(递归、非递归)

【数据结构】树与二叉树(廿二):树和森林的遍历------后根遍历(递归算法PostOrder、非递归算法NPO)

3. 森林的遍历


4. 层次遍历

树和森林层次遍历按层数由小到大,即从第0层开始逐层向下,同层中由左到右的次序访问所有结点。

a. 算法LevelOrder

b. 算法解读

首先,创建一个队列Q,并将根指针t入队列Q中。然后,进入一个循环,只要队列Q非空,就执行以下操作:

  1. 将队首元素p出队列Q。
  2. 打印节点p的数据。
  3. 如果节点p有左子节点,则将左子节点入队列Q。
  4. 将节点p的右兄弟节点赋值给p,继续遍历下一个节点。

LevelOrder算法通过队列的先进先出特性,确保按照从上到下、从左到右的顺序遍历二叉树的节点。

c. 时间复杂度

在层次遍历中,每个结点都要进行1次入队、1次出队和1次访问,每次访问入队、出队和访问都是常数级的,因此,算法LevelOrder的时间复杂度为O(n)。

d.代码实现

层次遍历(levelOrder)
c 复制代码
void LevelOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }

    Queue queue;
    initQueue(&queue);

    enqueue(&queue, root);

    while (queue.front != NULL) {
        TreeNode* p = dequeue(&queue);

        while (p != NULL) {
            // 访问当前结点
            printf("%c ", p->data);

            // 将大儿子结点入队列
            if (getFirstChild(p) != NULL) {
                enqueue(&queue, getFirstChild(p));
            }

            // 移动到下一个兄弟结点
            p = getNextBrother(p);
        }
    }
}

其中,队列操作详解:【数据结构】线性表(九)队列:链式队列及其基本操作(初始化、判空、入队、出队、存取队首元素)

初始化队列(initQueue)
c 复制代码
void initQueue(Queue* q) {
    q->front = NULL;
    q->rear = NULL;
}
入队列(enqueue)
c 复制代码
void enqueue(Queue* q, TreeNode* treeNode) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->treeNode = treeNode;
    newNode->next = NULL;

    if (q->rear == NULL) {
        q->front = newNode;
        q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}
出队列(dequeue)
c 复制代码
TreeNode* dequeue(Queue* q) {
    if (q->front == NULL) {
        return NULL; // 队列为空
    }

    TreeNode* treeNode = q->front->treeNode;
    QueueNode* temp = q->front;

    q->front = q->front->next;
    free(temp);

    if (q->front == NULL) {
        q->rear = NULL; // 队列为空
    }

    return treeNode;
}

5. 代码整合

c 复制代码
#include <stdio.h>
#include <stdlib.h>

// 定义树节点
typedef struct TreeNode {
    char data;
    struct TreeNode* firstChild;
    struct TreeNode* nextBrother;
} TreeNode;

// 创建树节点
TreeNode* createNode(char data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    if (newNode != NULL) {
        newNode->data = data;
        newNode->firstChild = NULL;
        newNode->nextBrother = NULL;
    }
    return newNode;
}

// 释放树节点及其子树
void freeTree(TreeNode* root) {
    if (root != NULL) {
        freeTree(root->firstChild);
        freeTree(root->nextBrother);
        free(root);
    }
}

// 算法GFC:获取大儿子结点
TreeNode* getFirstChild(TreeNode* p) {
    if (p != NULL && p->firstChild != NULL) {
        return p->firstChild;
    }
    return NULL;
}

// 算法GNB:获取下一个兄弟结点
TreeNode* getNextBrother(TreeNode* p) {
    if (p != NULL && p->nextBrother != NULL) {
        return p->nextBrother;
    }
    return NULL;
}


// 队列结构
typedef struct QueueNode {
    TreeNode* treeNode;
    struct QueueNode* next;
} QueueNode;

typedef struct {
    QueueNode* front;
    QueueNode* rear;
} Queue;

// 初始化队列
void initQueue(Queue* q) {
    q->front = NULL;
    q->rear = NULL;
}

// 入队列
void enqueue(Queue* q, TreeNode* treeNode) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->treeNode = treeNode;
    newNode->next = NULL;

    if (q->rear == NULL) {
        q->front = newNode;
        q->rear = newNode;
    } else {
        q->rear->next = newNode;
        q->rear = newNode;
    }
}

// 出队列
TreeNode* dequeue(Queue* q) {
    if (q->front == NULL) {
        return NULL; // 队列为空
    }

    TreeNode* treeNode = q->front->treeNode;
    QueueNode* temp = q->front;

    q->front = q->front->next;
    free(temp);

    if (q->front == NULL) {
        q->rear = NULL; // 队列为空
    }

    return treeNode;
}

// 层次遍历算法
void LevelOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }

    Queue queue;
    initQueue(&queue);

    enqueue(&queue, root);

    while (queue.front != NULL) {
        TreeNode* p = dequeue(&queue);

        while (p != NULL) {
            // 访问当前结点
            printf("%c ", p->data);

            // 将大儿子结点入队列
            if (getFirstChild(p) != NULL) {
                enqueue(&queue, getFirstChild(p));
            }

            // 移动到下一个兄弟结点
            p = getNextBrother(p);
        }
    }
}


int main() {
    // 构建左儿子右兄弟链接结构的树
    TreeNode* A = createNode('A');
    TreeNode* B = createNode('B');
    TreeNode* C = createNode('C');
    TreeNode* D = createNode('D');
    TreeNode* E = createNode('E');
    TreeNode* F = createNode('F');

    A->firstChild = B;
    B->nextBrother = C;
    C->nextBrother = D;
    C->firstChild = E;
    E->nextBrother = F;

    // 层次遍历算法
    printf("Level Order: \n");
    LevelOrder(A);
    printf("\n");
    
    freeTree(A);

    return 0;
}
相关推荐
Y40900116 分钟前
C语言转Java语言,相同与相异之处
java·c语言·开发语言·笔记
YuTaoShao18 分钟前
【LeetCode 热题 100】994. 腐烂的橘子——BFS
java·linux·算法·leetcode·宽度优先
Wendy14418 小时前
【线性回归(最小二乘法MSE)】——机器学习
算法·机器学习·线性回归
拾光拾趣录8 小时前
括号生成算法
前端·算法
棐木8 小时前
【C语言】动态内存管理
c语言·free·malloc·realloc·calloc·动态内存
渣呵9 小时前
求不重叠区间总和最大值
算法
拾光拾趣录9 小时前
链表合并:双指针与递归
前端·javascript·算法
好易学·数据结构9 小时前
可视化图解算法56:岛屿数量
数据结构·算法·leetcode·力扣·回溯·牛客网
香蕉可乐荷包蛋10 小时前
AI算法之图像识别与分类
人工智能·学习·算法
chuxinweihui10 小时前
stack,queue,priority_queue的模拟实现及常用接口
算法