[数据结构]：07-二叉树（无头结点）（C语言实现）

Chandni.

已于 2023-03-29 00:38:36 修改

阅读量420

点赞数

分类专栏：数据结构（C语言版）文章标签：考研 c++ 数据结构 c语言

于 2023-02-28 17:09:51 首次发布

本文链接：https://blog.csdn.net/qq_55143210/article/details/129265636

版权

数据结构（C语言版）专栏收录该内容

25 篇文章 3 订阅

订阅专栏

前言

此专栏包含408考研数据结构全部内容，除其中使用到C++引用外，全为C语言代码。使用C++引用主要是为了简化指针的使用，避免二重指针的出现。

已完成内容

[数据结构]：01-顺序表（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：02-单链表（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：03-栈（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：04-循环队列（数组）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：05-循环队列（链表）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：06-队列（链表带头结点）（C语言实现）_Chandni.的博客-CSDN博客

[数据结构]：20-线索二叉树（无头结点）（C语言实现）_Chandni.的博客-CSDN博客

二叉树实现

01-开发环境

语言：C/C++14

编译器：MinGW64

集成开发环境：CLion2022.1.3

02-文件布局

请在CLion集成开发环境中创建C++可执行程序，否则无法运行，原因上面已解释。

03-代码

01-主函数

用于测试和初始化二叉树。

#include "./Head/TreeData.h"
#include "./Source/QueueFunction.cpp"
#include "./Source/TreeFunction.cpp"

int main() {
    // 层序创建树
    BinaryTree BTree = NULL;
    int value[MaxSize] = {1, 2, 3, 4, 5, 6, 0};
    TreeCreate(BTree, value);

    // 前序遍历
    // 1  2  4  5  3  6
    printf("Preorder.\n");
    PreorderTraversalTree(BTree);
    printf("\n");

    // 中序遍历
    // 4  2  5  1  6  3
    printf("InOrder.\n");
    InOrderTraversalTree(BTree);
    printf("\n");

    // 后序遍历
    // 4  5  2  6  3  1
    printf("PostOrder.\n");
    PostOrderTraversalTree(BTree);
    printf("\n");

    // 层序遍历
    // 1  2  3  4  5  6
    printf("Level.\n");
    LevelTraversalTree(BTree);
    printf("\n");
    return 0;
}

02-头文件

用于存储结构体和常量等。

//
// Created by 24955 on 2023-02-26.
//

#ifndef INC_01_ARRAYQUEUE_QUEUEDATA_H
#define INC_01_ARRAYQUEUE_QUEUEDATA_H
// 头文件
#include <stdio.h>
#include <stdlib.h>

// 常量
#define MaxSize 10
typedef int ElemType;

// 结构体
// 二叉树
typedef struct BinaryTreeNode {
    ElemType data;
    struct BinaryTreeNode *lChild;
    struct BinaryTreeNode *rChild;
} BinaryTreeNode, *BinaryTree;

// 辅助队列
typedef struct SecondaryQueueNode {
    BinaryTree BTree;
    struct SecondaryQueueNode *next;
} SecondaryQueueNode;
typedef struct {
    SecondaryQueueNode *front, *rear;
} SecondaryQueue;
#endif //INC_01_ARRAYQUEUE_QUEUEDATA_H

03-QueueFunction.cpp

用于存储辅助队列的函数。

//
// Created by 24955 on 2023-02-26.
// 队列带头结点
//
// 初始化队列(循环队列)
void InitializationQueue(SecondaryQueue &Queue) {
    Queue.front = Queue.rear = (SecondaryQueueNode *) malloc(sizeof(SecondaryQueueNode));
    Queue.rear->next = Queue.front;
}

// 判断队列是否为空
bool JudgeQueueEmpty(SecondaryQueue Queue) {
    if (Queue.front == Queue.rear) {
        return true;
    } else {
        return false;
    }
}

// 判断队列是否已满
bool JudgeQueueFull(SecondaryQueue Queue) {
    if (Queue.rear->next == Queue.front) {
        return true;
    } else {
        return false;
    }
}

// 入队
void QueuePush(SecondaryQueue &Queue, BinaryTree BTree) {
    if (JudgeQueueFull(Queue)) {
        SecondaryQueueNode *NewNode = (SecondaryQueueNode *) malloc(sizeof(SecondaryQueueNode));
        NewNode->BTree = BTree;
        NewNode->next = Queue.front;
        Queue.rear->next = NewNode;
        Queue.rear = NewNode;
    } else {
        Queue.rear->next->BTree = BTree;
        Queue.rear = Queue.rear->next;
    }
}

// 出队
void QueuePop(SecondaryQueue &Queue, BinaryTree &BTree) {
    if (!JudgeQueueEmpty(Queue)) {
        SecondaryQueueNode *Node = Queue.front->next;
        BTree = Node->BTree;
        Queue.front = Node;
    } else {
        printf("Queue Empty.\n");
    }
}

04-TreeFunction.cpp

用于存储树的创建、遍历等函数。

//
// Created by 24955 on 2023-02-27.
// 不带头结点(408不存在带头结点的树)
//
// 创建树-层序创建
void TreeCreate(BinaryTree &BTree, int value[]) {
    /*
     * 1. 初始化辅助队列
     * 2. 初始化要插入的树节点
     * 3. 判断是否为根节点
     * 4. 若非根节点，则判断左孩子是否为空，为空则插入，并修改辅助队列尾指针
     * 5. 否则判断右孩子是否为空，为空则插入，并修改辅助队列头、尾指针*/
    // 初始化辅助队列
    SecondaryQueue Queue;
    InitializationQueue(Queue);
    // 树的新结点
    BinaryTree NewBTree;
    for (int i = 0; value[i]; i++) {
        // 初始化树结点
        // calloc申请空间大小为两参数相乘
        // 并对空间初始化赋值为0
        // NewBTree->lChild = NULL;NewBTree->rChild = NULL;可省略
        NewBTree = (BinaryTree) calloc(1, sizeof(BinaryTreeNode));
        NewBTree->data = value[i];

        // 判断是否为创建根节点
        if (BTree == NULL) {
            // 创建根节点
            BTree = NewBTree;
            // 入队(辅助队列)
            QueuePush(Queue, NewBTree);
        } else {
            // 创建非根节点
            SecondaryQueueNode *FirstQueueNode = Queue.front->next;
            BinaryTree NowTree = FirstQueueNode->BTree;

            // 插入
            if (NowTree->lChild == NULL) {
                // 插入左孩子
                NowTree->lChild = NewBTree;
                // 入队(辅助队列)
                QueuePush(Queue, NewBTree);
            } else if (NowTree->rChild == NULL) {
                // 插入右孩子
                NowTree->rChild = NewBTree;
                // 入队(辅助队列)
                QueuePush(Queue, NewBTree);
                // 出队(辅助队列)
                BinaryTree OutTree;
                QueuePop(Queue, OutTree);
            }
        }
    }
}

// 前序遍历(深度优先遍历)
void PreorderTraversalTree(BinaryTree BTree) {
    /* 递归三要素：目标、结束条件、等价关系式
     * 1. 自身、左、右*/
    if (BTree != NULL) {
        printf("%3d", BTree->data);
        PreorderTraversalTree(BTree->lChild);
        PreorderTraversalTree(BTree->rChild);
    }
}

// 中序遍历
void InOrderTraversalTree(BinaryTree BTree) {
    /*
     * 1. 左、自身、右*/
    if (BTree != NULL) {
        InOrderTraversalTree(BTree->lChild);
        printf("%3d", BTree->data);
        InOrderTraversalTree(BTree->rChild);
    }
}

// 后序遍历
void PostOrderTraversalTree(BinaryTree BTree) {
    /*
     * 1. 左、右、自身*/
    if (BTree != NULL) {
        PostOrderTraversalTree(BTree->lChild);
        PostOrderTraversalTree(BTree->rChild);
        printf("%3d", BTree->data);
    }
}

// 层序遍历(广度优先遍历)
void LevelTraversalTree(BinaryTree BTree) {
    /*
     * 1. 将树根节点入队
     * 2. 判断队列是否为空
     * 3. 若不为空，出队并输出
     * 4. 判断左、右孩子是否为空，不为空则入队*/
    // 初始化辅助队列
    SecondaryQueue SQueue;
    InitializationQueue(SQueue);

    // 树根节点入队
    QueuePush(SQueue, BTree);
    BinaryTree NowTreeNode;
    while (!JudgeQueueEmpty(SQueue)) {
        // 出队并打印
        QueuePop(SQueue, NowTreeNode);
        printf("%3d", NowTreeNode->data);
        // 判断左、右孩子是否为空，非空入队
        if (NowTreeNode->lChild != NULL) {
            QueuePush(SQueue, NowTreeNode->lChild);
        }
        if (NowTreeNode->rChild != NULL) {
            QueuePush(SQueue, NowTreeNode->rChild);
        }
    }
}