二叉树、堆学习笔记

已于 2024-03-04 14:47:34 修改
阅读量921 收藏 19
点赞数 30
文章标签： 笔记 算法
于 2024-03-04 01:54:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79528561/article/details/136441151
版权

前言：笔者最近正在学习树的结构，因此写这个笔记用来记录，之后学的更多，笔记会更加完善，希望大家批评指正。

目录

 

树的概念

树由几部分组成

树的表示 

二叉树

二叉树的概念

二叉树的特点：

特殊的二叉树

二叉树的存储结构

二叉树的性质

堆的结构

堆的概念

堆的性质

堆的调整算法

建立最大堆的实现

插入元素 

 弹出最大元素

堆排序 Heapsort()

判断堆是否为空 

遍历打印堆

销毁堆

 堆的实际开发应用

参考文献：

结语：

附录

 

树的概念

树由几部分组成

  • 根节点：根节点没有前驱节点
  • 除根节点外，其余节点被分成是一个结构与树类似的子树。每颗子树的根节点有且只有一个前驱，可以由0或多个后继
  • 节点的度：一个节点含有的子树的个数称为该节点的度；
  • 叶节点：度为0的节点称为叶节点
  • 非终端节点或分支节点：度不为0的节点
  • 双亲节点或父节点：若一个节点含有的子节点，则这个节点成为其子节点的父节点
  • 孩子节点或子节点：一个节点延伸的子树的根节点称为该节点的子节点
  • 兄弟节点：具有相同父节点的节点互称为兄弟节点
  • 树的度：一颗树中，最大的节点的度称为树的度
  • 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，一次类推
  • 树的高度或深度：树中节点的最大层次
  • 堂兄弟节点：双亲在同一层的节点互为堂兄弟
  • 子孙：以某节点为根的子树中任一节点都为该节点的子孙
  • 森林：由m颗互不相交的树的集合称为森林、 

树的表示 

树有很多表示方式，如：双亲表示法，孩子表示法，孩子兄弟表示法等，常用的是孩子兄弟表示法。

二叉树

二叉树的概念

一颗二叉树是节点的一个有限集合，该集合或者为空，或者是有一个根节点加上两颗分别称为左子树和右子树的二叉树组成。注意：左右子树有次序之分，并且两个子树依然是二叉树。

二叉树的特点：

1.每个节点最多有两颗子树，即二叉树不存在度大于2的节点

2.二叉树的子树有左右之分，次序不能颠倒。

特殊的二叉树

1.满二叉树：一个二叉树，如果每层的节点数都达到最大值，则这个二叉树就是满二叉树。

2.完全二叉树：完全二叉树是查找效率很高的数据结构，只有最后一行的节点可以不是满节点，另外满二叉树是特殊的完全二叉树。

二叉树的存储结构

1.顺序结构存储

顺序结构存储就是使用数组来存储，一般这种方法只适用于完全二叉树，因为不是完全二叉树会存在空间的浪费，而现实中只有堆会使用数组来存储。

7525f7b2c7c048c590a861f13c5d4a0a.png

2.链式存储

即使用链表来表示一颗二叉树，即用链来指示元素的逻辑关系。通常的方法是链表的每个节点由三个域组成，数据域和左右指针域，左右指针分别用来给除该节点左右孩子所在链结点的存储地址。链式存储又分为二叉链和三叉链。

1c3bb79a88954ff784c4d72d5ab4efd8.png

78b997b72e0044fdbb2bd95f13891f59.png

 

//二叉链
struct BinaryTreeNode
{
    struct BinaryTreeNode* _pLeft
    struct BinaryTreeNode* _pRight;
    int data;
};


//三叉链
struct BinaryTreeNode
{
    struct BinaryTreeNode* _pParent;
    struct BinaryTreeNode* _pRight;
    struct BinaryTreeNode* _Left;
    int data;
};

二叉树的性质

1.若规定根节点的层数为1，则一颗非空二叉树的第i层上最多有2^(i - 1)个节点
2.若规定根节点的层数为1，则深度为的二叉树的最大节点数是2^h - 1
3. 对于任何一棵二叉树，叶结点的个数等于度为2的分支结点个数加1
4.若规定根节点的层数为1， 具有n个节点的满二叉树的深度，h = log2(n + 1)
5.对于具有n个节点的完全二叉树，如果按照从上至下的数组顺序对所有节点从0开始编号，则对序号为i的节点有：
6.若i > 0, i位置节点的双亲序号：(i - 1) / 2; i == 0, i 为根节点无父节点
若2i + 1 < n, 则左孩子编号：2i+1
若2i + 2 < n, 则右孩子编号：2i+2
 

堆的结构

堆的概念

堆就是将元素按照完全二叉树的顺序存储方式存储在一个一维数组中，而当满足父节点的元素小于其左右孩子时，称为小堆，特别的当根节点的元素最小时叫做最小堆；当父节点的元素大于其左右孩子时，称为大堆，特别的当根节点的元素最大时，叫做最大堆。

堆的性质

  • 小（大）堆中的某个节点总是不大于或不小于其父节点的值；
  • 堆总是一个完全二叉树，所以可以使用数组来顺序存储；
  • 以i为下标，可以看出堆或者说完全二叉树的规律：
  • i 的左子节点下标：2i + 1
  • i 的右子节点下标：2i + 2
  • i 的父节点：( i - 1 ) / 2;

堆的调整算法

向下/上调整：是让调整的节点与其孩子节点进行比较，若想将其调整为小堆，那么根节点的左右子树必须都为小堆，若想将其调整为大堆，那么根节点的左右子树必须都为大堆。

向下调整算法的基本思想（以最大堆为例）：

1.从根节点处开始，选出左右孩子中值较大的那个

2.让大的孩子与其父亲进行比较

3.若大的孩子比父亲还大，则该孩子与其父亲的位置进行交换，继续向下进行调整直到调整到叶子节点为止。

4.若大的孩子比父亲小，就不需处理，调整完成，整个树就是大堆了。

/*向下调整当前的节点和子节点，将堆调整成最大堆*/

void adjustDown(Heap& heap, int index)    //heap是引入的待调整的堆，index是当前待调整的父节点
{    
    int cur = heap.arr[index];
    int parent, child;
    
    /*判断是否存在大于当前节点的子节点，如果不存在，则堆本身就是平衡的，不需要调整；如果存在，则将最大的子节点与之交换，交换后，如果这个子节点还有子节点，则需要继续按照同样的步骤堆这个子节点进行调整*/
    for (parent = index; (parent * 2 + 1) < heap.size; parent = child)
/*这个循环时因为如果父节点小于左节点，那么循环内会将child ++ 变为右节点
    {
        child = parent * 2 + 1;    //左子节点
        
        //取两个子节点中的最大的点
        if ( ((child + 1) < heap.size) && (heap.arr[child] < heap.arr[child + 1]) )
            child ++;
        
        //判断最大子节点是否大于当前的父节点
        if (cur >= heap.arr[child]) break;    //不大于，不需要调整，跳出循环
        else 
        {
            heap.arr[parent] = heap.arr[child];    
            heap.arr[child] = cur;
            /*循环到这里就结束了，没有再判断右节点，那么如果换完之后，右节点大于父节点怎么办？：循环没有结束，而是因为父节点和较大的子节点交换位置，所以之前子节点作为父节点时构建好的大堆可能被破坏，所以parent = child，子节点作为父节点重新进行可能的换位操作。 */
        }
    }
}

向上调整算法的基本思想：

1.将目标节点与其父节点比较

2.若目标节点的值比其父节点的值大，则交换目标节点与其父节点的位置

3.将原目标节点的父节点当作新的目标节点继续进行向上调整。若目标节点的值比其父节点的值小，则停止向上调整，此时树已经是最大堆了。

void adjustUp(Heap& heap, int index)
{
    if (index < 0 || index >= size) return ;    //下标小于0或下标大于堆的元素个数，越界直接返回
    
    while (index > 0)
    {
        int temp = heap.arr[index];    
        int parent = (index - 1) / 2;    //无论是左节点还是右节点，使用这个公式都能正确得到其父节点的下标
        
        if (parent >= 0)
            if (temp > heap.arr[parent])
            {
                heap.arr[index] = heap.arr[parent];
                heap.arr[parent] = temp;
                index = parent;
            }
            else break;    /*如果已经比父亲小，直接结束循环，但如果另一个子节点比父亲大呢?向上调整算法应用于插入元素时，因为原本堆已是最大堆，所以如果插入的元素大于其父节点那么一定大于其兄弟节点。*/      else break;    //parent < 0,结束循环
 
   }
}

向下调整算法的使用情景：在从一维数组构建树时，从最后的父节点开始向上遍历每个父节点，进行向下调整

向上调整算法的使用情景：向堆中插入元素，使用向上调整算法保证原本的最大堆在插入元素后依然是最大堆。

可以看到：向下调整算法中的index是父节点，看父节点和最大子节点之间的大小关系；向上调整算法中的index是子节点，只需看该子节点和父节点之间的大小关系，而不需要看兄弟节点。

建立最大堆的实现

#define DEFAULT_CAPACITY 128    //宏定义一个规定的容量

typedef struct Heap
{
    int* arr;    //存储堆元素的数组，二叉树的顺序存储
    int size;    //当前已存储的元素个数
    int capacity;    //当前存储的容量
}Heap;


/*构造堆*/
void buildHeap(Heap& heap)
{
    for (int i = heap.size / 2 - 1; i >= 0; i -- )
    {
        adjustDown(head, i);
        /*从最后一个父节点开始（(heap.size) - 1 ）/ 2，逐个调整所有的父节点（直到根节点），确保每一个父节点都是最大堆，嘴都整体上形成一个最大堆*/ 
    }
}

/*初始化堆*/
bool initHeap(Heap& heap, int* orginal, int size)
{
    int capacity = DEFAULT_CAPACITY > size ? DEFAULT_CAPACITY : size;

    heap.arr = new int[capacity];
    if (!heap.arr) return false;

    heap.capacity = capacity;
    heap.size = 0;

    //如果传入的数组中有元素
    if (size)
    {
        memcpy(heap.arr, orginal, size* sizeof(int));    //将原始数据复制到堆中
        heap.size = size;
        buildHeap(heap);
    }
    else heap.size = 0;

    return true;
}

插入元素 

例子：将99加入到原始堆中，对应数组为：{95， 93， 87， 92， 86， 82}

首先将新进的元素插入到大顶堆的尾部，此时最大堆已被破坏，需要重新调整。

353b3079cb714007adc02739114e25f5.png

69bd9baddf2e4ac7bfc3e05498ba4e4d.png

 b0331fbdb33b49548ea4db9e1c70936b.png

代码实现

bool insertHeap(Heap& heap, int value)
{
    if (heap.size == heap.capacity)
    {
        cout << "栈空间耗尽！" << endl;
        return false;
    }
    
    int index = heap.size;
    heap.arr[heap.size ++] = value;
    adjustUp(heap, index);
}

 弹出最大元素

如果将堆顶的元素弹出，那么顶部有一个空的节点，该怎么处理呢？

当插入节点时，我们将新的值插入到数组的尾部。现在来做相反的事情：取出数组的最后一个元素，将它放到堆的顶部，然后修复堆的属性（最大堆/最小堆）

bool popMax(Heap& heap, int& value);

bool popMax(Heap& heap, int& value)
{
    if (heap.size < 1)return false;
    value = heap.arr[0];    //这个是为了可能后续要将最大值输出
    
    //将size - 1的位置值赋值给根节点，size本身再--
    /*相当于
        heap.arr[0] = heap.arr[ heap.size -- ];
        heap.size --;
    */
        heap.arr[0] = heap.arr[-- size];
        adjustDown(heap, 0);    //向下执行堆调整
        return true;
}

堆排序 Heapsort()

堆排序利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种，可以利用数组的特点快速定位到指定索引的元素。

选择排序原理：第一次从待排序的元素中选出最小（最大）的元素，存放在序列的起始位置，然后从剩余未排序的元素中寻找到最小（大）的元素，然后放在已排序序列的末尾，以此类推，直到待排序的元素个数为0。

8b31cb0fb36d46b48543eca95039dc44.png

00a4cadaadc8457c92808ed093019432.png

堆排序实现

void HeapSort(Heap& heap)
{
    if (heap.size < 1) return 0;
    
    while (heap.size > 0)
    {
        int tmp = heap.arr[0];
        heap.arr[0] = heap.arr[heap.size - 1];
        heap.arr[size - 1] = tmp;
        
        heap.size --;
        adjustDown(heap, 0);
    }
}

判断堆是否为空 

bool isEmpty(Heap& heap)
{
    if (heap.size < 1) return true;
    
    return false;
}

遍历打印堆

打印堆中的数据，可以有两种打印格式。第一种是按照堆的物理结构进行打印，即打印一排连续的数字；第二种打印格式是按照堆的逻辑结构进行打印，即打印成树形结构。

第一种方法使用正常的数组遍历就可以实现，这里展示如何使用树形结构打印出堆中元素

//求节点数为n的二叉树的深度
int depth(int n)
{
    if (n > 0)
    {
        int m = 2; 
        int hight = 1;
        while (m < n + 1)
        {
            m *= 2;
            hight ++;
        }
        return hight;
    else 
        return 0;
}

//打印堆
void HeapPrint(Heap& heap)
{
    //按照物理结构进行打印
    for (int i = 0; i < heap.size; i ++ )
        printf("%d ", heap.arr[i]);

    //按照树形结构进行打印
    int h = depth(heap.size);
    int N = pow(2, h) - 1; //与该二叉树深度相同的满二叉树的节点总数
    int space = N - 1;    //记录每一行前面的空格数
    int row = 1;     //当前打印的行数
    int pos = 0;    //待打印的数据的下标
    
    while (1)
    {
        //打印前面的空格
        for (int i = 0; i < space; i ++ )
            cout << " ";
        
        //打印数据和间距
        int count = pow(2, row - 1);    //每一行的数字个数
        while (count --)    //打印一行
        {
            printf("%02d", heap.arr[pos ++]); 
            
            int distance = (space + 1) * 2;    //两个数之间的空格数
            while(distance --)
            {
                cout << " " ;
            }
            if (pos >= heap.size)
            {
                cout << endl;
                return;
            }
        }
        cout << endl;
        row ++;
        space = space / 2 - 1;
    }
}

销毁堆

void destroy(Heap& heap)
{
    if (heap.arr) delete[] heap.arr;
    
    heap.arr = NULL;    //及时置空
    heap.size = 0;    //元素个数置0
    heap.capacity = 0;    //容量置0
}

 堆的实际开发应用

优先队列

操作系统内核作业调度是优先队列的一个应用实例，它根据优先级的高低而不是先到先服务的方式来进行调度；

如果最小键值元素拥有最高的优先级。那么这种优先队列叫做升序优先队列（即总是先删除最小的元素），类似的，如果最大键值元素拥有最高的优先级，那么这种优先队列叫做降序优先队列（即总是先删除最大的元素）

参考文献：

C++数据结构详解——堆

数据结构--二叉树--详解

C++实现树 - 01 树的三种表示法

结语：

笔记到这里结束了，在之后的学习中笔者会不断补充增加自己的知识，努力做的更好，大家共勉。

附录

总测试代码

#include <iostream>
#include <stdlib.h>
#include <cstring>
#include <cmath>

using namespace std;

#define DEFAULT_CAPACITY 128

typedef struct Heap
{
    int* arr;   
    int size;
    int capacity;
}Heap;

bool initHeap(Heap& heap, int* orginal, int size);
void buildHeap(Heap& heap);
void adjustDown(Heap& heap, int index);
void adjustUp(Heap& heap, int index);
bool insertHeap(Heap& heap, int value);
bool popMax(Heap& heap, int& value);
bool isEmpty(Heap& heap);
int depth(int n);
void HeapPrint(Heap& heap);
void destroy(Heap& heap);
void HeapSort(Heap& heap);

//初始化堆
bool initHeap(Heap& heap, int* orignArray, int size)
{
    int capacity = DEFAULT_CAPACITY > size ? DEFAULT_CAPACITY : size;
    heap.arr = new int[capacity];
    if (!heap.arr) 
    {
        cout << "内存分配失败 " << endl;
        return false;    
    }

    heap.capacity = capacity;
    heap.size = 0;

    if (size)
    {
        memcpy(heap.arr, orignArray, size * sizeof(int));
        heap.size = size;

        buildHeap(heap);
    }
    return true;
}

void buildHeap(Heap& heap)
{
    for (int i = (heap.size - 1) / 2; i >= 0; i --)
        adjustDown(heap, i);

}

void adjustDown(Heap& heap, int index)
{
    int cur = heap.arr[index];
    int parent, child;

    for (parent = index; (parent * 2 + 1) < heap.size; parent = child)
    {
        child = parent * 2 + 1;

        if ((child + 1) < heap.size && (heap.arr[child + 1] > heap.arr[child]))
            child ++;
        if (cur >= heap.arr[child]) break;
        else 
        {
            heap.arr[parent] = heap.arr[child];
            heap.arr[child] = cur;
        }
    }
}

void adjustUp(Heap& heap, int index)
{
    if (index < 0 || index >= heap.size) return ;  //索引值越界，返回

    int temp = heap.arr[index]; //temp为插入的值

    while (index > 0)
    {
        int parent = (index - 1) / 2;
        if (parent >= 0)
        {
            if (heap.arr[parent] < temp)
            {
                heap.arr[index] = heap.arr[parent];
                heap.arr[parent] = temp;
                index = parent; 
            }
            else break; //比父节点小，则不需要调整
        }
        else break; //越界，返回
    }
}

bool insertHeap(Heap& heap, int value)
{
    if (heap.size == heap.capacity) 
    {
        cout << "栈空间耗尽！" << endl;
        return false;
    }

    int index = heap.size;  //插入元素的索引
    heap.arr[heap.size ++] = value;
    adjustUp(heap, index);

    return true;
}

bool popMax(Heap& heap, int& value)
{
    if (heap.size < 1) return false;

    value = heap.arr[0];
    heap.arr[0] = heap.arr[-- heap.size];
    adjustDown(heap, 0);  //向下调整
    
    return true;
}

bool isEmpty(Heap& heap)
{
    if (heap.size < 1) return true;

    return false;
}

int depth(int n)
{
    if (n > 0)
    {
        int m = 2;
        int hight = 1;
        while (m < n + 1)
        {
            m *= 2;
            hight ++;
        }
        return hight;
    }
    else return 0;

}

void HeapPrint(Heap& heap)
{
    //按照树形结构进行打印，这种space 和 distance 的计算方式适用于域宽为2的数字
    int h = depth(heap.size);
    int N = pow(2, h) - 1;
    int space = N - 1;
    int row = 1;
    int pos = 0;

    while (1)
    {
        for (int i = 0; i < space; i ++ )
            cout << " " ;
        
        int count = pow(2, row - 1);
        while (count -- )
        {
            printf("%02d", heap.arr[pos ++]);       //设置域宽为2

            if (pos >= heap.size)
            {
                cout << endl;
                return;
            }
            int distance = (space + 1) * 2; //上一行的space等于下一行的distance，第一行的space等于N - 1,
            while (distance --)
            {
                cout << " " ;
            }
        }
        cout << endl;
        row ++;
        space = space / 2 - 1;

    }
}

void destroy(Heap& heap)
{
    if (heap.arr) delete[] heap.arr;

    heap.arr = NULL;
    heap.size = 0;
    heap.capacity = 0;
}

void HeapSort(Heap& heap)
{
    if (heap.size < 1) return ;

    while (heap.size > 0)
    {
         int temp = heap.arr[0];
         heap.arr[0] = heap.arr[-- heap.size];
         heap.arr[heap.size] = temp;

         adjustDown(heap, 0); 
    }
}

int main()
{
    Heap heap;
    int orignArray[] = {82,95,85,96,86,94,96,95};

    if (!initHeap(heap, orignArray, sizeof(orignArray) / sizeof(orignArray[0])))
    {
        cout << "初始化失败。" << endl;
        exit(-1);
    }

    for (int i = 0; i < heap.size; i ++ )
        printf("第%d个数为： %d\n",i, heap.arr[i]);

    cout << "分割线--------------------" << endl;

    printf("在堆中插入新的元素99，插入结果：\n");
    insertHeap(heap, 99);
    for (int i = 0; i < heap.size; i ++ )
        printf("第%d个数为:%d\n", i, heap.arr[i]);

    // int value;
    // while (popMax(heap, value))
    //     cout << "依次列出最大元素：" << value << endl;

    HeapPrint(heap);

    return 0;
}

 

 

 

Whisper_lx
关注
Java学习笔记：二叉树
mokari的博客
10-28 732
当结点的度为1时，其孩子必为叶结点且为左叶结点。孩子结点：子树的根结点为一个结点的"后继"，该子树的根结点则为这个结点的孩子结点，如B，C 为A 的孩子结点。结点祖先：从一个结点开始向父结点溯源至根结点的所有结点都为该节点的祖先，如上图D 结点的祖先为B和A。二叉树是树的一种特殊形式，在二叉树中，每个结点的度最大为2，即对一个结点而言，一个结点最多有两棵子树。父结点：一个结点的"后继"指向其他结点，此时该结点为其他结点的父结点。叶结点：结点没有后继(孩子结点)，即结点的度为0，如D，E，F，G。
[数据结构] -堆与二叉树 【学习笔记】
Iiverson2000的博客
04-26 991
二叉树 1、满二叉树：k层满二叉树节点总数位（2^k）-1 2、完全二叉树：可以不满，但必须按顺序 告诉你一棵二叉树有N个节点，那么他的高度是多少？ 2^k - 1 =N k = log(N+1) 若根节点为第一层，那么非空二叉树的第i层上最多有2^(i-1)个节点 若根节点为第一层，那么深度为h的二叉树的最大结点数是 2^h -1 度为零的节点个数比度为二的节点个数多一个：n0 = n2 +1; 来两道题练练手，看看概念理解的怎么样？ 1、某二叉树共有 399 个结点，其中 有199个为 度为2的
二叉树学习笔记
BlueDre的博客
07-25 796
在了解二叉树之前，首先要了解比二叉树更大一级的概念，不仅是为了在学习二叉树的时候不至于不明白这两个具有包含关系的两个事物的相同之处，还是为了能够在有一个更为宏观的认知，不至于管中窥豹。
堆学习笔记
ZiYuTongXue的博客
12-06 150
堆是用来处理优先队列的一种方式。 优先队列是指所有存储的信息以某种特定的排序规则排序。 一般的队列是按照来的时间先后排序，而堆是某种特定序列，比如来的年龄最大的站在最前面，或者退伍军人站在最前面，这种指定排序规则的队列就是优先队列。 优先队列的想法很简单，实现方式也很简单，关键的是如何存储，即找一种存储效率高的数据结构才存储堆。 树是堆的最优存储方式，而且是顺序存储的完全二叉树。 递归定义，...
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 42万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
关于C++数据结构中的二叉树的学习笔记
weixin_44980842的博客
10-16 262
这两天回顾了二叉树的上和下的算法专栏，先用这篇博客来记录我的学习笔记。 本.txt,我将再一次学习二叉树这种数据结构！ 前面我们都只是讲了线性表结构而已，比如：栈和队列等数据结构。那么今天我们将来讲解一种非线性表结构---树！ 树这种数据结构比线性表的数据结构要复杂得多！内容也比较多，因此专栏的王老师分为了4节课去讲解！ 二叉树的存储方式主要有2种方式，分别是 链式存储 和 顺序存储 所谓的链式存储其实就是用链表list来do树这种数据结构！ 所谓的顺序存储其实就是用数组arr来do树这种数据
嵌入式数据结构—学习笔记 二叉树
qq_58277444的博客
07-10 791
二叉树是计算机科学中的一种重要的数据结构，
二叉树 | 代码随想录学习笔记
qq_44250700的博客
08-10 237
二叉树的定义与链表差不多，只不过二叉树的节点里多了两个指针：指向左右孩子。
数据结构 二叉树--学习笔记
weixin_48271092的博客
03-02 297
1. 树型结构 1.1 概念 树是一种非线性的数据结构，它是由n(n>=0)个有限结点组成一个具有层次关系的集合。 树型结构便于利用分支进行查找和搜索。 · 有一个特殊的节点，称为根节点，根节点没有前驱节点。 · 除根节点外，其余节点被分为M(M>0)个互不相交的集合T1、T2...Tm，其中每一个集合， ...
C+学习笔记+树、堆、二叉树代码
03-28
适合人群：学生，学习初阶数据结构的人群 能学到什么：通过简单的代码，用C语言实现了堆的一些相关接口，比如堆的初始化创建销毁，插入删除，堆排序，TOPK问题解决等等...还有一些链式二叉树的相关内容，在这里为了...
数据结构学习笔记；算法学习笔记；python实现；.zip
02-22
此外，算法的学习笔记会涵盖算法设计策略、时间复杂度和空间复杂度分析，以及各种算法的实现细节。 Python的简洁性和丰富的库使得它成为学习数据结构和算法的理想选择。在实践中，掌握这些知识不仅可以提升编程技能...
二叉树学习笔记（二）之堆
小菜羊的博客
12-18 398
文章目录堆堆的定义堆的实现堆的筛选堆的插入建堆删除堆顶结点堆排序附上一张总结图 继续上一篇笔记，本文接着讲 堆 。 堆 堆是一类完全二叉树，常用于实现排序，选择最小（大）值和优先队列等 **优先队列：**一种特殊的队列，队列中元素出栈的顺序是按照元素的优先权大小，而不是元素入队的先后顺序。 堆的定义 堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质： 堆中所有非叶子结点总是不大于或不...
AIGC学习笔记—minimind详解+训练+推理
m0_56569131的博客
09-27 259
这个开源项目是带我的一个导师，推荐我看的，记录一下整个过程，总结一下收获。这个项目的slogan是“大道至简”，确实很简。作者说是这个项目为了帮助初学者快速入门大语言模型（LLM），通过从零开始训练一个仅26MB的微型语言模型MiniMind，最快可在3小时内完成。降低学习LLM的门槛，让更多人能够轻松上手。MiniMind极其轻量，约为GPT-3的1/7000，适合普通个人GPU进行快速推理和训练。
H.264学习笔记
zfenggo的博客
09-26 791
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
江科大笔记—LED闪烁& LED流水灯& 蜂鸣器
m0_62005595的博客
09-28 384
LED闪烁& LED流水灯& 蜂鸣器
Maya学习笔记：项目设置和快捷键
吴梓穆的博客
09-24 399
快速空格：切换三视图，鼠标放到对应的视图上，在快速按空格，可以切到对应视图。在项目窗口里，选择要生成的子文件夹（保持默认即可），然后点下边的接受。文件/最下边选择最近的项目，在右侧展开菜单里选择刚创建的目录。只后场景会被默认保存在这个文件夹下的scenes里。F：先点击一个物体，在按F，选中的物体居中显示。主键盘5：平滑着色显示模型（默认的方式）选择一个文件夹，然后选择创建默认工作区。alt+滚路或右键拖动：缩放视角。alt+左键拖动：旋转视角。alt+中键拖动：移动视角。A：场景所有物体居中显示。
React学习笔记（2.0）
mez_Blog的博客
09-26 465
本质：和普通JS变量不同的是，状态变量一旦发生变化组件的视图UI也会跟着发生变化（数据驱动视图），可以类比与vue中的响应式。这里的e就是一个类似原生的事件e，并不是真正的原生事件e,如果要使用原生事件e，需要使用 e.nativeEvent。在React中，一个组件就是首字母大写的函数，内部存放了组件的逻辑和视图UI，渲染组件只需要把组件当成标签书写即可。概念：一个组件就是用户界面的一部分，他可以有自己的逻辑和外观，组件之间可以相互嵌套，也可以复用多次。在css文件中定义样式，然后在引入使用。
Coursera_ Algorithms I 学习笔记：Module_3_Analysis_of_Algorithm_Introduction
最新发布
approximately_的博客
09-29 907
Coursera_ Algorithms I 学习笔记：Module_3_Analysis_of_Algorithm_Introduction
数据结构学习笔记c++
08-23
下面是一些数据结构的基本概念，你可以在学习笔记中包含它们： 1. 数组（Array）：一种线性数据结构，可以存储相同类型的元素。在C语言中，数组是通过索引访问的。 2. 链表（Linked List）：也是一种线性数据结构...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值