【数据结构】二叉树-堆（深入学习）

要做朋鱼燕

于 2025-08-19 23:25:13 发布

阅读量399

点赞数 13

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签：学习数据结构 c语言算法

本文链接：https://blog.csdn.net/2402_83411382/article/details/150536693

数据结构专栏收录该内容

14 篇文章

订阅专栏

如果是小白的话，建议先阅读以下博客，效果更好：

【数据结构】二叉树概念及结构 -CSDN博客

【数据结构】堆-“此堆非比堆”-CSDN博客

一.二叉树链式结构的实现

1.1前置说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在我们对二叉树结构掌握还不够深入，为了降低学习成本，此处我手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

typedef char BTDataType;
typedef struct BinaryTreeNode
{
        BTDataType _data;
        struct BinaryTreeNode* _right;
        struct BinaryTreeNode* _left;
}BTNode;

BTNode* NoteCreate(int x)
{
        BTNode* note = (BTNode*)malloc(sizeof(BTNode));
        note->_data = x;
        note->_left = NULL;
        note->_right = NULL;

        return note;
}

int main()
{
        BTNode* A = NoteCreate('A');
        BTNode* B = NoteCreate('B');
        BTNode* C = NoteCreate('C');
        BTNode* D = NoteCreate('D');
        BTNode* E = NoteCreate('E');

        A->_left = B;
        A->_right = C;
        B->_left = D;
        B->_right = E;
        
        return 0;
}

注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解。

二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。一个结点（非叶子结点）都可以向下分为左右子树；

1.2二叉树的遍历

1.2.1前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

前序遍历递归图解：

前序遍历结果：1 2 3 4 5 6

中序遍历结果：3 2 1 5 4 6

后序遍历结果：3 2 5 6 4 1

1.2.2层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

1.3求树的结点个数

第一种方法：

（定义一个全局变量来存个数）

int size = 0;
int TreeSize(BTNode* root)
{
        if (root == NULL)
                return 0;

        size++;
        TreeSize(root->_left);
        TreeSize(root->_right);

        return size;
}

int main()
{
        BTNode* A = NoteCreate('A');
        BTNode* B = NoteCreate('B');
        BTNode* C = NoteCreate('C');
        BTNode* D = NoteCreate('D');
        BTNode* E = NoteCreate('E');

        A->_left = B;
        A->_right = C;
        B->_left = D;
        B->_right = E;

        printf("Notesize=%d\n", TreeSize(A));
        printf("Notesize=%d\n", TreeSize(A));
        
        return 0;
}

但是这种方法存在漏洞，计算完一次结点个数size没有清零而是继续在前一次的基础上累加，如果我们在工程中多个地方调用，算出来的结点个数就会出错。接下来我们使用传参的方法。

第二种方法：传参

void TreeSize(BTNode* roo1t,int* size)
{
        if (root == NULL)
                return;
        else
                (*size)++;

        TreeSize(root->_left,size);
        TreeSize(root->_right,size);
}


int main()
{
        BTNode* A = NoteCreate('A');
        BTNode* B = NoteCreate('B');
        BTNode* C = NoteCreate('C');
        BTNode* D = NoteCreate('D');
        BTNode* E = NoteCreate('E');

        A->_left = B;
        A->_right = C;
        B->_left = D;
        B->_right = E;

        int sizea = 0;
        TreeSize(A, &sizea);
        printf("Notesizea=%d\n", sizea);

        int sizeb = 0;
        TreeSize(B, &sizeb);
        printf("Notesizeb=%d\n", sizeb);
        
        return 0;
}

但是这种方法每次要计算结点个数都要传参，有点别扭，因此我们还有第三种方法。

第三种方法：


int TreeSize(BTNode* root)
{
        if (root == NULL)
                return 0;
        else
                return 1 + TreeSize(root->_left) + TreeSize(root->_right);
}

int main()
{
        BTNode* A = NoteCreate('A');
        BTNode* B = NoteCreate('B');
        BTNode* C = NoteCreate('C');
        BTNode* D = NoteCreate('D');
        BTNode* E = NoteCreate('E');

        A->_left = B;
        A->_right = C;
        B->_left = D;
        B->_right = E;
        
        printf("Notesize=%d\n", TreeSize(A));
        printf("Notesize=%d\n", TreeSize(A));
        
        return 0;
}

1.4求叶子结点的个数

int TreeLeafSize(BTNode* root)
{
        if (root == NULL)
                return 0;

        if (root->_left == NULL && root->_right == NULL)
                return 1;

        return TreeLeafSize(root->_left) + TreeLeafSize(root->_right);
}

int main()
{
        BTNode* A = NoteCreate('A');
        BTNode* B = NoteCreate('B');
        BTNode* C = NoteCreate('C');
        BTNode* D = NoteCreate('D');
        BTNode* E = NoteCreate('E');

        A->_left = B;
        A->_right = C;
        B->_left = D;
        B->_right = E;

        printf("TreeLeafSize=%d\n", TreeLeafSize(A));
        
        return 0;
}

走到D的时候发现是叶子节点，回溯时返回1，E回溯返回1，B回溯返回2，C回溯时返回1，再回溯到A结束，最后返回3

1.5求第K层节点的个数

//二叉树第K层的节点个数
//当前树的第K层可以转换成左右子树的第（K-1）层
//层数是1不用分解
int BinaryTreeLevelKSize(BTNode* root, int k)
{
        if (root == NULL)
        {
                return 0;
        }
        if (k == 1)
        {
                return 1;
        }

        return BinaryTreeLevelKSize(root->_left,k-1) + BinaryTreeLevelKSize(root->_right,k-1);
}

1.6查找值为x的节点

//查找值为x的节点
//递归思想，遍历左右子树
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
        if (root == NULL)
        {
                return NULL;
        }
        if (root->_data == x)
        {
                return root;
        }
        BTNode* node = BinaryTreeFind(root->_left, x);
        if (node)
                return node;
        node = BinaryTreeFind(root->_right, x);
        if (node)
                return node; 

        return NULL;
}

1.7销毁一颗树

这里我们使用后序销毁

//销毁
void DestoryTree(BTNode* root)
{
        if (root == NULL)
        {
                return;
        }
        DestoryTree(root->_left);
        DestoryTree(root->_right);
        free(root);
}