数据结构:二叉树(超详解析)

这篇具有很好参考价值的文章主要介绍了数据结构:二叉树(超详解析)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

目录​​​​​​​

1.树概念及结构

1.1树的概念

1.2树的相关概念

1.3树的表示

1.3.1孩子兄弟表示法: 

 1.3.2双亲表示法:只存储双亲的下标或指针

两节点不在同一树上:

2.二叉树概念及结构

2.1.概念

2.2.特殊的二叉树:

2.2.1.满二叉树:

​编辑2.2.2. 完全二叉树:h = (log2(N+1))

2.3.二叉树的性质

2.4.二叉树的存储结构

2.4.1. 顺序存储:

2.4.2.链式存储:

3.二叉树的顺序结构及实现

3.1.二叉树的顺序结构

3.2.堆的概念及结构

3.3堆的实现

3.4.堆排序

3.5.TOP--K问题

4.二叉树的链式结构及实现

4.1.前序、中序以及后序遍历

4.2层序遍历

 以上就是个人学习线性表的个人见解和学习的解析,欢迎各位大佬在评论区探讨!

感谢大佬们的一键三连! 感谢大佬们的一键三连! 感谢大佬们的一键三连! 


1.树概念及结构

1.1树的概念

        树是一种非线性的数据结构,它是由n(n>=0)个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

1.1.1.有一个特殊的结点,称为根结点,根节点没有前驱结点;
1.1.2.除根节点外,其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm,其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱,可以有0个或多个后继 ;

1.1.3.因此,树是递归定义的。
注意:树形结构中,子树之间不能有交集,否则就不是树形结构。

1.2树的相关概念

        数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

重点重点重点:

1.2.1.节点的度:一个节点含有的子树的个数称为该节点的度; 如上图:A的为6。。
1.2.2.叶节点或终端节点:度为0的节点称为叶节点; 如上图:B、C、H、I...等节点为叶节点。
1.2.3.非终端节点或分支节点:度不为0的节点; 如上图:D、E、F、G...等节点为分支节点。
1.2.4.双亲节点或父节点:若一个节点含有子节点,则这个节点称为其子节点的父节点; 如上图:A是B的父节点。

1.2.5.孩子节点或子节点:一个节点含有的子树的根节点称为该节点的子节点; 如上图:B是A的孩子节点。
1.2.6.兄弟节点:具有相同父节点的节点互称为兄弟节点; 如上图:B、C是兄弟节点。
1.2.7.树的度:一棵树中,最大的节点的度称为树的度; 如上图:树的度为6。
1.2.8.节点的层次:从根开始定义起,根为第1层,根的子节点为第2层,以此类推。
1.2.9.树的高度或深度:树中节点的最大层次; 如上图:树的高度为4。
1.2.10.堂兄弟节点:双亲在同一层的节点互为堂兄弟;如上图:H、I互为兄弟节点。
1.2.11.节点的祖先:从根到该节点所经分支上的所有节点;如上图:A是所有节点的祖先。
1.2.12.子孙:以某节点为根的子树中任一节点都称为该节点的子孙。如上图:所有节点都是A的子孙。
1.2.13.森林:由m(m>0)棵互不相交的树的集合称为森林。

1.3树的表示

既要保存值域,也要保存结点和结点之间的关系。

实际中树有很多种表示方式如:双亲表示法,孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。

1.3.1孩子兄弟表示法: 

typedef int DataType;
struct Node
{
        struct Node* _firstChild1; // 第一个孩子结点
        struct Node* _pNextBrother; // 指向其下一个兄弟结点
        DataType _data; // 结点中的数据域
};

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

 1.3.2双亲表示法:只存储双亲的下标或指针

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

两节点不在同一树上:

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

2.二叉树概念及结构

2.1.概念

一棵二叉树是结点的一个有限集合,该集合:

        1. 或者为空 ;

        2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成 。

注意:

        1. 二叉树不存在度大于2的结点
        2. 二叉树的子树有左右之分,次序不能颠倒,因此二叉树是有序树。

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

2.2.特殊的二叉树:

2.2.1.满二叉树:

        一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是 2^k-1,则它就是满二叉树

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记
2.2.2. 完全二叉树:h = (log2(N+1))

        完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

2.3.二叉树的性质

2.3.1. 若规定根节点的层数为1,则一棵非空二叉树的第i层上最多有2^(i-1)个结点;

2.3.2. 若规定根节点的层数为1,则深度为h的二叉树的最大结点数是2^h-1;

2.3.3. 对任何一棵二叉树, 如果度为n0其叶结点个数为 , 度为2的分支结点个数为n2 ,则有 n0=n2 +1;

2.3.4. 若规定根节点的层数为1,具有n个结点的满二叉树的深度,h=log(n+1). (ps:log2(n+1)是log以2 为底,n+1为对数);

2.3.5. 对于具有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否则无右孩子;

 1. 某二叉树共有 399 个结点,其中有 199 个度为 2 的结点,则该二叉树中的叶子结点数为( )
A .不存在这样的二叉树
B.200
C. 198
D. 199
2.在具有 2n 个结点的完全二叉树中,叶子结点个数为( )
A. n
B. n+1
C. n-1
D. n/2

解析:

        0个节点N0,1个节点N1,2个节点N2;2n = N0+N1+N2;2n = N0+N1+N0-1;所以2N0=2n。
3.一棵完全二叉树的节点数位为531个,那么这棵树的高度为( )
A. 11
B. 10
C. 8
D. 12
4.一个具有767个节点的完全二叉树,其叶子节点个数为()
A. 383
B. 384
C. 385
D. 386

解析:

        0个节点N0,1个节点N1,2个节点N2;767 = N0+N1+N0-1;2N0 = 768.

2.4.二叉树的存储结构

        二叉树一般可以使用两种结构存储,一种顺序结构,一种链式结构。

2.4.1. 顺序存储:

        顺序结构存储就是使用数组来存储,一般使用数组只适合表示完全二叉树,因为不是完全二叉树会有空间的浪费(当节点无子节点时,数组位置空缺)。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储结构在物理上是一个数组,在逻辑结构上是一颗二叉树。

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

2.4.2.链式存储:

        二叉树的链式存储结构是指,用链表来表示一棵二叉树,即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成,数据域和左右指针域,左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链,当前我们学习中一般都是二叉链,学到高阶数据结构时如红黑树等会用到三叉链。

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

3.二叉树的顺序结构及实现

3.1.二叉树的顺序结构

        普通的二叉树是不适合用数组来存储的,因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储,需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事,一个是数据结构,一个是操作系统中管理内存的一块区域分段。

3.2.堆的概念及结构

3.2.1.概念:

        如果有一个关键码的集合K = {k1,k2 ,k3,…,kn-1},把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中,并满足:ki<=k2i+1 且ki<=k2i+2 (ki>=k2i+1且ki>=k2i+2) i = 0,1,2…,则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。
3.2.2堆的性质:
        1.堆中某个节点的值总是不大于或不小于其父节点的值;
        2.堆总是一棵完全二叉树。

数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记

底层逻辑:

        1.物理结构——>数组;

        2.逻辑结构——>完全二叉树;

堆:非线性结构,是完全二叉树;

小堆:树中任意一个父亲都<=孩子;

大堆:树中任意一个父亲都>=孩子;

一般解决的问题:

        1.topk问题:找前多少个最大值或最小值;

        2.堆排序:(时间复杂度O(N*logN))    冒泡排序(O(N^2))

需要排序100W个元素,堆排序2000W次,冒泡排序1万亿次。

堆的规律:

        leftchild = parent*2+1;

        rightchild = parent*2+2;

        partent =  (child-1)/2;

总结:

        顺序存储不适合用数组存储;

        满二叉树和完全二叉树适合用数组存储。

3.3堆的实现

堆的头文件:

typedef int HPDataType;

typedef struct Heap
{
    HPDataType* a;
    int size;
    int capacity;
}HP;


//初始化
void HeapInit(HP* php);
void HeapInitArray(HP* php,int* a,int n);

//销毁
void HeapDestory(HP* php);

//插入
void HeapPush(HP* php, HPDataType x);

//弹出
void HeapPop(HP* php);

//打印
void HeapPrint(HP* php);

//堆顶
HPDataType HeapTop(HP* php);

//判断为空
bool HeapEmpty(HP* php);

//交换
void Swap(HPDataType* s1, HPDataType* s2);

//向上调整
void Adjustup(HPDataType* a, int child);

//向下调整
void Adjustdown(HPDataType* a, int n, int parent);

//初始化(为空)111方法一
void HeapInit(HP* php)
{
    assert(php);

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

//初始化(不为空不需要再Push)222方法二
void HeapInitArray(HP* php, int* a, int n)
{
    assert(php);
    assert(a);

    php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
    if (php->a == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }

    php->size = php->capacity = n;
    memcpy(php->a, a, n * sizeof(HPDataType));

    //建堆
    for (int i = 1; i < n; i++)
    {
        Adjustup(php->a, i);
    }
}

        向上调整:将儿子节点的下标传递给形参,找到父节点,子节点的值与父节点比较,如果子节点比父亲节点大那么进行交换(建大堆),依次循环判断,遍历结束则说明已经完成大堆的创建。

//交换
void Swap(HPDataType* s1, HPDataType* s2)
{
    HPDataType tmp = *s1;
    *s1 = *s2;
    *s2 = tmp;
}

//向上调整(此时建立大堆)
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 = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}

        向下调整:将父亲节点的下标传递给形参,找到儿子点,子节点的值与父节点比较,如果子节点比父亲节点大那么进行交换(建小堆),依次循环判断,遍历结束则说明已经完成小堆的创建。

//交换
void Swap(HPDataType* s1, HPDataType* s2)
{
    HPDataType tmp = *s1;
    *s1 = *s2;
    *s2 = tmp;
}

//向下调整(此时建立小堆)
void Adjustdown(HPDataType* a, int n, int parent)
{
    int child = (parent * 2) + 1;
    while (child < n)
    {
        if (child + 1 < n && a[child] > a[child + 1])
        {
            child++;
        }
        if (a[parent] > a[child])
        {
            Swap(&a[child], &a[parent]);
            parent = child;
            child = (parent * 2) + 1;
        }
        else
        {
            break;
        }
    }

}

//插入
void HeapPush(HP* php, HPDataType x)
{
    assert(php);

    if (php->size == php->capacity)
    {
        int newcapacity = php->size == 0 ? 4 : 2 * php->size;
        HPDataType* tmp = (HPDataType*)realloc(php->a,sizeof(HPDataType) * newcapacity);
        if (tmp == NULL)
        {
            perror("realloc fail");
            exit(-1);
        }

        php->capacity = newcapacity;
        php->a = tmp;
    }

    php->a[php->size] = x;
    php->size++;

    Adjustup(php->a, php->size-1);
}

//弹出/删除
void HeapPop(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);
}

//打印
void HeapPrint(HP* php)
{
    assert(php);

    for(int i = 0;i < php->size;i++)
    {
        printf("%d ",php->a[i]);
    }
    printf("\n");
}

//销毁
void HeapDestory(HP* php)
{
    assert(php);

    free(php->a);
    php->a = NULL;
    php->size = php->capacity = 0;
}

//堆顶
HPDataType HeapTop(HP* php)
{
    assert(php);
    assert(php->size > 0);

    return php->a[0];
}

//判断为空
bool HeapEmpty(HP* php)
{
    assert(php);

    return php->size == 0;
}

3.4.堆排序

升序建大堆;将最大值和最后一个值交换,然后size-1,一直到size为1时,完成升序排序

降序建小堆;将最小值和最后一个值交换,然后size-1,一直到size为1时,完成降序排序

3.5.TOP--K问题

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

1. 用数据集合中前K个元素来建堆
        前k个最大的元素,则建小堆;
        前k个最小的元素,则建大堆;
2. 用剩余的N-K个元素依次与堆顶元素来比较,不满足则替换堆顶元素

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

4.二叉树的链式结构及实现

4.1.前序、中序以及后序遍历

二叉树的遍历有:前序/中序/后序的递归结构遍历:
1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。(根,左,右)
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中(间)。(左,根,右)
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
由于被访问的结点必是某子树的根,所以N(Node)、L(Left subtree)和R(Right subtree)又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。(左,右,根)

//前序
void FrontOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }

    printf("%d ", root->val);
    FrontOrder(root->left);
    FrontOrder(root->right);
}

//中序
void InOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }

    InOrder(root->left);
    printf("%d ", root->val);
    InOrder(root->right);
}

//后序
void PostOrder(BTNode* root)
{
    if (root == NULL)
    {
        printf("NULL ");
        return;
    }

    PostOrder(root->left);
    PostOrder(root->right);
    printf("%d ", root->val);
}

 

4.2层序遍历

        设二叉树的根节点所在层数为1,层序遍历就是从所在二叉树的根节点出发,首先访问第一层的树根节点,然后从左到右访问第2层上的节点,接着是第三层的节点,以此类推,自上而下,自左至右逐层访问树的结点的过程就是层序遍历。

//结构体
typedef struct BinaryTreeNode
{
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
    int val;
}BTNode;

//节点个数
int TreeSize(BTNode* root)
{
    if (root == NULL)
        return 0;
    return TreeSize(root->left) + TreeSize(root->right) + 1;
}

//叶子节点的个数
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);
}

//第k层的节点数
int TreeKlevel(BTNode* root, int k)
{
    assert(k > 0);

    if (root == NULL)
    {
        return 0;
    }

    if (k == 1)
    {
        return 1;
    }

    return TreeKlevel(root->left, k - 1) + TreeKlevel(root->right, k - 1);
}

//查找值为x的节点
BTNode* FindTree(BTNode* root, int x)
{
    if (root == NULL)
        return NULL;

    if (root->val == x)
    {
        return root;
    }

    BTNode* ret = NULL;
    ret = FindTree(root->left, x);
    if (ret != NULL)
    {
        return ret;
    }
    ret = FindTree(root->right, x);
    return ret;
}

//层序遍历
void LevelOrder(BTNode* root)
{
    Que q;
    QueueInit(&q);

    if (root)
    {
        QueuePush(&q, root);
    }

    while (!QueueEmpty(&q))
    {
        BTNode* front = QueueFront(&q);
        printf("%d ", front->val);
        if(front->left != NULL)
            QueuePush(&q, front->left);
        if(front->right != NULL)
            QueuePush(&q, front->right);

        QueuePop(&q);
    }
    printf("\n");
}

//判断是否是完全二叉树
int TreeComplete(BTNode* root)
{
    Que q;
    QueueInit(&q);

    if (root)
    {
        QueuePush(&q, root);
    }

    while (!QueueEmpty(&q))
    {
        BTNode* front = QueueFront(&q);
        if (front == NULL)
        {
            break;
        }
        QueuePush(&q, front->left);
        QueuePush(&q, front->right);

        QueuePop(&q);
    }
    
    //当在队列中遇到NULL时,判断后面是否有非空节点,有则不是完全二叉树
    while (!QueueEmpty(&q))
    {
        BTNode* front = QueueFront(&q);
        QueuePop(&q);
        if (front != NULL)
        {
            QueueDestroy(&q);
            return false;
        }
    }
    QueueDestroy(&q);
    return true;
}

//销毁
void DestroyTree(BTNode* root)
{
    if (root == NULL)
    {
        return;
    }

    DestroyTree(root->left);
    DestroyTree(root->right);

    free(root);
}

 以上就是个人学习线性表的个人见解和学习的解析,欢迎各位大佬在评论区探讨!

感谢大佬们的一键三连! 感谢大佬们的一键三连! 感谢大佬们的一键三连! 

                                             数据结构:二叉树(超详解析),数据结构,算法,数据结构,深度学习,c语言,c++,学习,笔记文章来源地址https://www.toymoban.com/news/detail-713318.html

到了这里,关于数据结构:二叉树(超详解析)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 二叉树(上)——“数据结构与算法”

    各位CSDN的uu们好呀,好久没有更新我的数据结构与算法专栏啦,今天,小雅兰继续来更新二叉树的内容,下面,让我们进入链式二叉树的世界吧!!! 二叉树链式结构的实现  二叉树链式结构的实现 普通的二叉树的增删查改是没有价值的!!! 只有搜索二叉树的增删查改才

    2024年02月15日
    浏览(44)
  • 数据结构初阶之二叉树的详细解析

    个人主页:点我进入主页 专栏分类:C语言初阶      C语言程序设计————KTV       C语言小游戏     C语言进阶 C语言刷题       数据结构初阶    Linux 欢迎大家点赞,评论,收藏。 一起努力,共赴大厂。 目录 1.前言  2.二叉树各个功能代码实现 2.1二叉树结构体 2.2二叉

    2024年02月05日
    浏览(41)
  • 【数据结构】树与二叉树(十三):递归复制二叉树(算法CopyTree)

      二叉树是一种常见的树状数据结构,它由结点的有限集合组成。一个二叉树要么是 空集 ,被称为 空二叉树 ,要么由一个根结点和两棵不相交的子树组成,分别称为 左子树 和 右子树 。每个结点最多有两个子结点,分别称为左子结点和右子结点。 引理5.1:二叉树中层数

    2024年02月01日
    浏览(39)
  • 数据结构与算法——树与二叉树

    😊各位小伙伴久等了,本专栏新文章出炉了!!! 我又回来啦,接下来的时间里,我会持续把数据结构与算法专栏更新完。 👉树型结构👈 是一类重要的 ✍非线性数据结构 ,其中以树和二叉树最为常用,直观来看,树是以分支关系定义的层次结构。树型结构在客观世界中

    2024年02月11日
    浏览(45)
  • 【数据结构与算法】树与二叉树

    除了之前我们讲的栈、队列、链表等线性结构,数据结构中还有着一对多的 非线性结构 ——— 树 。 树是有 n 个结点组成的有限集,当n=0时为空树,在任意一颗非空树中,有且仅有一个 特定的根结点 ;当n1时,其余结点又可以分为一棵树,称为根的 子树 。 如下图所示: A为

    2023年04月09日
    浏览(49)
  • 数据结构与算法之《二叉树》详解

    文章目录 一、树的概念及结构 二、二叉树的概念及结构 2、1 二叉树的概念 2、2 二叉树的特点 2、3 二叉树的结构(图片) 2、4 特殊的二叉树 三、二叉树的代码及思路实现 3、1 二叉树的存储结构 3、1、1 二叉树的顺序存储结构 3、1、2 二叉树的链式存储结构 3、2 二叉树链式

    2024年02月01日
    浏览(45)
  • 【数据结构和算法】---二叉树(1)--树概念及结构

    树是一种 非线性的数据结构 ,它是由n(n=0)个有限结点组成一个具有层次关系的集合。之所以叫它树,是因为将此结构倒转后与现实生活中的树极其相似,一个主干分出多个分支,分支还可继续分展。 有一个特殊的结点,称为 根结点 ,根节点没有前驱结点; 除根节点外,

    2024年02月03日
    浏览(43)
  • 【数据结构】二叉树算法讲解(定义+算法原理+源码)

    博主介绍:✌全网粉丝喜爱+、前后端领域优质创作者、本质互联网精神、坚持优质作品共享、掘金/腾讯云/阿里云等平台优质作者、擅长前后端项目开发和毕业项目实战✌有需要可以联系作者我哦! 🍅附上相关C语言版源码讲解🍅 👇🏻 精彩专栏推荐订阅👇🏻 不然下次找

    2024年01月23日
    浏览(53)
  • 《数据结构与算法》之二叉树(补充树)

    二叉搜索树,也称二叉排序树或二叉查找树 二叉搜索树:一棵二叉树,可以为空,如果不为空,应该满足以下性质: 非空左子树的所有结点小于其根结点的键值 非空右子树的所有结点大于其根结点的键值 左右子树都是二叉搜索树 对于二叉树的查找,其实沿用的是分治法的

    2024年02月08日
    浏览(48)
  • 数据结构与算法-二叉树的遍历

    🌞 “少年没有乌托邦,心向远方自明朗!” 二叉树的遍历是按照一定次序访问二叉树中的所有结点,且每个结点仅被访问一次的过程。遍历线性结构是容易解决的,而二叉树的结构是非线性结构,需要寻找规律,使二叉树的结点排列在一个线性队列上,便于遍历。 由二叉树

    2024年02月08日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包