AI 助理
备案控制台
开发者社区 云计算 文章 正文

数据结构-树

2022-04-16 160
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 数据结构-树

树的基本概念

  • 树是递归定义的结构

  • 结点

    • 根节点：树只有一个根结点

    • 结点的度：结点拥有的子树的数量

      • 度为0：叶子结点或者终端结点

      • 度不为0：分支结点或者非终端结点

        • 分支结点除去根结点也称为内部结点
  • 树的度：树中所有结点的度数的最大值

  • 结点关系

    • 祖先结点

      • 根结点到该结点的唯一路径的任意结点
    • 子孙结点

    • 双亲结点

      • 根结点到该结点的唯一路径上最接近该结点的结点
    • 孩子结点

    • 兄弟结点

      • 有相同双亲结点的结点

  • 层次，高度，深度，树的高度

    • 层次：根为第一层，它的孩子为第二层，以此类推
    • 结点的深度：根结点开始自顶向下累加
    • 结点的高度：叶节点开始自底向上累加
    • 树的高度（深度）：树中结点的最大层数

  • 树的性质

    • 1.树中的结点数等于所有结点的度数加1。

      • 证明：不难想象，除根结点以外，每个结点有且仅有一个指向它的前驱结点。也就是说每个结点和指向它的分支一一对应。

假设树中一共有b个分支，那么除了根结点，整个树就包含有b个结点，所以整个树的结点数就是这b个结点加上根结点，设为n，则n=b+1。而分支数b也就是所有结点的度数，证毕。

* 2.度为m的树中第i层上至多有m^(i−1)个结点（i≥1）。
    * 证明：（数学归纳法）

首先考虑i=1的情况：第一层只有根结点，即一个结点，i=1带入式子满足。
假设第i-1层满足这个性质，第i-1层最多有m i-2个结点。
……… ..........
i-1层
………
又因为树的度为m,所以对于第i-1层的每个结点，最多
有m个孩子结点。所以第i层的结点数最多是i-1层的m
倍，所以第i层上最多有m ^(i-1)个结点。

* 3.高度为h的m叉树至多有(m^h-1)/(m-1)个结点
* 4.具有n个结点的m叉树的最小高度为logm(n(m-1)+1)

树的存储结构

  • 顺序存储结构

    • 双亲表示法：用一组连续的存储空间存储树的结点，同时在每个结点中，用一个变量存储该结点的双亲结点在数组中的位置。

  • 链式存储结构

    • 孩子表示法：把每个结点的孩子结点排列起来存储成一个单链表。所以n个结点就有n个链表；

如果是叶子结点，那这个结点的孩子单链表就是空的；
然后n个单链表的的头指针又存储在一个顺序表（数组）中。

* 孩子兄弟表示法：顾名思义就是要存储孩子和孩子结点的兄弟，具体来说，就是设置两个指针，分别指向该结

点的第一个孩子结点和这个孩子结点的右兄弟结点。

顺序存储：

void InitBiTree_Sq(SqBiTree T)
{
    int i;
    
    for(i=0; i<MAX_TREE_SIZE; i++)
        T[i] = '\0';                        //空树无结点，以空字符填充数组 
}

void ClearBiTree_Sq(SqBiTree T)                //清空与构造算法一样 
{
    int i;
    
    for(i=0; i<MAX_TREE_SIZE; i++)
        T[i] = '\0';
}

void DestroyBiTree_Sq(SqBiTree T)
{
    //二叉树无法销毁  
} 

Status BiTreeEmpty_Sq(SqBiTree T)
{
    return T[0]=='\0' ? TRUE : FALSE;
} 

Status CreateBiTree_Le_Sq(FILE *fp, SqBiTree T)
{
    char ch;
    int i = 0;
    
    while(Scanf(fp, "%c", &ch)==1 && ch!='\n')
    {
        if(ch == '^')
            T[i++] = '\0';
        else
            T[i++] = ch;
    }
    
    return OK;    
}

Status CreateBiTree_Pre_Sq(FILE *fp, SqBiTree T, int i)
{
    char ch;

    Scanf(fp, "%c", &ch);
    
    if(ch == '^')
        T[i] = '\0';
    else
    {
        T[i] = ch;
        CreateBiTree_Pre_Sq(fp, T, 2*i+1);
        CreateBiTree_Pre_Sq(fp, T, 2*i+2);
    }
    
    return OK;
}

int BiTreeLength_Sq(SqBiTree T)
{
    int len;
    
    for(len=MAX_TREE_SIZE; len-1>=0; len--)        //寻找最后一个结点 
    {
        if(T[len-1]!='\0')
            break;
    }
    
    return len;
}

int BiTreeDepth_Sq(SqBiTree T)
{
    int level=0;                            

    while((int)pow(2, level)-1<BiTreeLength_Sq(T))
        level++;
    
    return level;
}

Status Root_Sq(SqBiTree T, TElemType_Sq *e)
{
    if(BiTreeEmpty_Sq(T))                        //空树无根结点 
        return ERROR;
    
    *e = T[0];
    
    return OK;
} 

TElemType_Sq Value_Sq(SqBiTree T, Position s)
{
    int i =(int)pow(2, s.level-1)+s.order-2;    //将位序转变为树的次序（层序序列） 
    
    return T[i]; 
}

Status Assign_Sq(SqBiTree T, Position s, TElemType_Sq value)
{
    int i =(int)pow(2, s.level-1)+s.order-2;
    
    if(value=='\0' && (T[2*i+1]!='\0' || T[2*i+2]!='\0'))     //元素value是空值但s位序的结点有子树
        return ERROR;
    else if(value!='\0' && T[(i+1)/2-1]=='\0')                 //元素value不为空但s位序的结点无双亲结点
        return ERROR;
    else
        T[i] = value;
    
    return OK; 
}

TElemType_Sq Parent_Sq(SqBiTree T, TElemType_Sq e)
{
    int i;
    
    if(T[0]!='\0')                                //空树 
    {
        for(i=0; i<MAX_TREE_SIZE; i++)
        {
            if(T[i]==e)
                return T[(i+1)/2-1];
        }    
    }
    
    return '\0';                                //未找到e     
}

TElemType_Sq LeftChild_Sq(SqBiTree T, TElemType_Sq e)
{
    int i;
    
    if(T[0]=='\0')
        return '\0';                            //空树

    for(i=0; i<MAX_TREE_SIZE; i++)
    {
        if(T[i]==e)
            return T[2*i+1];
    }
    
    return '\0';                                //未找到e
} 

TElemType_Sq RightChild_Sq(SqBiTree T, TElemType_Sq e)
{
    int i;
    
    if(T[0]=='\0')
        return '\0';                            //空树 

    for(i=0; i<MAX_TREE_SIZE; i++)
    {
        if(T[i]==e)
            return T[2*i+2];
    }
    
    return '\0';                                //未找到e
} 

TElemType_Sq LeftSibling_Sq(SqBiTree T, TElemType_Sq e)
{
    int i;
    
    if(T[0]=='\0')
        return '\0';                            //空树 

    for(i=0; i<MAX_TREE_SIZE; i++)
    {
        if(i%2==0 && T[i]==e)                    //i为偶序数 
            return T[i-1];
    }
    
    return '\0';                                //未找到e
} 

TElemType_Sq RightSibling_Sq(SqBiTree T, TElemType_Sq e)
{
    int i;
    
    if(T[0]=='\0')                     
        return '\0';                            //空树 

    for(i=0; i<MAX_TREE_SIZE; i++)
    {
        if(i%2!=0 && T[i]==e)                    //i为奇序数
            return T[i+1];
    }
    
    return '\0';                                //未找到e
} 

void LevelOrderTraverse_Sq(SqBiTree T, void(Visit)(TElemType_Sq))
{
    int i;
    int len = BiTreeLength_Sq(T);
    
    for(i=0; i<len; i++)
    {
        if(T[i]!='\0')
            Visit(T[i]);
    }
}

void PreOrderTraverse_Sq(SqBiTree T, void(Visit)(TElemType_Sq), int i)
{
    if(T[i]!='\0')
    {
        Visit(T[i]);
        PreOrderTraverse_Sq(T, Visit, 2*i+1);
        PreOrderTraverse_Sq(T, Visit, 2*i+2);
    }    
}

void InOrderTraverse_Sq(SqBiTree T, void(Visit)(TElemType_Sq), int i)
{
    if(T[i]!='\0')
    {
        InOrderTraverse_Sq(T, Visit, 2*i+1);
        Visit(T[i]);
        InOrderTraverse_Sq(T, Visit, 2*i+2);
    }    
}

void PostOrderTraverse_Sq(SqBiTree T, void(Visit)(TElemType_Sq), int i)
{
    if(T[i]!='\0')
    {
        PostOrderTraverse_Sq(T, Visit, 2*i+1);
        PostOrderTraverse_Sq(T, Visit, 2*i+2);
        Visit(T[i]);
    }
}

void Print_Sq(SqBiTree T)
{
    int i, j, level;
    char tmp[MAX_TREE_SIZE][MAX_TREE_SIZE] = {}; 
    
    level = BiTreeDepth_Sq(T);
    
    for(i=1; i<=level; i++)
        for(j=1; j<=(int)pow(2,i-1); j++)
            tmp[i-1][(int)pow(2,level-i)+(j-1)*(int)pow(2,level-i+1)-1] = T[(int)pow(2,i-1)-1+j-1];
    
    for(i=0; i<level; i++)
    {
        for(j=0; j<2*(int)pow(2,level-1)-1; j++)
        {
            if(tmp[i][j]!='\0')
                printf("%c", tmp[i][j]);
            else
                printf(" ");
        }
        printf("\n");
    }
}

双亲表示：

void InitTree_P(PTree *T)
{
    (*T).n = 0;                                        //结点数量 
}

void ClearTree_P(PTree *T)
{
    (*T).n = 0;
}

void DestroyTree_P(PTree *T)
{
    //此存储结构下的树无法销毁 
} 

Status TreeEmpty_P(PTree T)
{
    return (T.n ? FALSE : TRUE); 
} 

Status CreateTree_P(FILE *fp, PTree *T)
{
    TElemType_P ch, p, tmp;
    int i, j;
    
    Scanf(fp, "%c", &ch);
    printf("录入树的根结点 %c \n", ch);
    Scanf(fp, "%c", &tmp);                            //跳过换行符 
    
    if(ch!='^')
    {
        i = 0;                                        //根结点起点设为0
        (*T).nodes[i].data = ch;
        (*T).nodes[i].parent = -1;
        
        j = -1;
        while(!feof(fp))
        {
            Scanf(fp, "%c", &p);
            printf("依次录入 %c 的孩子结点：", p);
            j++;
            while(1)
            {
                Scanf(fp, "%c", &ch);
                if(ch=='^' || ch=='\n')
                {
                    if(ch=='^')
                    {
                        printf("%c", ch);
                        Scanf(fp, "%c", &tmp);        //跳过换行符 
                    }
                        
                    break;
                }
                else
                {
                    printf("%c", ch);
                    i++;
                    (*T).nodes[i].data = ch;
                    (*T).nodes[i].parent = j;
                }
            }
            
            printf("\n");
        }
        
        (*T).n = i+1;        
    }
        
    return OK;
}

int TreeDegree_P(PTree T)
{
    int i, tmp, count;
    int max;
    
    max = count = 0;
    
    if(T.n)
    {
        tmp = T.nodes[0].parent;
        
        for(i=0; i<T.n; i++)
        {
            if(T.nodes[i].parent!=tmp)
            {
                tmp = T.nodes[i].parent;
                count = 1;            
            }
            else
                count++;
            
            if(count>max)
                max = count;
        }        
    }
    
    return max;
}

int TreeDepth_P(PTree T)                                        //由于按层序序列存储，故最后存储的结点必在最大层 
{
    int k, level;
    
    k = T.n-1;
    level = 0;
    
    if(T.n!=0)
    {
        level++;
        k = T.nodes[k].parent;
        
        while(k!=-1)
        {
            level++;
            k = T.nodes[k].parent;
        }
        
    }
    
    return level; 
}

TElemType_P Root_P(PTree T)
{
    if(T.n)
        return T.nodes[0].data;

    return '\0';
}

TElemType_P Value_P(PTree T, int i)
{
    if(T.n && i>0 && i<=T.n)
        return T.nodes[i-1].data;
    else
        return '\0';
}

int Order_P(PTree T, TElemType_P e)
{
    int i;
    int k = -1;
    
    for(i=0; i<T.n; i++)
    {
        if(T.nodes[i].data==e)
        {
            k = i;
            break;
        }
    }
    
    return k;
} 

Status Assign_P(PTree *T, TElemType_P e, TElemType_P value)
{
    int i;
    
    for(i=0; i<(*T).n; i++)
    {
        if((*T).nodes[i].data==e)
        {
            (*T).nodes[i].data = value;
            return OK;
        }
    }
    
    return ERROR;
}

TElemType_P ChildValue_P(PTree T, TElemType_P e, int order)
{
    int i, p, count;
    
    count = 0;
    for(i=1; i<T.n; i++)
    {
        p = T.nodes[i].parent;
        if(T.nodes[p].data==e)
        {
            count++;
            if(count==order)
                return T.nodes[i].data;
        }
    }
    
    return '\0';
}

TElemType_P Sibling_P(PTree T, TElemType_P e, int mark)
{
    int i;
    
    if(!TreeEmpty_P(T) && e!=T.nodes[0].data)
    {
        for(i=1; i<T.n; i++)
        {
            if(mark==0)                                        //左兄弟
            {
                if(T.nodes[i].data==e)
                    break;

                if(T.nodes[i].data!=e && i+1<T.n && T.nodes[i+1].parent==T.nodes[i].parent && T.nodes[i+1].data==e)
                    return T.nodes[i].data;
            }
            
            if(mark==1)                                        //右兄弟 
            {
                if(T.nodes[i].data==e && i+1<T.n && T.nodes[i].parent==T.nodes[i+1].parent)
                    return T.nodes[i+1].data;    
            } 
        }    
    }

    
    return '\0';
}

int ChildCount_P(PTree T, TElemType_P p)
{
    int k1, k2, count;
    
    if(TreeEmpty_P(T))                        //空树 
        return -1;

    k1 = Order_P(T, p);
    
    if(k1<0)                                //p结点不存在 
        return -2;
    
    k2 = k1 + 1;
    count = 0;
    while(k2<T.n)                            //统计孩子个数 
    {
        if(T.nodes[k2].parent==k1)
            count++;
        if(T.nodes[k2].parent>k1)
            break;
        k2++;
    }

    return count;
}

int ChildSeat_P(PTree T, TElemType_P p, int i)
{
    int k0, k1, k2, count;
    
    if(TreeEmpty_P(T))                            //空树 
        return -1;
    
    k0 = ChildCount_P(T, p);        //k0标记孩子个数 
    
    if(i<0 || k0<0 || i>k0+1)        //插入位置不正确 
        return -2;
    
    k1 = Order_P(T, p);

    k2 = k1 + 1;    
    if(i==0)                        //此时i为p最后一个结点的下一个位置
    {
        while(k2<T.n)
        {
            if(T.nodes[k2].parent>k1)
                break;
            k2++;
        }
    } 
    else
    {
        count = 0;
        
        while(k2<T.n)
        {
            if(T.nodes[k2].parent>=k1)
            {
                count++;
                if(count==i)
                    break;
            }
            
            k2++;
        }
    }

    return k2;    
}

Status InsertChild_P(PTree *T, TElemType_P p, int i, TElemType_P e)
{
    int k0, start, end;
    
    if(TreeEmpty_P((*T)) || !e)                //空树或e为空字符 
        return ERROR;

    k0 = 0;                                    //k0标记p的位置 
    while(k0<(*T).n)
    {
        if((*T).nodes[k0].data==p)
            break;
        k0++;
    }    
    
    if(k0==(*T).n)                            //p不存在 
        return ERROR;
    
    start = ChildSeat_P(*T, p, i);            //e结点的插入位置 
    if(start<=0)                            //插入位置不正确 
        return ERROR;
    
    end = (*T).n;
    while(end>start)
    {
        (*T).nodes[end].data = (*T).nodes[end-1].data;
        if((*T).nodes[end-1].parent<start)
            (*T).nodes[end].parent = (*T).nodes[end-1].parent;
        else
            (*T).nodes[end].parent = (*T).nodes[end-1].parent+1;
        end--;
    }
    
    (*T).nodes[start].data = e;
    (*T).nodes[start].parent = k0;
    (*T).n++;
    
    return OK;
}

Status InsertTree_P(PTree *T, TElemType_P p, int i, PTree t)
{
    int k;
    
    if(TreeEmpty_P((*T)) || TreeEmpty_P(t))                //空树 
        return ERROR;

    for(k=0; k<t.n; k++)
    {
        if(k==0)
            InsertChild_P(T, p, i, t.nodes[k].data);
        else
            InsertChild_P(T, t.nodes[t.nodes[k].parent].data, 0, t.nodes[k].data);
    }

    return OK; 
}

Status DeleteTree_P(PTree *T, TElemType_P p, int i)
{
    int k1;                                            //k1标记p的位置 
    int k2 , count;                                    //k2标记第i棵子树起点 
    int k3;
    int stack[MAX_TREE_SIZE], m, n;
    int k4, k5, order[MAX_TREE_SIZE] = {};
    
    for(k1=0; k1<(*T).n; k1++)
    {
        if((*T).nodes[k1].data==p)
            break;
        if(k1==(*T).n-1)
            return ERROR;        
    }
    
    count = 0;        
    for(k2=k1+1; k2<(*T).n; k2++)
    {
        if((*T).nodes[k2].parent==k1)
        {
            count++;
            if(count==i)
                break;
        }
        if(k2==(*T).n-1)
            return ERROR;        
    }
    
    m = n = 0;
    stack[n] = k2;
    n++; 
    (*T).nodes[k2].data = '\0';                    //抹掉此处的值
    
    k3=k2+1;
    while(k3<(*T).n && m<n)
    {        
        if((*T).nodes[k3].parent<stack[m])
            k3++;
        else if((*T).nodes[k3].parent>stack[m])
            m++;
        else        //(*T).nodes[k3].parent==stack[m]
        {
            (*T).nodes[k3].data = '\0';                    //抹掉此处的值
            stack[n] = k3;
            n++;
            k3++;
        }        
    }
    
    k5 = 0;
    for(k4=0; k4<(*T).n; k4++)                            //遍历树，找出各结点现在的实际位置 
    {
        if((*T).nodes[k4].data)
        {
            order[k4] = k5;
            k5++;
            
            if(k4)                                        //不为头结点 
                (*T).nodes[k4].parent = order[(*T).nodes[k4].parent];    //当前结点双亲结点位置发生变化 
        }
    }
    
    k4 = -1;
    k5 = 0;
    while(k5<(*T).n)                                        //遍历，去掉删除的结点 
    {
        if((*T).nodes[k5].data)
        {
            k4++;
            (*T).nodes[k4].data = (*T).nodes[k5].data;
            (*T).nodes[k4].parent = (*T).nodes[k5].parent;
        }
        
        k5++;
    }
        
    (*T).n = k4+1;
    
    return OK; 
}

void LevelOrderTraverse_P(PTree T, void(Visit)(TElemType_P))
{
    int i;
    
    for(i=0; i<T.n; i++)
        Visit(T.nodes[i].data);
}

void Print_P(PTree T)
{
    int row[MAX_TREE_SIZE];                        //各结点实际所处行 
    int col[MAX_TREE_SIZE];                        //各结点在其兄弟中的次序 
    int i, j, tmp;                                //tmp存放当前结点的父结点位置 
    int x[MAX_TREE_SIZE], y[MAX_TREE_SIZE];        //存放各结点打印时所处行和列（从0开始计数） 
    int count;
    int t[MAX_TREE_SIZE][MAX_TREE_SIZE]={};        //孩子链表存储结构 
    char a[MAX_TREE_SIZE][MAX_TREE_SIZE]={};    //按树的形状存放结点 
    SqStack S;
    SElemType_Sq e;

    if(T.n)
    {    
        j = 1;                                //j统计某孩子次序 
        row[0] = 1;
        col[0] = j;
        tmp = T.nodes[0].parent;
                
        for(i=1; i<T.n; i++) 
        {
            if(T.nodes[i].parent!=tmp)
            {
                j = 1;                            //若与上一个结点不属于同一双亲结点，则重新开始计数 
                tmp = T.nodes[i].parent;
            }
            else
                j++;
            
            col[i] = j;    
            row[i] = row[T.nodes[i].parent]+1;                
        }    
        
        for(i=1; i<T.n; i++)                                    //构造孩子链表 
        {
            tmp = T.nodes[i].parent;
            t[tmp][col[i]-1] = i;
        }
        
        count = 0;                                                //追踪行 
        InitStack_Sq(&S);
        Push_Sq(&S, 0);
        while(!StackEmpty_Sq(S))                                    //确定每个结点在树中所在行                
        {
            GetTop_Sq(S, &e);
            if(col[e]!=1)
                count++;
            x[e] = count;

            if(t[e][0])
                Push_Sq(&S, t[e][0]);            
            else
            {
                while(!StackEmpty_Sq(S))
                {
                    Pop_Sq(&S, &e);
                    if(t[T.nodes[e].parent][col[e]])
                    {
                        Push_Sq(&S, t[T.nodes[e].parent][col[e]]);
                        break;
                    }
                }
            }
            
        }

        for(i=0; i<T.n; i++)                                        //确定每个结点在树中所在列 
            y[i] = row[i]-1;

        for(i=0; i<T.n; i++)                                        //将各结点放入a中适当位置 
            a[x[i]][2*y[i]] = T.nodes[i].data;
                    
        for(i=0; i<=count; i++)
        {
            for(j=0; j<=2*y[T.n-1]; j++)
            {
                if(a[i][j])
                    printf("%c", a[i][j]);
                else
                    printf(".");
            }
                
            printf("\n");        
        }
    }
    else
        printf("空树无法打印！！\n");
}
文章标签：
云数据库 ClickHouse
存储
关键词：
数据结构树
Ethin
目录
相关文章
土木林森
|
3月前
|
存储 算法 C语言
"揭秘C语言中的王者之树——红黑树：一场数据结构与算法的华丽舞蹈，让你的程序效率飙升，直击性能巅峰！"
【8月更文挑战第20天】红黑树是自平衡二叉查找树，通过旋转和重着色保持平衡，确保高效执行插入、删除和查找操作，时间复杂度为O(log n)。本文介绍红黑树的基本属性、存储结构及其C语言实现。红黑树遵循五项基本规则以保持平衡状态。在C语言中，节点包含数据、颜色、父节点和子节点指针。文章提供了一个示例代码框架，用于创建节点、插入节点并执行必要的修复操作以维护红黑树的特性。
土木林森
101 1
糜终
|
1月前
|
存储 算法 搜索推荐
探索常见数据结构：数组、链表、栈、队列、树和图
探索常见数据结构：数组、链表、栈、队列、树和图
糜终
99 64
ephemerals__
|
13天前
|
存储 搜索推荐 算法
【数据结构】树型结构详解 + 堆的实现（c语言）（附源码）
本文介绍了树和二叉树的基本概念及结构，重点讲解了堆这一重要的数据结构。堆是一种特殊的完全二叉树，常用于实现优先队列和高效的排序算法（如堆排序）。文章详细描述了堆的性质、存储方式及其实现方法，包括插入、删除和取堆顶数据等操作的具体实现。通过这些内容，读者可以全面了解堆的原理和应用。
ephemerals__
56 16
java冯坚持
|
1月前
|
存储 算法 关系型数据库
数据结构与算法学习二一：多路查找树、二叉树与B树、2-3树、B+树、B*树。（本章为了解基本知识即可，不做代码学习）
这篇文章主要介绍了多路查找树的基本概念，包括二叉树的局限性、多叉树的优化、B树及其变体（如2-3树、B+树、B*树）的特点和应用，旨在帮助读者理解这些数据结构在文件系统和数据库系统中的重要性和效率。
java冯坚持
18 0
数据结构与算法学习二一：多路查找树、二叉树与B树、2-3树、B+树、B*树。（本章为了解基本知识即可，不做代码学习）
是店小二呀
|
1月前
|
存储 编译器 C++
【初阶数据结构】掌握二叉树遍历技巧与信息求解：深入解析四种遍历方法及树的结构与统计分析
【初阶数据结构】掌握二叉树遍历技巧与信息求解：深入解析四种遍历方法及树的结构与统计分析
是店小二呀
28 3
是店小二呀
|
1月前
【高阶数据结构】二叉树进阶探秘：AVL树的平衡机制与实现详解（三）
【高阶数据结构】二叉树进阶探秘：AVL树的平衡机制与实现详解
是店小二呀
27 1
是店小二呀
|
1月前
【高阶数据结构】二叉树进阶探秘：AVL树的平衡机制与实现详解（二）
【高阶数据结构】二叉树进阶探秘：AVL树的平衡机制与实现详解
是店小二呀
44 1
是店小二呀
|
1月前
|
存储
【高阶数据结构】二叉树进阶探秘：AVL树的平衡机制与实现详解（一）
【高阶数据结构】二叉树进阶探秘：AVL树的平衡机制与实现详解
是店小二呀
51 1
Dylaniou
|
1月前
|
Java C++
【数据结构】探索红黑树的奥秘：自平衡原理图解及与二叉查找树的比较
本文深入解析红黑树的自平衡原理，介绍其五大原则，并通过图解和代码示例展示其内部机制。同时，对比红黑树与二叉查找树的性能差异，帮助读者更好地理解这两种数据结构的特点和应用场景。
Dylaniou
28 0
周一同学Zelina
|
2月前
|
JSON 前端开发 JavaScript
一文了解树在前端中的应用，掌握数据结构中树的生命线
该文章详细介绍了树这一数据结构在前端开发中的应用，包括树的基本概念、遍历方法（如深度优先遍历、广度优先遍历）以及二叉树的先序、中序、后序遍历，并通过实例代码展示了如何在JavaScript中实现这些遍历算法。此外，文章还探讨了树结构在处理JSON数据时的应用场景。
周一同学Zelina
34 0
一文了解树在前端中的应用，掌握数据结构中树的生命线

热门文章

最新文章

  • 1
    我花了一夜用数据结构给女朋友写个H5走迷宫游戏
  • 2
    数据结构学习笔记【持续更新】
  • 3
    基于OHCI的USB主机 —— OHCI（自定义数据结构）
  • 4
    【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
  • 5
    学数据结构，只需要基本的编程体验
  • 6
    数据结构（2）：栈的原理和实现
  • 7
    【数据结构7】查找
  • 8
    算法导论第十四章 数据结构的扩张
  • 9
    R语言学习笔记（一）数据结构
  • 10
    Smaller And Smarter Python数据结构：自己动手实现栈
  • 1
    `geopandas`是一个开源项目，它为Python提供了地理空间数据处理的能力。它基于`pandas`库，并扩展了其对地理空间数据（如点、线、多边形等）的支持。`GeoDataFrame`是`geopandas`中的核心数据结构，它类似于`pandas`的`DataFrame`，但包含了一个额外的地理列（通常是`geometry`列），用于存储地理空间数据。
    69
  • 2
    “解锁Python高级数据结构新姿势：图的表示与遍历，让你的算法思维跃升新高度
    40
  • 3
    Redis数据结构—跳跃表 skiplist 实现源码分析
    62
  • 4
    逆袭之路！用 Python 玩转图的 DFS 与 BFS，让数据结构难题无处遁形
    65
  • 5
    Python中的列表（List）和元组（Tuple）是两种重要的数据结构
    53
  • 6
    【数据结构OJ题】链表分割
    32
  • 7
    【数据结构常见七大排序（三）上】—交换排序篇【冒泡排序】And【快速排序】
    45
  • 8
    【数据结构常见七大排序（二）】—选择排序篇【直接选择排序】And【堆排序】
    33
  • 9
    【数据结构常见七大排序（一）】—插入排序篇【直接插入排序】And【希尔排序】
    45
  • 10
    【数据结构OJ题】链表的回文结构
    39

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法

    • 相关电子书

    更多
  • 如何使用Tair增强数据结构构建丰富在线实时场景
  • Apache Flink 流式应用中状态的数据结构定义升级
  • 低代码开发师（初级）实战教程
    • 下一篇
    阿里云OSS设置跨域访问