C语言数据结构——二叉树的顺序存储结构

最新推荐文章于 2024-08-16 09:16:07 发布
最新推荐文章于 2024-08-16 09:16:07 发布
阅读量1.7w 收藏 128
点赞数 29
分类专栏： 数据结构 c语言 二叉树顺序存储结构 文章标签： c语言 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunshine_rebrith/article/details/72854236
版权

1、二叉树的顺序存储结构就是用一维数组存储二叉树的结点，结点的存储位置就是数组下标要能体现结点间的逻辑关系。
2、顺序存储结构一般只适用于完全二叉树。

3、http://www.cnblogs.com/Alex-bg/archive/2012/08/12/2634203.html（代码原址）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h> 
#include <math.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

#define MAX_TREE_SIZE 100
#define MAX_QUEUE_SIZE 5
#define Nil ' ' 

typedef char TElemtype;    //将树的结点类型设置为字符型 
typedef int QElemType;    //将队列的结点类型设置为整形 


typedef struct{     
    QElemType *base;    //队列的基地址 
    int front;     
    int rear;     
}SqQueue;

typedef TElemtype SqBiTree[MAX_TREE_SIZE];    //定义顺序存储二叉树的结构数组 

typedef struct{
    int level;    //树的层号 
    int order;    //一层中的序号(从左向右) 
}position;

/**-------队列的函数声明------*/

int InitQueue(SqQueue *);    //初始化队列 
int DestroyQueue(SqQueue *);    //销毁队列 
int ClearQueue(SqQueue *);    //清空队列 
int QueueEmpty(SqQueue *);    //队列是否为空 
int GetQueueLength(SqQueue *);    //获取队列的长度 
int GetQueueHead(SqQueue *,QElemType *);    //获取队头元素 
int EnterQueue(SqQueue *,QElemType);    //向队列中插入元素 
int DeleteQueue(SqQueue *,QElemType *);    //向队列中删除元素 
int (*QueueVisit)(QElemType);    //函数变量 
int QueueTraverse(SqQueue *,int (*) (QElemType));    //遍历队列 


/*---------二叉树的函数声明*/ 

int InitBiTree(SqBiTree);    //初始化二叉树 
int CreateBiTree(SqBiTree);    //创建二叉树 
int BiTreeEmpty(SqBiTree);    //判断二叉树是否为空 
int BiTreeDepth(SqBiTree);    //计算二叉树的深度 
int GetRoot(SqBiTree,TElemtype *);    //获取二叉树的根结点 
TElemtype GetNodeValue(SqBiTree,position);    //获取二叉树结点元素 
int Assign(SqBiTree,position,TElemtype);    //给结点元素赋值 
TElemtype GetParent(SqBiTree,TElemtype);    //获取结点的双亲结点 
TElemtype GetLeftChild(SqBiTree,TElemtype);    //获取结点的左孩子 
TElemtype GetRightChild(SqBiTree,TElemtype);    //获取结点的右孩子 
TElemtype GetLeftSibling(SqBiTree,TElemtype);    //获取结点的左兄弟 
TElemtype GetRightSibling(SqBiTree,TElemtype);    //获取结点的右兄弟 
void Move(SqBiTree,int,SqBiTree,int);    //移动结点 
int InsertChild(SqBiTree,TElemtype,int,SqBiTree);    //插入子结点 
int DeleteChild(SqBiTree,position,int);    //删除子结点 
int (*TreeVisit)(TElemtype);    //函数变量 
int PreOrderTraverse(SqBiTree, int (*Visit)(TElemtype));    //先序遍历二叉树 
int InOrderTraverse(SqBiTree,int (*Visit)(TElemtype));    //中序遍历二叉树 
int PostOrderTraverse(SqBiTree,int (*Visit)(TElemtype));    //后序遍历二叉树 
void LevelOrderTraverse(SqBiTree,int (*Visit)(TElemtype));    //层序遍历二叉树 
void PrintTree(SqBiTree);    //打印二叉树 

/*-----------队列的函数定义-----------*/ 

 /*初始化队列*/ 
int InitQueue(SqQueue *Q)
{
    //分配内存区域 
    Q->base=(QElemType *)malloc(MAX_QUEUE_SIZE*sizeof(QElemType)); 
    if(!Q->base)
    {
        printf("存储分配失败.\n");
        return ERROR;
    }
    Q->front=Q->rear=0;    //将队列置空 
    return OK;
}

/*销毁队列*/ 
int DestroyQueue(SqQueue *Q)
{
    if(Q->base)
    {
        free(Q->base);
    }
    Q->front=Q->rear=0;
    return OK;
}

/*清空队列*/ 
int ClearQueue(SqQueue *Q)
{
    Q->front=Q->rear=0;
    return OK;
}

/*判断队列是否为空*/ 
int QueueEmpty(SqQueue *Q)
{
    if(Q->front==Q->rear)
    {
        return OK;
    }
    else
    {

        return ERROR;
    }
}

/*获取队列长度*/
int GetQueueLength(SqQueue *Q)
{
    return (Q->rear-Q->front);
}

/*获取队列头的元素*/ 
int GetQueueHead(SqQueue *Q,QElemType *e)
{
    if(!QueueEmpty(Q))
    {
        *e=*(Q->base+Q->front);    
        return OK;    
    }
    return ERROR;
}

/*使元素进队*/ 
int EnterQueue(SqQueue *Q,QElemType e)
{
    if(Q->rear == MAX_QUEUE_SIZE)    //队列满了,重新分配内存区域,用realloc 
    {
        printf("队列已满,尝试增加存储单元...\n"); 
        Q->base=(QElemType *)realloc(Q->base,MAX_QUEUE_SIZE+1);
        if(!Q->base)        
        {
            printf("增加队列存储单元失败.\n");
            return ERROR;
        }
    }
    *(Q->base+Q->rear)=e;
    Q->rear++;
    return OK;
}

/*删除队头元素*/ 
int DeleteQueue(SqQueue *Q,QElemType *e)
{
    if(QueueEmpty(Q))
    {
        //printf("队列为空.\n");
        return ERROR;
    }
    *e=*(Q->base+Q->front);
    Q->front++;
    return OK;
}

/*遍历队列*/ 
int QueueTraverse(SqQueue *Q,int (*QV)(QElemType) )
{
    int i=0;
    while(i<Q->rear)
    {
        (*QV)(*(Q->base+i));
        i++;
    }    
}

/*访问队列中元素的函数,将元素值打印出来*/ 
int QueueVisitFunc(QElemType e)
{
    printf("%d\n",e);
}

/*-------二叉树的函数定义-------*/

/*初始化树*/ 
int InitBiTree(SqBiTree T)
{
    int i;
    for(i=0;i<MAX_TREE_SIZE;i++)
    {
        T[i]=Nil;    //将初值设为空格 
    }

    T[MAX_TREE_SIZE]='\0';    //给数组尾部加上结标致 
    return OK;
} 

/*创建树*/ 
int CreateBiTree(SqBiTree T)
{
    int i=0;
    int l=0;
    char s[MAX_TREE_SIZE];
    printf("请按顺序输入结点的值,空格表示空结点,结点数<=%d\n",MAX_TREE_SIZE);
    gets(s);
    l=strlen(s);
    for(;i<l;i++)
    {
        T[i]=s[i];
        if(i!=0&&T[(i+1)/2-1]==Nil&&T[i]!=Nil)
        {
            printf("出现无双亲且不是根的结点.\n");
            return ERROR;
        }
    }
    for(;i<MAX_TREE_SIZE;i++)
    {
        T[i]=Nil; 
    }
    return OK;
}

#define ClearBiTree InitBiTree    //在顺序存储结构中,ClearBiTree和InitBiTree完全一样 

/*判断树是否为空*/ 
int BiTreeEmpty(SqBiTree T)
{
    if(T[0]==Nil)
    {
        printf("树为空.\n");
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

/*计算树的深度*/ 
int BiTreeDepth(SqBiTree T)
{
    int j=-1;
    int i=0;
    if(BiTreeEmpty(T))
    {
        return ERROR;    
    }
    for(i=MAX_TREE_SIZE-1;i>=0;i--)
    {
        if(T[i]!=Nil)
        {
            break;
        }
    }
    i++;
    //printf("i = %d\n",i);
    do
    {
        j++;
    }while(i>=pow(2,j));
    return j;
}

/*获取根结点的值*/ 
int GetRoot(SqBiTree T,TElemtype * e)
{
    if(BiTreeEmpty(T))
    {
        return ERROR;
    }
    *e=T[0];
    return OK;
}

/*根据位置获取某一结点的值*/ 
TElemtype GetNodeValue(SqBiTree T,position p)
{
    return T[(int)pow(2,p.level)-1-(int)pow(2,p.level-1)+p.order-1];
}

/*根据结点的位置给某一结点元素赋值*/ 
int Assign(SqBiTree T,position p,TElemtype e)
{
    int i = (int)pow(2,p.level)-1-(int)pow(2,p.level-1)+p.order-1;
    if(e!=Nil&&T[(i+1)/2-1]==Nil)
    {
        printf("将要赋值的结点双亲为空,不合法.\n");
        return ERROR;
    }
    if(e==Nil&&(T[2*i+1]!=Nil||T[2*i+2]!=Nil))
    {
        printf("将有子结点的结点赋空值,不合法.\n");
        return ERROR;
    }
    T[i]=e;
    //printf("T[%d] 已修改为: %c.\n",i,T[i]);
    return OK;
}

/*获取结点元素的双亲结点*/ 
TElemtype GetParent(SqBiTree T,TElemtype e)
{
    int i;
    if(BiTreeEmpty(T))
    {
        return Nil;
    }
    for(i=0;i<MAX_TREE_SIZE;i++)
    {
        if(T[i]==e)
        {
            return T[(i+1)/2-1];
        }
    }     
    printf("未找到双亲结点.\n");
    return Nil;
}

/*获取结点元素的左孩子*/ 
TElemtype GetLeftChild(SqBiTree T,TElemtype e)
{
    int i;
    if(BiTreeEmpty(T))
    {
        return Nil;
    }
    for(i=0;i<MAX_TREE_SIZE;i++)
    {
        if(T[i]==e)
        {
            return T[2*i+1];
        }
    }
    printf("未找到左孩子.\n");
    return Nil;
}

/*获取结点元素的右孩子*/ 
TElemtype GetRightChild(SqBiTree T,TElemtype e)
{
    int i;
    if(BiTreeEmpty(T))
    {
        return Nil;
    }
    for(i=0;i<MAX_TREE_SIZE;i++)
    {
        if(T[i]==e)
        {
            return T[2*i+2]; 
        }
    }
    printf("未找到右孩子.\n");
    return Nil;
} 

/*获取结点元素的左兄弟*/ 
TElemtype GetLeftSibling(SqBiTree T,TElemtype e)
{
    int i;
    if(BiTreeEmpty(T))
    {
        return Nil;
    }
    for(i=1;i<MAX_TREE_SIZE;i++)
    {
        if(T[i]==e&&i%2==0)
        {
            return T[i-1];
        }
    }
    printf("未找到左兄弟.\n");
    return Nil;
}

/*获取结点元素的右兄弟*/ 
TElemtype GetRightSibling(SqBiTree T,TElemtype e)
{
    int i;
    if(BiTreeEmpty(T))
    {
        return Nil;
    }
    for(i=1;i<MAX_TREE_SIZE;i++)
    {
        if(T[i]==e&&i%2!=0)
        {
            return T[i+1];
        }
    }
    printf("未找到右兄弟.\n");
    return Nil;
}

/*把从T1中j结点开始的子树移到T2中i结点开始的子树*/ 
void Move(SqBiTree T1,int i1,SqBiTree T2,int i2)
{
    if(T1[2*i1+1] != Nil)
    {/*左子树不空*/
        Move(T1,2*i1+1,T2,2*i2+1);
    }
    if(T1[2*i1+2] != Nil)
    {/*右子树不空*/
        Move(T1,2*i1+2,T2,2*i2+2);    
    }
    /*左右子树都为空,说明该结点为叶子结点,可以移动.*/
    T2[i2]=T1[i1];
    T1[i1]=Nil;
}

/*插入结点或子树*/ 
int InsertChild(SqBiTree T,TElemtype e,int LR,SqBiTree S)
{
    int j,k,i=0;
    if(BiTreeEmpty(T))
    {
        return ERROR;
    }
    for(j=0;j<(int)pow(2,BiTreeDepth(T))-1;j++)
    {
        if(T[j]==e)
        {
            break;
        }
    }
    k=2*j+LR;    //k为e结点的左或右孩子的序号
     if(T[k]!=Nil)
     {/*e结点的左右孩子不空,即e结点不是叶子结点*/
        Move(T,k,T,2*k+2);     
    }
    Move(S,i,T,k); 
} 

/*删除结点或子树*/ 
int DeleteChild(SqBiTree T,position p,int LR)
{
    int i;
    int k=OK;
    SqQueue Q;
    InitQueue(&Q);
    i=(int)pow(2,p.level)-1-(int)pow(2,p.level-1)+p.order-1;
    if(BiTreeEmpty(T))
    {
        return ERROR;
    }
    i=2*i+1+LR;
    while(k)
    {
        if(T[2*i+1]!=Nil)
        {
            EnterQueue(&Q,2*i+1);
        }
        if(T[2*i+2]!=Nil)
        {
            EnterQueue(&Q,2*i+2);
        }
        T[i]=Nil;
        k=DeleteQueue(&Q,&i);
    }
    return OK;
}

/*访问结点元素的函数*/ 
int TreeVisitFunc(TElemtype e)
{
    printf(" %c -",e);
}

/*先序遍历二叉树的递归函数*/ 
int PreTraverse(SqBiTree T,int i)
{
    TreeVisit(T[i]);
    if(T[2*i+1]!=Nil)
    {
        PreTraverse(T,2*i+1);
    }
    if(T[2*i+2]!=Nil)
    {
        PreTraverse(T,2*i+2);
    }
}

/*先序遍历二叉树*/ 
int PreOrderTraverse(SqBiTree T,int (*TV) (TElemtype e))
{
    TreeVisit=TV;
    if(BiTreeEmpty(T))
    {
        return ERROR;
    }
    PreTraverse(T,0);
}

/*中序遍历二叉树的递归函数*/ 
int InTraverse(SqBiTree T,int i)
{
    if(T[2*i+1]!=Nil)
    {
        InTraverse(T,2*i+1);
    }
    TreeVisit(T[i]);
    if(T[2*i+2]!=Nil)
    {
        InTraverse(T,2*i+2);
    }
}

/*中序遍历二叉树*/
int InOrderTraverse(SqBiTree T,int (*TV)(TElemtype))
{
    TreeVisit=TV;
    if(BiTreeEmpty(T))
    {
        return ERROR;
    }
    InTraverse(T,0);
}

/*后序遍历二叉树的递归函数*/
int PostTraverse(SqBiTree T,int i)
{
    if(T[2*i+1]!=Nil)
    {
        PostTraverse(T,2*i+1);
    }
    if(T[2*i+2]!=Nil)
    {
        PostTraverse(T,2*i+2);
    }
    TreeVisit(T[i]);
}

/*后序遍历二叉树*/
int PostOrderTraverse(SqBiTree T,int (*TV)(TElemtype))
{
    TreeVisit=TV;
    if(BiTreeEmpty(T))
    {
        return ERROR;
    }
    PostTraverse(T,0);
}

/*打印树*/ 
void PrintTree(SqBiTree T)
{
    int j,k;
    position p;
    TElemtype e;
    for(j=0;j<BiTreeDepth(T);j++)
    {
        p.level=j+1;
        printf("第%d层:\n",p.level);
        for(k=0;k<pow(2,p.level-1);k++)
        {
            p.order=k+1;
            e=T[(int)pow(2,p.level)-1-(int)pow(2,p.level-1)+p.order-1];
            printf(" %d : %c ",p.order,e);
        }
        printf("\n");
    }
    printf("\n");
}

/*程序入口函数,对二叉树及队列的操作的调用*/ 
int main()
{
    /*
    SqQueue queue;
    InitQueue(&queue);
    QueueEmpty(&queue);
    ClearQueue(&queue);
    QueueEmpty(&queue);
    int length;
    length = GetQueueLength(&queue);
    printf("队列长度为: %d\n",length);
    if(1==OK)
    {
        printf("-----------------------------\n\n");
    }
    EnterQueue(&queue,1);
    EnterQueue(&queue,2);
    EnterQueue(&queue,3);
    EnterQueue(&queue,4);
    EnterQueue(&queue,5);
    QueueEmpty(&queue);
    length=GetQueueLength(&queue);
    printf("The Length of the Queue is : %d.\n",length);
    QElemType headElem;
    if(GetQueueHead(&queue,&headElem))
    {
        printf("The Head of the Queue is : %d.\n",headElem);
    }
    QueueVisit=QueueVisitFunc;
    QueueTraverse(&queue,QueueVisit);
    printf("销毁队列.\n");
    DestroyQueue(&queue);
    */

    position p;
    SqBiTree T;
    SqBiTree S;
    int depth;
    int i;
    TElemtype elem;
    InitBiTree(T);
    BiTreeEmpty(T);
    CreateBiTree(T);
    puts(T);
    depth=BiTreeDepth(T);
    printf("The Depth of the tree is %d.\n",depth);


    GetRoot(T,&elem);
    printf("The Root of the tree is %c.\n",elem);/*

    printf("Please Enter the Level and Order of the Tree:\n");
    scanf("%d",&p.level);
    scanf("%d",&p.order);
    fflush(stdin);
    elem=GetNodeValue(T,p);
    printf("The Node of level %d order %d is : %c \n",p.level,p.order,elem);
    Assign(T,p,'C');*/
    printf("--------------------------------\n\n");
/*
    printf("输入一个结点的值,我们可以找到其双亲,孩子和兄弟.\n");
    scanf("%c",&elem);
    fflush(stdin);
    printf("%c 's parent is : %c.\n",elem,GetParent(T,elem));
    printf("%c 's left child is : %c.\n",elem,GetLeftChild(T,elem));
    printf("%c 's right child is : %c.\n",elem,GetRightChild(T,elem));
    printf("%c 's left sibling is : %c.\n",elem,GetLeftSibling(T,elem));
    printf("%c 's right sibling is : %c.\n",elem,GetRightSibling(T,elem));*/

    printf("----------------------------------\n\n");
    /*
    InitBiTree(S);
    CreateBiTree(S);
    printf("Please enter the node value where you want to insert a child.\n");
    scanf("%c",&elem);
    InsertChild(T,elem,1,S);
    puts(T);
    printf("Please enter the node position you want to delete.\n");
    scanf("%d%d",&p.level,&p.order);
    printf("p.level=%d,p.order=%d\n",p.level,p.order);
    DeleteChild(T,p,0);
    puts(T);
    */
    printf("--------------遍历二叉树--------------------\n\n");
    printf("先序遍历:\n");
    PreOrderTraverse(T,TreeVisitFunc);
    printf("\n中序遍历:\n");
    InOrderTraverse(T,TreeVisitFunc);
    printf("\n后序遍历:\n");
    PostOrderTraverse(T,TreeVisitFunc);
    printf("\n");
    printf("--------------打印二叉树--------------------\n\n");
    PrintTree(T); 
}
sunshine_BUCT_LLP
关注
专栏目录
【大话数据结构C语言】26 二叉树的顺序存储结构
CodeAllen嵌入式
12-12 1302
我的首发平台是公众号【CodeAllen】，学习交流QQ群：736386324 二叉树的顺序存储结构是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系 下面是完全二叉树的顺序存储 将这颗二叉树存入到数组中，下标对应其同样的位置 对于普通的二叉树，则可以把不存在的位置标示为^ 由上图可知，顺序存储结构一般只适用于完全二叉树（考虑对存储空间的浪费） ...
C语言数据结构——二叉树
qq_41481924的博客
07-18 732
链式存储 定义结构体 typedef struct tree { char data; struct tree *Lchild,*Rchild; }Tree; 创建二叉树（采用先序遍历创建，也可采用中序或后序遍历创建） 1.扫描字符序列，输入字符ch 2.如果ch是一个'#'字符，则表明该二叉树为空树，即T为NULL；否则执行以下操作： 申请一个节点空间 将ch赋...
数据结构——堆的结构及实现详解
程序之生
11-01 633
堆 如题，这里说的堆并不是计算机进程地址空间中的堆，而是数据结构中的堆 堆的作用： 选最大数或最小数，不断选数，时间复杂度是O（LogN） 注意： 在数据结构中，堆是一种完全二叉树，适合用数组存储。只有非完全二叉树不适合用线性表来存储，因为空白部分会浪费空间。 堆的实现 头文件 #pragma once #include<stdio.h> typedef int HpDateType; typedef struct Heap { HpDateType* _a; size_t _size;
数据结构——二叉树
最新发布
2301_80373479的博客
08-16 1820
轻松学会二叉树
c语言实现二叉树的存储结构,数据结构之---C语言实现二叉树的顺序存储
weixin_33941707的博客
05-18 1271
//二叉树的顺序存储//这里利用循环队列存储数据//杨鑫#include#include#include#include#define MAXQSIZE 5 // 最大队列长度(对于循环队列，最大队列长度要减1)#define MAX_TREE_SIZE 100 // 二叉树的最大结点数#define ClearBiTree InitBiTree // 在顺序存储结构中，两函数完全一样typede...
数据结构C语言版_二叉树的顺序存储表示和实现
07-23
二叉树的顺序存储表示和实现、自己写的、觉得应该有用吧、、
二叉树的顺序存储结构
Vring_Jan的博客
05-15 919
#include &lt;iostream&gt;using namespace std;#define Max 16void Create_Tree(int *Tree,int *node,int length){ int i; int level; Tree[1]=node[1]; for(i=2;i&lt;length;i++) { level=1; while(Tree[level]!...
C语言数据结构——二叉树的顺序存储和二叉树的遍历
我想让你也是一个开心果！
11-18 2604
在学习顺序存储结构之前要知道： 二叉树的结构是非线性的； 每一个结点可有两个后继。 对于这种一对多的层次结构，我们应该怎么样合理的存储下来呢？ 二叉树既有顺序存储又有链式存储，今天先学顺序存储。 方法: 使用一组连续的存储单元来存放二叉树的数据元素。 使用结点之间的相对位置表示结点之间的关系。 对于满二叉树和完全二叉树来说，可以按照对满二叉树结点连续编号，将各结点数据存放到一组连续的存储单元中，将二叉树中编号为i的结点存放在数组的第i号元素中。 编号规则： 根结点的编号为1；对于编号为i的结点， 左孩子如果
数据结构——二叉树顺序存储
xiaoyu1381的博客
08-12 4711
数据结构——二叉树顺序存储
数据结构——二叉树的基本操作（C语言，完整优美实现）
明宇逸风的博客
10-28 9566
串 文章目录串前言一、树是什么？二、该如何理解树？三、各类树的存在形式四、二叉树的遍历方式深度遍历先序遍历中序遍历后序遍历层次遍历五、二叉树的实现1.二叉树的实现1.1 引入库以及设置结构体1.2初始化二叉树1.3队列的基本操作实现1.4二叉树深度遍历的三种方法1.5层次遍历1.6求子叶个数以及结点个数1.7串的输出功能1.8主函数实现上述全部功能2.运行截图总结 前言 1.本文就介绍了数据结构中二叉树的五条性质以及二叉树的存储结构 2.二叉树的基本操作的编程实现，掌握二叉树的建立、先序，中序，后序遍
【数据结构】二叉树的顺序存储结构 —— 堆
StackFrame
11-21 1532
二叉树顺序存储介绍、C语言实现堆
二叉树的顺序存储
11-17
C语言实现二叉树的顺序存储
数据结构c语言版二叉树的顺序存储表示,数据结构C语言版 二叉树的顺序存储表示和实现...
weixin_42414213的博客
05-18 340
急救知识_眼部烧伤急救要趁早数据结构C语言版 二叉树的顺序存储表示和实现.txt丶︶￣喜欢的歌，静静的听，喜欢的人，远远的看我笑了当初你不挺傲的吗现在您这是又玩哪出呢？/*数据结构C语言版 二叉树的顺序存储表示和实现P126编译环境：Dev-C++ 4.9.9.2日期：2011年2月13日*/#include typedef char TElemType;// 二叉树的顺序存储表示#define ...
【数据结构】二叉树顺序结构实现_BiTreeArray
博客
11-14 5639
#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 /* 存储空间初始分配量 */
二叉树的顺序存储结构------(C语言实现)
makabaka12138的博客
04-05 2470
上图所示的二叉树用顺序存储方式存为 A B C D E 0 F ... 相当于一个一维数组啦 下面是代码实现： //定义二叉树的最大结点数 #define MAX_SIZE 255 //下标为0的位置存储根结点 typedef Element SqBinTree[MAX_SIZE]; SqBinTree tree; ...
二叉树（C语言实现）——顺序存储结构
Mr_John
11-08 7277
/* 二叉树顺序存储结构一般仅适合于存储完全二叉树 */ #include<stdio.h> #include<stdlib.h> #include<math.h> #include<stdbool.h> #define MaxSize 100 typedef char DataType; typedef struct { DataType data[MaxSize]; // 存储树结点的数组 int BiTreeNum; // 二叉树的..
c语言 二叉树存储结构,C语言 二叉树顺序存储结构的先序遍历算法
weixin_39805255的博客
05-17 215
#include#include#include#define__MAX_LENGTH__20typedefstructSqStack{//调用栈intdata[__MAX_LENGTH__];inttop;}SqStack;typedefstructSqBiTree{//顺序存储二叉树elemTypedata[__MAX_LENGTH__];intlen;}SqBiTr...
树的顺序存储C语言,C语言 二叉树顺序存储结构的先序遍历算法
weixin_39939993的博客
05-17 366
C语言 二叉树顺序存储结构的先序遍历算法发布时间：2020-08-06 08:03:29来源：51CTO阅读：938作者：Mr_haha#include#include#include#define__MAX_LENGTH__20typedefstructSqStack{//调用栈intdata[__MAX_LENGTH__];inttop;}SqStack;typedefst...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值