【初阶数据结构】7.二叉树（2）

于 2024-07-25 10:12:30 发布
阅读量1k 收藏 12
点赞数 35
分类专栏： 初阶数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hlyd520/article/details/140682324
版权

3.实现顺序结构二叉树

一般堆使用顺序结构的数组来存储数据，堆是一种特殊的二叉树，具有二叉树的特性的同时，还具备其他的特性。

3.1 堆的概念与结构

如果有一个关键码的集合 K = {k0, k1, k2, …，kn−1}，把它的所有元素按完全二叉树的顺序存储方式存储，在一个一维数组中，并满足： Ki<= K2∗i+1（ Ki>= K2∗i+1且Ki<= K2∗i+2 ），i = 0、1、2... ，则称为小堆(或大堆)。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。

小根堆示例大根堆示例
6602d54790edac562f096f247e0f6c9737a409ee51f1104c1da9e9b576a36adf
父节点小于等于孩子节点父节点大于等于孩子节点
小堆堆顶是堆的最小值大堆堆顶是堆的最大值

堆具有以下性质

  • 堆中某个结点的值总是不大于或不小于其父结点的值；
  • 堆总是一棵完全二叉树。

二叉树性质

  • 对于具有 n 个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有结点从0 开始编号，则对于序号为 i 的结点有：

  1. 若 i > 0 ， i 位置结点的父结点序号： (i-1)/2 ；

    i=0 ， i 为根结点编号，无双亲结点

  2. 若 2i+1 < n ，左孩子序号： 2i+1 ， 2i+1 >= n 否则无左孩子

  3. 若 2i+2 < n ，右孩子序号： 2i+2 ， 2i+2 >= n 否则无右孩子

3.2 堆的实现

Heap.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

//定义堆的结构---数组
typedef int HPDataType;

typedef struct Heap {
	HPDataType* arr;
	int size;//有效的数据大小
	int capacity;//空间大小
}HP;

//堆的初始化
void HPInit(HP* php);

//堆的销毁
void HPDestroy(HP* php);

//交换函数
void Swap(int* x, int* y);

//堆的向上调整算法
void AdjustUp(HPDataType* arr, int child);



//往堆里面插入数据
void HPPush(HP* php, HPDataType x);

//往堆里面删除数据
void HPPop(HP* php);

//取堆顶数据
HPDataType HPTop(HP* php);

// 判断堆是否为空
bool HPEmpty(HP* php);

Heap.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

//堆的初始化
void HPInit(HP* php) {
	assert(php);
	php->arr = NULL;
	php->size = php->capacity = 0;
}

//堆的销毁
void HPDestroy(HP* php) {
	assert(php);
	if (php->arr)
		free(php->arr);

	php->arr = NULL;
	php->size = php->capacity = 0;
}

//交换函数
void Swap(int* x, int* y) {
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

//堆的向上调整算法
void AdjustUp(HPDataType* arr, int child) {
	int parent = (child - 1) / 2;

	while (child > 0) {
		//建大堆，>
		//建小堆，<
		if (arr[child] < arr[parent]) {
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else {
			break;
		}
	}
}

//堆的向下调整算法
void AdjustDown(HPDataType* arr, int parent, int n) {
	int child = parent * 2 + 1;//左孩子
	while (child < n) {
		//小堆：找左右孩子中最小的
		//大堆：找左右孩子中最大的
		//看arr[child] > arr[child + 1]和if (arr[child] < arr[parent])里面的符号,符号不变就是小堆，反过来就是大堆
		if (child + 1 < n && arr[child] > arr[child + 1]) {//防止越界
			child++;
		}

		if (arr[child] < arr[parent]) {
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			break;
		}
	}
}

//往堆里面插入数据
void HPPush(HP* php, HPDataType x) {
	assert(php);
	//判断空间是否足够
	if (php->size == php->capacity) {
		//扩容
		int newCapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDataType* tmp = (HPDataType*)realloc(php->arr, newCapacity * sizeof(HPDataType));
		//空间申请失败
		if (tmp == NULL) {
			perror("relloc fail!");
			exit(1);
		}
		//空间申请成功
		php->arr = tmp;
		php->capacity = newCapacity;
	}
	php->arr[php->size] = x;

	AdjustUp(php->arr, php->size);//如果上一步size++的话，这里要size-1

	++php->size;
}

//往堆里面删除数据
//出堆：出的是堆顶是数据
//用到了堆的向下调整算法
void HPPop(HP* php) {
	assert(php && php->size);
	Swap(&php->arr[0], &php->arr[php->size - 1]);//交换栈顶和栈底元素

	--php->size;//删除交换后的原栈顶元素

	AdjustDown(php->arr, 0, php->size);
}

//取堆顶数据
HPDataType HPTop(HP* php) {
	assert(php && php->size);

	return php->arr[0];
}

// 判断堆是否为空
bool HPEmpty(HP* php) {
	assert(php);
	return php->size == 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

//冒泡排序
//时间复杂度：0(N^2)
void BubbleSort(int* arr, int n)
{
	for (int i = 0; i < n; i++){
		int exchange = 0;
		for (int j = 0; j < n - i - 1; j++){
			//升序
			if (arr[j] > arr[j + 1]){
				exchange = 1;
				Swap(&arr[j], &arr[j + 1]);
			}
		}
		if (exchange == 0){
			break;
		}
	}
}


//堆排序
//空间复杂度为0(1)
//时间复杂度为O(n*logn)
void HeapSort(int* arr, int n)
{
	//建堆
	//打印升序---大堆
	//打印降序----小堆

	//向上调整算法建堆
	/*for (int i = 0; i < n; i++)
	{
		AdjustUp(arr, i);
	}*/

	//向下调整算法建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--){
		AdjustDown(arr, i, n);
	}

	//循环将堆顶数据跟最后位置（会变化，每次减少一个数据）的数据进行交换
	int end = n - 1;
	while (end > 0){
		Swap(&arr[0], &arr[end]);
		AdjustDown(arr, 0, end);
		end--;
	}
}


//空间复杂度为0(n)
void test01() {
    HP hp;
    HPInit(&hp);

    int arr[] = { 17,20,10,13,19,15 };

    for (int i = 0; i < 6; i++) {
        HPPush(&hp, arr[i]);
    }

    while (!HPEmpty(&hp)) {
        printf("%d ", HPTop(&hp));
        HPPop(&hp);
    }

    //HPPop(&hp);

    //HPDestroy(&hp);
}

int main() {
    //test01();
    //给定一个数组，对数组中的数据进行排序
    int arr[] = { 17,20,10,13,19,15 };
    //BubbleSort(arr, 6);
	HeapSort(arr, 6);
    for (int i = 0; i < 6; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

3.2.1 向上调整算法

堆的插入

将新数据插入到数组的尾上，再进行向上调整算法，直到满足堆。

向上调整算法

  • 先将元素插入到堆的末尾,即最后一个孩子之后

  • 插入之后如果堆的性质遭到破坏，将新插入结点顺着其双双亲往上调整到合适位置即可

img

void AdjustUp(HPDataType* a, int child)
{
    int parent = (child - 1) / 2;
    while(child > 0)
    {
        if (a[child] > a[parent])
        {
            Swap(&a[child], &a[parent]);
            child = parent;
            parent = (parent - 1) / 2;
        }
        else
        {
            break;
        }
    }
}
void HPPush(HP* php, HPDataType x)
{
    assert(php);
    if (php->size == php->capacity)
    {
        size_t newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
        HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newCapacity);
        if (tmp == NULL)
        {
            perror("realloc fail");
            return;
        }
        php->a = tmp;
        php->capacity = newCapacity;
    }
    php->a[php->size] = x;
    php->size++;
    AdjustUp(php->a, php->size-1);
}

计算向上调整算法建堆时间复杂度：

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明(时间复杂度本来看的就是近似值，多几个结点不影响最终结果)

img

img

如果是根节点，不需要向上调整。

img

img

  1. T(n)：这个表达式代表的是在堆的向上调整算法中，对于一个具有n个节点的堆，完成调整所需的移动步数。

    通过分层说明和移动步数计算解释，给出了一个关于h（堆的高度）的函数表达式，并最终通过一系列变换得到了T(h)的表达式。

  2. F(h)：这个表达式代表的是在堆的向上调整算法中，对于高度为h的堆，完成调整所需的移动步数的另一种表达形式。

    最终目的是为了推导出F(n)。

  3. F(n)：这个表达式代表的是对于具有n个节点的堆，完成向上调整所需的移动步数的最终表达式。通过将T(h)的表达式转换为关于n的表达式，得到了F(n)的表达式。

    这个表达式是基于二叉堆的性质，即堆的节点数n与堆的高度h之间的关系==（n = 2h - 1），以及高度h与节点数n之间的关系（h = log2(n + 1)）==。

由此可得：

向上调整算法建堆时间复杂度为：O(n ∗ log2n)

3.2.2 向下调整算法

堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

img

向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

向下调整算法

  • 将堆顶元素与堆中最后一个元素进行交换

  • 删除堆中最后一个元素

  • 将堆顶元素向下调整到满足堆特性为止

img

void AdjustDown(HPDataType* a, int n, int parent)
{
    int child = parent * 2 + 1;
    while (child < n)
    {
        // 假设法，选出左右孩子中小的那个孩子
        if (child+1 < n && a[child + 1] > a[child])
        {
            ++child;
        }
        if (a[child] > a[parent])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else
        {
            break;
        }
    }
}
void HPPop(HP* php)
{
    assert(php);
    assert(php->size > 0);
    Swap(&php->a[0], &php->a[php->size - 1]);
    php->size--;
    AdjustDown(php->a, php->size, 0);
}

计算向下调整算法建堆时间复杂度：

img

img

最底层不需要向下移动

img

向下调整算法建堆时间复杂度为：O(n)

3.3 堆的应用

3.3.1 堆排序

代码1：基于已有数组建堆、取堆顶元素完成排序版本

// 1、需要堆的数据结构
// 2、空间复杂度 O(N)
void HeapSort(int* a, int n)
{
    HP hp;
    for(int i = 0; i < n; i++)
    {
        HPPush(&hp,a[i]);
    }
    int i = 0;
    while (!HPEmpty(&hp))
    {
        a[i++] = HPTop(&hp);
        HPPop(&hp);
    }
    HPDestroy(&hp);
}

该版本有一个前提，必须提供有现成的数据结构堆

代码2：数组建堆，首尾交换，交换后的堆尾数据从堆中删掉，将堆顶数据向下调整选出次大的数据

// 升序，建大堆
// 降序，建小堆
// O(N*logN)
void HeapSort(int* a, int n)
{
    // a数组直接建堆 O(N)
    for (int i = (n-1-1)/2; i >= 0; --i)
    {
        AdjustDown(a, n, i);
    }
    // O(N*logN)
    int end = n - 1;
    while (end > 0)
    {
        Swap(&a[0], &a[end]);
        AdjustDown(a, end, 0);
        --end;
    }
}

堆排序时间复杂度计算：

img

img

通过分析发现，堆排序第二个循环中的向下调整与建堆中的向上调整算法时间复杂度计算一致，因此，堆排序的时间复杂度为O(n + n ∗ log n) ，即O(n log n)

堆排序时间复杂度为：O(n *log n)

3.3.2 TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

比如：

  1. 要存储4GB的内存数据，现在只有1GB，怎么找到里面最大的10个数？

    分四次建堆，每次建堆分别找到堆里面最大的10个数，最后在40个数里找到最大的10个数。

  2. 如果只有1KB怎么办呢？

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合中前K个元素来建堆

    要取前k个最大的元素，则建小堆

    要取前k个最小的元素，则建大堆

  2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

    将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素

为什么要取前k个最大的元素，则建小堆呢？

因为在最小堆中，堆顶元素总是堆中最小的元素。当处理一个新元素时，如果这个新元素比堆顶元素大，那么它就有可能是最大的k个数之一。此时，我们把堆顶元素弹出，将新元素加入堆中。然后调整新元素在堆里面的位置。这样，堆中始终保持了当前遇到的最大的k个数。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <time.h>
#include <stdlib.h>

//生成随机数
//void CreateNDate()
//{
//    // 造数据
//    int n = 100000;
//    srand(time(0));
//    const char* file = "data.txt";
//    FILE* fin = fopen(file, "w");
//    if (fin == NULL)
//    {
//        perror("fopen error");
//        return;
//    }
//    for (int i = 0; i < n; ++i)
//    {
//        int x = (rand() + i) % 1000000;
//        fprintf(fin, "%d\n", x);
//    }
//    fclose(fin);
//}

//定义堆的结构---数组
typedef int HPDataType;

typedef struct Heap {
    HPDataType* arr;
    int size;//有效的数据大小
    int capacity;//空间大小
}HP;

//交换函数
void Swap(int* x, int* y) {
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

//堆的向下调整算法
void AdjustDown(HPDataType* arr, int parent, int n) {
    int child = parent * 2 + 1;//左孩子
    while (child < n) {
        //小堆：找左右孩子中最小的
        //大堆：找左右孩子中最大的
        //看arr[child] > arr[child + 1]和if (arr[child] < arr[parent])里面的符号,符号不变就是小堆，反过来就是大堆
        if (child + 1 < n && arr[child] > arr[child + 1]) {//防止越界
            child++;
        }

        if (arr[child] < arr[parent]) {
            Swap(&arr[child], &arr[parent]);
            parent = child;
            child = parent * 2 + 1;
        }
        else {
            break;
        }
    }
}

//TOP-K排序
void topk()
{
    printf("请输入k：>");
    int k = 0;
    scanf("%d", &k);

    //从文件中读取前k个数据，建堆
    const char* file = "data.txt";
    FILE* fout = fopen(file, "r");
    if (fout == NULL)
    {
        perror("fopen error");
        return;
    }

    int val = 0;
    int* minheap = (int*)malloc(sizeof(int) * k);//创建小堆
    if (minheap == NULL)
    {
        perror("malloc error");
        return;
    }
    for (int i = 0; i < k; i++)//循环读取数据，先读取k个
    {
        fscanf(fout, "%d", &minheap[i]);
    }
    // 建k个数据的小堆
    for (int i = (k - 1 - 1) / 2; i >= 0; i--)//循环读取数据，读取n-k个
    {
        AdjustDown(minheap, i, k);
    }

    int x = 0;
    while (fscanf(fout, "%d", &x) != EOF)
    {
        // 读取剩余数据，比堆顶的值大，就替换他进堆
        if (x > minheap[0])
        {
            minheap[0] = x;
            AdjustDown(minheap, 0, k);
        }
    }

    for (int i = 0; i < k; i++)//打印最大的k个数据
    {
        printf("%d ", minheap[i]);
    }

    fclose(fout);
}

int main() {
    //CreateNDate();
    topk();
    return 0;
}

时间复杂度：O(n) = k + (n − k)log2k

流星白龙
关注
  • 35
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构初阶数据结构初阶
02-12
2. **栈和队列**：栈是后进先出（LIFO）的数据结构，常用于函数调用、表达式求值等；队列是先进先出（FIFO）的数据结构，常用于任务调度和消息传递。 3. **树形数据结构**：包括二叉树、平衡树、堆等。二叉树每个...
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-23
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"包含了使用C和C++语言实现的数据结构实例，旨在帮助初学者和进阶者深化对数据结构的理解。 首先，让我们从初阶数据结构开始。基础的数据结构通常包括...
【初阶数据结构】6.二叉树（1）
hlyd520的博客
07-23 1072
对于深度为 K 的，有 n 个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从 1 至 n 的结点一一对应时称之为完全二叉树。现实中我们通常把堆（一种二叉树）使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。在树形结构中，我们最常用的就是二叉树，一棵二叉树是结点的一个有限集合，该集合由一个根结点加上两棵别称为左子树和右子树的二叉树组成或者为空。：一个结点含有的子树的根结点称为该结点的子结点；
【数据结构初阶】7. 二叉树
weixin_60915103的博客
02-19 322
该博客介绍二叉树的定义，二叉树的遍历以及例题（详解），层序遍历。
初阶数据结构——二叉树
dtxew love c++
11-10 2818
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 前言 我们在上篇文章中已经介绍了二叉树的相关性质及其应用，点我直达上一篇文章 然而，在实际应用中，单纯地讲二叉树的增删查改是没有意义的 因为存储和访问数据，将会变得特别的困难，因为二叉树是一种层次结构，需要递归来定义，在哪一点添加删除？这
初阶数据结构—二叉树
Awkwardx的博客
06-25 683
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。。
手撕初阶数据结构之二叉树
liu3290607528的博客
06-19 917
上篇博客小L已经讲述了二叉树的基本性质目前初阶数据结构最难的一集-树+二叉树_堆-CSDN博客，这期我将带领大家一起进行二叉树的具体实现，由于普通二叉树实在太复杂，于是我们这节要一步步从零开始，那么就让我们系好安全带，一起向二叉树前进吧！！！
初阶数据结构 初识二叉树
小萌新的博客
10-18 420
初阶数据结构 初识二叉树
初阶数据结构之二叉树
2302_80418176的博客
07-04 851
那么本篇文是初阶数据结构这个系列的最后一篇文章，那么闲话少叙，我们直接进入正题在讲二叉树的一些之前知识点之前，我先给大家送个小礼物哈。
数据结构初阶：二叉树
yourfriendyo的博客
11-17 1470
树是n(n≥0)n\;(n≥0)n(n≥0)个元素的有限集。树是递归定义的，任意一个树都是由一个根结点和多个子树构成，而其中每个子树也是由一个根结点和多个子树构成。根结点：每个树有且仅有的一个根结点，即树中最上面的一个结点，根结点无前驱结点。子树：分成M(M≥0)M\;(M≥0)M(M≥0)个互不相交的集合，而每个集合都是一个与树结构类似的子树。如右图所示，根结点AAA下面有三个子树，这三个子树又分别以结点BBB，CCC，DDD为根结点。B。
初阶数据结构：二叉树
qq_71806743的博客
03-02 1081
的数据结构，其有n个有限的节点构成，树结构具有层次性。它的形状颇像一颗颠倒的树，因此而被称为树。2. 我们从最后一个非叶子结点开始，向下调整，调整过后的子树都为堆，一直循环到根结点。对于树结构的初次学习，我们来重点学习二叉树这一结构。我们接下来进行这几个问题的学习。
C语言实现数据结构算法初阶算法
06-15
6. **二叉树遍历**：二叉树是一种非线性数据结构，有前序、中序和后序三种遍历方式。这些遍历方法在搜索、排序等问题中非常有用。C语言实现二叉树，需要定义结构体表示节点，并编写递归或迭代的遍历函数。 7. **...
C+学习笔记+树、堆、二叉树代码
03-28
还有一些链式二叉树的相关内容，在这里为了简单链式二叉树相关内容均是用递归的思路来进行实现的，因而算是初阶数据结构二叉树的一个小集合。 适合人群：学生，学习初阶数据结构的人群 能学到什么：通过简单的代码，...
插入和选择排序
c23856的博客
07-20 523
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
【数据结构】搜索二叉树
最新发布
dab112的博客
07-24 526
介绍了二叉搜索树的实现与模拟
数据结构（二叉树-1）
2401_83968713的博客
07-20 1066
树是⼀种⾮线性的数据结构，它是由nn>=0） 个有限结点组成⼀个具有层次关系的集合。把它叫做 树是因为它看起来像⼀棵倒挂的树，也就是说它是根朝上，⽽叶朝下的。有⼀个特殊的结点，称为根结点，根结点没有前驱结点。除根结点外，其余结点被分成M(M>0)个互不相交的集合T1T2……Tm，其中每⼀个集合⼜是⼀棵结构与树类似的⼦树。每棵⼦树的根结点有且只有⼀个前驱，可以有0个或多个后继。因此，树是递归定义的。树形结构中，⼦树之间不能有交集，否则就不是树形结构。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 955
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
数据结构——二叉树定义
鲸落博客
07-23 364
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值