第4章 二叉树和BST

于 2024-08-29 19:52:28 发布
阅读量285 收藏 12
点赞数 11
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74916669/article/details/141686696
版权

树与二叉树

1. 基本概念

树是一种非线性结构，其严格的数学定义是：如果一组数据中除了第一个节点（第一个节点称为根节 点，没有直接前驱节点）之外，其余任意节点有且仅有一个直接前驱，有零个或多个直接后继，这样 的一组数据形成一棵树。这种特性简称为一对多的逻辑关系。即用于描述具有层次关系，类似组织架 构关系的一种数据结构。

树的组成：根，分支，叶子

2. 常见例子

日常生活中，很多数据的组织形式本质上是一棵树。比如一个公司中的职员层级关系，一个学校中的 院系层级关系，淘汰赛中的各次比赛队伍，一个家族中的族谱成员关系等，这些都是树状逻辑结构。 由于树状结构表现出来都是具有层次的，因此也被称为层次结构。

3. 相关术语

通常，在逻辑上表达一棵抽象的树状结构的时候，习惯于将树根放在顶部，树枝树杈向下生长，如下 图所示。

对于一棵树来说，有如下基本术语：

1. 结点：

树中的元素 及其子树

2. 根（root）：

树的第一个节点，没有直接前驱。如上图中的A。

3. 双亲节点/父节点（parent）：

某节点的直接前驱称为该节点的双亲节点，或成为父节点。例如上图中A是B的父节点。

4. 孩子节点/子节点（child）：

某节点的直接后继称为该节点的孩子节点。例如上图中B、C、D均为A的孩子节点。

5. 节点的层次（level）：

根节点所在的层次规定为第1层，其孩子所在的层次为第2层，后代节点以此类推。比如上图中节 点E的层次是3。

6. 节点的度（degree）：

一个节点拥有的孩子节点的总数，称为该节点的度。比如上图中节点B的度为2。

7. 叶子（leaf）：

一棵树中度等于0的节点，被称为叶子，又称为终端节点。比如上图中K、L、F、G、M、I、J均为 叶子。

8. 树的高度（height）：

一棵树中所有节点的层次的最大值，称为这棵树的高度，又称为树的深度。比如上图的树的高度为 4。

9. 有序树与无序树：

一棵树中，如果某个节点的孩子节点之间是有次序的，则称这棵树为有序树，反之称为无序树。


4. 二叉树

在各种不同的树状结构中，最常见也最重要的是二叉树（Binary Tree），下面是二叉树的定义：

有序树

任意节点的度小于等于2

比如如下这棵树就是一棵二叉树。其中8是根节点，14是10的右孩子（因为二叉树是有序树，因此严 格区分左右），而13则是14的左孩子。

为了方便对二叉树进行操作，通常会对一棵它进行标号：从上到下，从左到右进行标号：

注意：

没有孩子节点的地方也要标出来

对于二叉树而言，有如下特性：

1. 第𝑖层上，最多有2𝑖−1个节点。

2. 高度为𝑘的二叉树，最多有2𝑘−1个节点。

3. 假设叶子数目为𝑛0，度为2的节点数目为𝑛2，则有：

二叉树的一般结构：

满二叉树

一棵深度为k，且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是 最大结点数。

简单理解： 除了叶子节点之外，其余节点的度都为2；其特点是： 如果深度为 K，则节点数为 2^K - 1。

完全二叉树

在一棵二叉树中，除最后一层外，若其余层都是满的，或者最后一层是满的，或者是最后一层在右 边缺少连续若干结点，则此二叉树为完全二叉树。

简单理解：除最后一层叶子节点外。是一颗满二叉树，最后一层由右向左有连续缺省的0个,1个或 多个节点。

二叉搜索树(BST) 特点：

1. 如果节点具有左子树，则左子树上所有节点都不大于该节点的值；

2. 节点具有右子树，则右子树上所有节点都不小于该节点的值；

3. 子树又是二叉搜索数

二叉搜索树（BST）

二叉树（BST）的组成

根指针：指向根节点的指针变量

节点：

数据域 (存储的实际数据)

指针域 (左，右指针)

结构设计：

typedef int data_t;
typedef struct _node
{
data_t data; // 数据域
struct _node *left; // 左子树指针
struct _node *right;// 右子树指针
}NODE;

二叉树（BST）的算法

创建二叉树

int btree_create(NODE** root,data_t data);

二叉树数据添加

int btree_add(NODE** root,data_t data);

示例图：

二叉树数据遍历

前序遍历（先序遍历，即 根左右 )）

void Preorder(const NODE* root);

前序遍历通俗的说就是从二叉树的根结点出发，先输出根结点数据，然后输出左结点，最后输 出右结点的数据。

从根结点出发，则第一次到达结点A，故输出A;继续向左访问，第一次访问结点B，故输出B； 按照同样规则，输出D，输出H；当到达叶子结点H，返回到D，此时已经是第二次到达D，故不 在输出D，进而向D右子树访问，D右子树不为空，则访问至I，第一次到达I，则输出I；I为叶子 结点，则返回到D，D左右子树已经访问完毕，则返回到B，进而到B右子树，第一次到达E，故 输出E；向E左子树，故输出J；按照同样的访问规则，继续输出C、F、G。

前序遍历输出结果：ABDHIEJCFG 中序

遍历（即 左根右 ）

void Midorder(const NODE* root);

中序遍历通俗的说就是从二叉树的根结点出发，先输出左结点数据，然后输出根结点，最后输 出右结点的数据。

从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出 B；继续到达D，H；

到达H，H左子树为空，则返回到H，此时第二次访问H，故输出H；H右子树为空，则返回至 D，此时第二次到达

D，故输出D；由D返回至B，第二次到达B，故输出B；按照同样规则继续访问，输出J、E、A、 F、C、G；

中序遍历输出结果：HDIBJEAFCG

后序遍历（即 左右根 ）

void Postorder(const NODE* root);

后序遍历通俗的说就是从二叉树的根结点出发，先输出左结点数据，然后输出右结点，最后输 出根结点的数据。

从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出 B；继续到达D，H；

到达H，H左子树为空，则返回到H，此时第二次访问H，不输出H；H右子树为空，则返回至 H，此时第三次到达

H，故输出H；由H返回至D，第二次到达D，不输出D；继续访问至I，I左右子树均为空，故第 三次访问I时，输出

I；返回至D，此时第三次到达D，故输出D；按照同样规则继续访问，输出J、E、B、F、G、 C，A；

后序遍历输出为： HIDJEBFGCA

层序遍历

 void Levelorder(const NODE* root);

二叉树数据查询

NODE* btree_find(const NODE* root,data_t data);

① 从根结点出发

② 如果比根节点小，那么就去其左子树找

③ 如果比根节点大就去其右子树找

④ 找到叶子都没找到， 就代表查找失败

二叉树数据更新

int btree_update(const NODE* root,data_t old,data_t newdata);

二叉树回收

void btree_destroy(NODE** root);

二叉树数据删除

int btree_delete(NODE** root,data_t data);

原则：将待删除的节点尽量转换为删除叶子节点，因为删除叶子节点对BST树影响是最小的；

思路：

① 从根节点开始遍历BST找到待删除的节点；

② 对待删除的节点状态进行判断，如果节点有左子树，找到左子树中最大的节点，然后利用 左子树中最大的节 点数据替换待删除的节点数据，删除左子树中最大的节点；左子树中最大的节点大概率 是叶子节点。

③ 如果节点只有右子树，找到右子树中最小的节点，然后 利用右子树中最小的节点数据替 换待删除的节点数 据，删除右子树中最小的节点；右子树中最小的节点大概率是叶子节点。

④ 如果待删除节点是叶子节点，直接删除。

二叉树（BST）完整实现

队列实现

SQueue.h

#ifndef __SQUEUE_H
#define __SQUEUE_H
#include "btree.h"
typedef NODE* type_t;
typedef struct
{
type_t *pData;
int size;
int head;
int tail;
}SQueue;
int SQ_init(SQueue *q, int num);
int SQ_isfull(SQueue *q);
int SQ_isempty(SQueue *q);
int SQ_push(SQueue *q,type_t data);
int SQ_pop(SQueue *q,type_t *data);
int SQ_free(SQueue *q);
#endif



SQueue.c

#include <stdlib.h>
#include "SQueue.h"
int SQ_init(SQueue* q,int num)
{
q -> pData = (type_t*)calloc(sizeof(type_t),num);
if(q -> pData == NULL)
return -1;
q -> size = num ;
q -> head = q -> tail = 0;
return 0;
}
int SQ_isfull(SQueue *q)
{
return (q -> tail + 1) % q -> size == q -> head;
}
int SQ_isempty(SQueue *q)
{
return q -> tail == q -> head;
}
int SQ_push(SQueue *st,type_t data)
{
if(SQ_isfull(st))
return -1;
st -> pData[st -> tail] = data;
st -> tail = (st -> tail+1) % st -> size;
return 0;
}
int SQ_pop(SQueue *st,type_t *data)
{
if(SQ_isempty(st))
return -1;
*data = st -> pData[st -> head];
st -> head = (st -> head+1) % st -> size;
return 0;
}
int SQ_free(SQueue *st)
{
if(st -> pData)
{
free(st->pData);
st -> pData = NULL;
}
st -> head = st -> tail = 0;
}

树的实现

btree.h

#ifndef __BTREE_H
#define __BTREE_H
typedef int data_t;
typedef struct _node
{
data_t data; // 节点上的数据
struct _node *left; // 该节点左侧子节点的地址
struct _node *right;// 该节点右侧子节点的地址
}NODE;
// 创建搜索二叉树
int btree_create(NODE** root,data_t data);
// 二叉树数据添加
int btree_add(NODE** root,data_t data);
// 二叉树数据删除
int btree_delete(NODE** root,data_t data);
// 二叉树前序遍历
void Preorder(const NODE* root);
// 二叉树中序遍历
void Midorder(const NODE* root);
// 二叉树后序遍历
void Postorder(const NODE* root);
// 二叉树层序遍历
void Levelorder(const NODE* root);
// 二叉树数据查询
NODE* btree_find(const NODE* root,data_t data);
// 更新二叉树数据old 为 newdata
int btree_update(const NODE* root,data_t old,data_t newdata);
// 二叉树回收
void btree_destroy(NODE** root);
#endif

btree.c

#include "btree.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "SQueue.h"
/*
@function: int btree_create(NODE** root,data_t data)
@brief: 创建搜索二叉树
@argument: root: 根指针地址
@argument: data: 存储的数据
@ret : 0 成功
-1 失败
*/
int btree_create(NODE** root,data_t data)
{
if(*root)
return -1;
NODE* p = (NODE*)malloc(sizeof(NODE));
if(!p)
return -1;
p -> data = data;
p -> left = NULL;
p -> right = NULL;
*root = p;
return 0;
}
/*
@function: int btree_add(NODE** root,data_t data)
@brief: 二叉树数据添加
@argument: root: 根指针地址
@argument: data: 添加的数据
@ret : 0 成功
-1 失败
*/
int btree_add(NODE** root,data_t data)
{
NODE* pNew = (NODE*)malloc(sizeof(NODE));
if(!pNew)
return -1;
pNew -> data = data;
pNew -> left = NULL;
pNew -> right = NULL;
NODE* p = *root, *q = NULL;
if(!p)
{
*root = pNew;
return 0;
}
while(p)
{
q = p;
if(memcmp(&data,&(p -> data),sizeof(data_t)) < 0)
p = p -> left;
else
p = p -> right;
}
if(memcmp(&data,&(q -> data),sizeof(data_t)) < 0)
q -> left = pNew;
else
q -> right = pNew;
return 0;
}
/*
@function: int btree_delete(NODE** root,data_t data)
@brief: 二叉树数据删除
@argument: root: 根指针地址
@argument: data: 待删除的节点数据
@ret : 0 成功
-1 失败
*/
int btree_delete(NODE** root,data_t data)
{
/*
原则：将待删除的节点尽量转换为删除叶子节点，因为删除叶子节点对BST树影响是最小的；
思路：
1. 从根节点开始遍历BST找到待删除的节点；
2. 对待删除的节点状态进行判断，如果节点有左子树，找到左子树中最大的节点，然后利用左子树中最大的
节点数据替换待删除 的节点数据，删除左子树中最大的节点；左子树中最大的节点大概率是叶子节点
3. 如果节点只有右子树，找到右子树中最小的节点，然后 利用右子树中最小的节点数据替换待删除的节点
数据，删除右子树中 最小的节点；右子树中最小的节点大概率是叶子节点
4. 如果待删除节点是叶子节点，直接删除。
*/
NODE* del = *root; //指向待删除的节点
NODE* parent = NULL; //指向实际删除节点的双亲节点
NODE* replace = NULL; //指向实际删除的节点
while(del)
{
if(memcmp(&(del -> data),&data,sizeof(data_t)) < 0) //待删除的数据大于当前节点数据，向右子
树继续查找
{
parent = del;
del = del -> right;
}
else if(memcmp(&(del->data),&data,sizeof(data_t)) > 0) //待删除的数据小于当前节点数据，向
左子树继续查找
{
parent = del;
del = del -> left;
}
else // 找到了待删除的节点
{
if(del -> left) //待删除的节点有左子树
{
parent = del ;
replace = del -> left;
while(replace -> right) //找左子树中最大的节点
{
parent = replace;
replace = replace -> right;
}
del -> data = replace -> data;
if(parent -> right == replace) //实际删除的节点在双亲节点的右子树上
parent -> right = replace -> left;
else
parent -> left = replace -> left;
free(replace);
}
else if(del -> right) //待删除的节点只有右子树
{
parent = del;
replace = del -> right;
while(replace -> left)
{
parent = replace;
replace = replace -> left;
}
del -> data = replace -> data;
if(parent -> right == replace)
parent -> right = replace -> right;
else
parent -> left = replace -> right;
free(replace);
}
else //待删除的节点是叶子
{
if(!parent)
{
free(del);
*root = NULL;
return 0;
}
if(parent -> left == del)
parent -> left = NULL;
else
parent -> right = NULL;
free(del);
}
return 0;
}
}
return -1;
}
/*
@function: void Preorder(const NODE* root)
@brief: 二叉树前序遍历
@argument: root: 根指针
@ret : 无
*/
void Preorder(const NODE* root)
{
if(!root)
return ;
printf("%4d",root -> data);
Preorder(root->left);
Preorder(root->right);
}
/*
@function: void Midorder(const NODE* root)
@brief: 二叉树中序遍历
@argument: root: 根指针
@ret : 无
*/
void Midorder(const NODE* root)
{
if(!root)
return ;
Midorder(root->left);
printf("%4d",root -> data);
Midorder(root->right);
}
/*
@function: void Postorder(const NODE* root)
@brief: 二叉树后序遍历
@argument: root: 根指针
@ret : 无
*/
void Postorder(const NODE* root)
{
if(!root)
return ;
Postorder(root->left);
Postorder(root->right);
printf("%4d",root -> data);
}
/*
@function: void Postorder(const NODE* root)
@brief: 二叉树层序遍历
@argument: root: 根指针
@ret : 无
*/
void Levelorder(const NODE* root)
{
SQueue q;
SQ_init(&q,100);
SQ_push(&q,(type_t)root);
while(!SQ_isempty(&q))
{
type_t dt;
if(0 == SQ_pop(&q,&dt))
{
printf("%4d",dt -> data);
if(dt -> left)
SQ_push(&q,dt->left);
if(dt -> right)
SQ_push(&q,dt->right);
}
}
printf("\n");
SQ_free(&q);
}
/*
@function: NODE* btree_find(const NODE* root,data_t data)
@brief: 二叉树数据查询
@argument: root: 根指针
@argument: data: 待查询的数据
@ret : 成功：返回查询到的节点地址
失败: NULL
*/
NODE* btree_find(const NODE* root,data_t data)
{
const NODE *p = root;
while(p)
{
if(memcmp(&data,&(p -> data),sizeof(data_t)) < 0)
p = p -> left;
else if(memcmp(&data,&(p -> data),sizeof(data_t)) > 0)
p = p -> right;
else
return (NODE*)p;
}
return NULL;
}
/*
@function: int btree_update(const NODE* root,data_t old,data_t newdata)
@brief: 更新二叉树数据old 为 newdata
@argument: root: 根指针
@argument: old: 待更新的数据
@argument: newdata: 更新后的数据
@ret : 成功：0
失败: -1
*/
int btree_update(const NODE* root,data_t old,data_t newdata)
{
NODE* pfind = btree_find(root,old);
if(!pfind)
return -1;
pfind -> data = newdata;
return 0;
}
/*
@function: void btree_destroy(NODE** root)
@brief: 二叉树回收
@argument: root: 根指针地址
@ret : 无
*/
static void btree_free(NODE* root)
{
if(!root)
return ;
btree_free(root->left);
btree_free(root->right);
free(root);
}
void btree_destroy(NODE** root)
{
btree_free(*root);
*root = NULL;
}

btree_main.c

#include "btree.h"
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define N 10
int main(void)
{
NODE *root = NULL;
register int i = 0;
data_t a[] = {20,15,25,10,19,28,6,13,26,30,11,27};
int n = sizeof a / sizeof a[0];
srand(time(NULL));
for(; i < n ; i++)
{
// int data = rand() % 99 + 1;
// printf("%4d",data);
// btree_add(&root,data);
btree_add(&root,a[i]);
}
printf("\n");
puts("====先序遍历====");
Preorder(root);
printf("\n");
puts("====中序遍历====");
Midorder(root);
printf("\n");
puts("====后序遍历====");
Postorder(root);
printf("\n");
puts("====层序遍历====");
Levelorder(root);
printf("\n");
data_t deldata = 0;
while(1)
{
printf("请输入要删除的数据(-1退出):");
scanf("%d",&deldata);
if(deldata == -1)
break;
if(btree_delete(&root,deldata) == -1)
{
puts("删除失败请重试...");
continue;
}
puts("====先序遍历====");
Preorder(root);
printf("\n");
}
btree_destroy(&root);
return 0;
}

不会玩。
关注
  • 11
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
(王道408考研数据结构)第五章树-第四节1：二叉树排序树(BST)及其操作
快乐江湖的博客
11-19 1718
文章目录一：二叉排序树基本概念二：二叉排序树查找二：二叉排序树插入/构建四：二叉排序树删除 一：二叉排序树基本概念 二叉排序树(Binary Sort Tree)：：又称之为二叉搜索树，它具有下面的性质 若其左子树不空，则左子树上所有结点的值均小于它根结点的值 若其左子树不空，则左子树上所有结点的值均大于它根结点的值 其左、右子树也分别是二叉排序树 由以上性质可知，二叉排序树的中序遍历是一个递增序列 二：二叉排序树查找 二叉排序树查找：若树非空，让目标值与根节点的值进行比较。查找成功返回结点指针，失败
二叉查找树(BST)，平衡二叉树(AVL)，红黑树之间的区别
Linkai12138的博客
10-14 1521
1. 4者的区别与联系 二叉树，二叉查找树(BST)，平衡二叉树(AVL)，红黑树之间的区别： 根据百度百科给出的定义，它们之间的关系可以用下图表示，平衡二叉树（平衡二叉查找树，AVL）和红黑树都是二叉查找树的一种，区别就是平衡二叉树严格平衡，红黑树是弱平衡。 而AVL树由于实现比较复杂，而且插入和删除性能差，在实际环境下的应用不如红黑树。 2. 二叉查找树（BST） 2.1 定义 左子树的值小于根节点的值，右子树的值全部大于根节点的值；左右子树分别都是一颗二叉查找树。（递归定义） 3.1.2 缺点 可
第五章 二叉树、树和森林
空梦❤的博客
09-30 3226
1.二叉树、树和森林的定义 　　(1)树的定义：树是n(n>=0)个结点的有限集。当n=0时，称为空树，任何一棵树都应满足： 　　　　　　①有且仅有一个特定的称为根的结点。 　　　　　　②当n>1时，其余节点可分为m(m>0)个互不相交的有限集T1,T2,...,Tm，其中每个集合本身又是一棵树，并且称为根的子树。 　　(2)二叉树的定义：二叉树是每个结点最多只有两颗子树，并且...............
C语言排序二叉树BST插入、删除和遍历
qq_45911878的博客
08-15 1378
一、什么是排序二叉树？ 如果一个二叉树的节点都是一个孩子比自己大或空，另一个比自己小或空，这样的二叉树称为排序二叉树也就是BST。 那么这样就分两种情况了，一个是左孩子小，右孩子大，另一种情况是左孩子大右孩子小。 如图示： 两种情况都可以。 下面以第一种情况进行讨论，给出案例： 可以看出，不仅是一个节点的左孩子比自己小，左孩子的孩子也比自己小，以此类推。 二、怎么创建排序二叉树？ 其实二叉树和双向链表差不多，都是保存一个数据和两个地址，不同点是双向链表保存的是自己的左节点和右节点地址，二叉树保存自己的两个
数据结构第六章 树和二叉树
郑哥哥の博客
08-23 501
文章目录基本术语树的性质二叉树二叉树的定义及其主要特性1.二叉树的定义2.几个特殊的二叉树3.二叉树的性质二叉树的存储结构1.顺序存储结构2.链式存储结构二叉树的遍历与线索二叉树1.先序遍历2.中序遍历3.后序遍历4.层序遍历线索二叉树1.线索二叉树的概念2.中序线索二叉树的构造树、森林树的存储结构1.双亲表示法2.孩子表示法3.孩子兄弟表示法树、森林、二叉树的转换树和二叉树的应用二叉排序树1.二叉排序树的定义2.二叉排序树的查找3.二叉树排序树的查找效率分析平衡二叉树1.平衡二叉树的插入2.平衡二叉树的4
【二叉树】BST的第k大结点,二叉树的深度,平衡二叉树
LauZyHou的笔记
10-23 1107
面试题54:二叉搜索树的第k个结点 给定一棵二叉搜索树，请找出其中的第k大的结点。 左边都比中间小，右边都比中间大，所以用中序遍历（左中右）就可以实现按结点的值从小到大遍历，遍历时候进行计数即可。 #include&amp;lt;bits/stdc++.h&amp;gt; #include &quot;../Utilities/BinaryTree.h&quot; using namespace std; //递归函数:输入...
第六章 树和二叉树习题1
03-20
8. 非空二叉树的第i层最多能有2i-1个节点，这是正确的，这是完全二叉树的性质。 9. 用二叉链表法存储n个节点的二叉树，确实有n+1个空指针，因为除了根节点，每个节点都只连接一个子节点。 10. 具有12个节点的完全...
第6章_树和二叉树 .ppt
12-05
**第6章 树和二叉树** 在计算机科学中，树是一种非线性数据结构，它由一组节点（或称为顶点）和一组连接这些节点的边组成，呈现出层次结构。这一章主要探讨了树的基本概念、二叉树的特性和应用，以及相关的操作方法...
二叉树（BST树）内结点的删除（3种情况全解）
热门推荐
Zxn、Sirius荣耀之路
08-05 3万+
现在有一棵二叉树查找树如下： 如果我们需要删除一个结点，而且在删除之后，依然满足二叉查找树的数据排序策略。此时删除操作可分为一下三种情况。如下情况1：结点没有左子树 如图：一棵没有左子树的二叉树 如果在此情况下删除结点，按照结点的位置又可以分为三种处理方式。如下 删除根结点：删除根结点也就是删除结点 5，此时只需将根结点指针指向其右子树结点。如下图 删除叶子结点：如果删除的结点是叶子结
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 675
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
排序------快速排序（C语言实现）
markingyi的博客
08-25 852
讲解快速排序原理，并通过例题使用C语言实现。
八股总结-----C++、数据结构、算法
m0_48022770的博客
08-25 336
存储可执行代码（程序指令）。：存储全局变量和静态变量（已初始化和未初始化）。：用于动态内存分配，由程序员管理。：存储函数调用中的局部数据（局部变量、参数、返回地址）。
Linux 数据结构 链表
最新发布
mxyzhy的博客
08-28 244
单向链表操作
数据结构之AVL树的 “奥秘“
robin_suli的博客
08-23 810
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索在二叉搜索树树平均查找长度是结点的深度的函数，即结点越深，则比较次数越多。如果需要 一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修 改，就不太适合。如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺 序表中搜索元素，效率低下。保证每个结点的左右子树高度之差的绝对值不超过 1。情况一：subLR平衡因子等于-1。情况二：subLR平衡因子等于1。subLR的平衡因子区分情况。
【初阶数据结构】顺序表和链表算法题（上）
2301_81072404的博客
08-22 734
数据结构与算法—顺序表链表篇
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 974
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
浅谈【数据结构】链表之单链表
weixin_67526434的博客
08-24 901
浅谈【数据结构】链表之单链表
C学习（数据结构）--＞二叉树
weixin_47298551的博客
08-22 702
对于深度为 K 的，有 n 个结点的二叉树，当且仅当其每一个结点都与度为 K 的满二叉树编号从 1 至 n 的结点一一对应时称之为完全二叉树。即一个二叉树是结点的一个有限集合，由一个根结点加上两棵别称为左子树和右子树的二叉树组成或者为空。也就是说，如果这个二叉树的层数为 K ，且结点总数是 2^k-1，那么它就是满二叉树。一般把堆（一种二叉树）使用顺序结构的数组来存储，要注意的是，这里的堆和操作系统虚拟进程地址空间中的堆是两回事，这里的堆是指数据结构。例如：深度为3，有6个结点的完全二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值