二叉树的顺序存贮结构

最新推荐文章于 2022-04-05 17:17:07 发布
最新推荐文章于 2022-04-05 17:17:07 发布
阅读量614 收藏
点赞数 1
分类专栏： 数据结构 树 文章标签： tree c 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llcomeon1_/article/details/7845044
版权

总结：树的结构中主要要把握递归的思想。

头文件

#ifndef STREEHEAD_H_INCLUDED

#define STREEHEAD_H_INCLUDED


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


#define MAX_TREE_SIZE 100
typedef int SqBiTree[MAX_TREE_SIZE] ;
int InitBiTree( SqBiTree T ) ;
int DestroyBiTree( SqBiTree T ) ;
int CreateBiTree( SqBiTree T ) ;
int ClearBiTree( SqBiTree T ) ;
int EmptyBiTree( SqBiTree T ) ;
int BiTreeDepth( SqBiTree T ) ;
int Root( SqBiTree T ) ;
int Value( SqBiTree T , int e ) ;
int Assign( SqBiTree T , int e , int value ) ;
int Parent( SqBiTree T , int e ) ;
int LeftChild( SqBiTree T , int e ) ;
int RightChild( SqBiTree T , int e ) ;
int LeftSibling( SqBiTree T , int e ) ;
int RightSibling( SqBiTree T , int e ) ;
int InsertChild( SqBiTree T , int e , int lor , SqBiTree C ) ;
int Move( SqBiTree S , int i , SqBiTree T , int j ) ;
int DeleteChild( SqBiTree T , int e ) ;
int PrintBiTree( SqBiTree T ) ;
int PreOrderTraverse( SqBiTree T , int e ) ;
int InTraverse( SqBiTree T , int e ) ;
int InOrderTraverse( SqBiTree T , int e ) ;
int PostOrderTraverse( SqBiTree T , int e ) ;

#endif // STREEHEAD_H_INCLUDED

函数实现

#include "Streehead.h"


int InitBiTree( SqBiTree T )
{
    int i ;
    for( i = 0 ; i < MAX_TREE_SIZE ; i++ )
    {
        T[i] = 0 ;
    }
    return 0 ;
}


int DestroyBiTree( SqBiTree T )
{
    return 0 ;
}


int CreateBiTree( SqBiTree T )
{
    printf( "请输入节点的值，输入0表示空结点，输999结束。\n" ) ;
    int i = 0 ;
    while( 1 )
    {
        scanf( "%d" , &T[i] ) ;
        if( T[i] == 999 )
        {
            break ;
        }
        if( i != 0 && T[(i + 1)/2 - 1] == 0 && T[i] != 0 )
        {
            printf( "ERROR!\n" ) ;
            exit( 1 ) ;
        }
        i++ ;
    }
    while( i < MAX_TREE_SIZE )
    {
        T[i++] = 0 ;
    }
    return 0 ;
}


int ClearBiTree( SqBiTree T )
{
    int i ;
    for( i = 0 ; i < MAX_TREE_SIZE ; i++ )
    {
        T[i] = 0 ;
    }
    return 0 ;
}
int EmptyBiTree( SqBiTree T )
{
    if( T[0] == 0 )
    {
        return 1 ;
    }
    return 0 ;
}


int BiTreeDepth( SqBiTree T )
{
    int i = MAX_TREE_SIZE ;
    while( T[ i - 1 ] == 0 )
    {
        i-- ;
        if( i == 0 )
        {
            break ;
        }


    }
    if( i == 0 )
    {
        return 0 ;
    }
    return ( log( i ) / log( 2 ) + 1 );
}


int Root( SqBiTree T )
{
    if( T[0] == 0 )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    return T[0] ;
}


int Value( SqBiTree T , int e )
{
    if( e <= 0 || e > MAX_TREE_SIZE )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    if( T[0] == 0 )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    if( T[ e - 1] == 0 )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    return T[ e - 1 ] ;
}


int Assign( SqBiTree T , int e , int value )
{
    if( e <= 0 || e > MAX_TREE_SIZE )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    if( value == 0 )
    {
        if( e == 1 )
        {
            printf( "ERROR!\n" ) ;
            exit( 1 ) ;
        }
        else if( e != 1 && 2 * e  < MAX_TREE_SIZE && ( T[ 2 * e - 1 ] != 0 || T[ 2 * e ] != 0 ) )
        {
            printf( "ERROR!\n" ) ;
            exit( 1 ) ;
        }
        T[ e - 1 ] = value ;
    }
    else
    {
        if( e != 1 && T[ e / 2 - 1 ] == 0 )
        {
            printf( "ERROR!\n" ) ;
            exit( 1 ) ;
        }
        T[ e - 1 ] = value ;
    }
    return 0 ;
}


int Parent( SqBiTree T , int e )
{
    if( e <= 0 || e > MAX_TREE_SIZE )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    if( e == 1 )
    {
        printf( "The root does not have parent!\n" ) ;
        exit( 1 ) ;
    }
    else if( e != 1 && T[ e - 1 ] != 0 )
    {
        return T[ e / 2 - 1 ] ;
    }
    return -1 ;
}


int LeftChild( SqBiTree T , int e )
{
    if( e <= 0 || e > MAX_TREE_SIZE )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    if( 2 * e <= MAX_TREE_SIZE && T[ 2 * e - 1] != 0 )
    {
        return T[ 2 * e - 1] ;
    }
    return -1 ;
}


int RightChild( SqBiTree T , int e )
{
    if( 2 * e < MAX_TREE_SIZE && T[ 2 * e ] != 0 )
    {
        return T[ 2 * e ] ;
    }
    return -1 ;
}


int LeftSibling( SqBiTree T , int e )
{
    if( e <= 0 || e > MAX_TREE_SIZE )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    if( e == 1 )
    {
        printf( "The root does not have leftsibling!\n" ) ;
        exit( 1 ) ;
    }
    if( e / 2 == ( e + 1 ) / 2  || ( ( e / 2 != ( e + 1 ) / 2 ) && T[ e - 1 ] == 0 ) )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    return T[ e - 2 ] ;
}


int RightSibling( SqBiTree T , int e )
{
    if( e <= 0 || e > MAX_TREE_SIZE )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    if( e == 1 )
    {
        printf( "The root does not have leftsibling!\n" ) ;
        exit( 1 ) ;
    }
    if( ( e / 2 != ( e + 1 ) / 2 ) || ( ( e / 2 == ( e + 1 ) / 2 ) && ( T[ e ] == 0 ) ) )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    return T[ e ] ;
}


int Move( SqBiTree S , int i , SqBiTree T , int j )
{
    if( S[ 2 * i + 1 ] != 0 )
    {
        Move( S , 2 * i + 1 , T , 2 * j + 1 ) ;
    }
    if( S[ 2 * i + 2 ] != 0 )
    {
        Move( S , 2 * i + 1 , T , 2 * j + 2 ) ;
    }
    T[j] = S[i] ;
    S[i] = 0 ;
    return 0 ;
}


int InsertChild( SqBiTree T , int e , int lor , SqBiTree C )
{
    int k ;
    if( e <= 0 || e > MAX_TREE_SIZE )
    {
        printf( "ERROR1!\n" ) ;
        exit( 1 ) ;
    }
    if( lor != 0 && lor != 1 )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    k = 2 * e - 1 + lor ;
    if( T[ k ] != 0 )
    {
        Move( T , k , T , 2 * k + 2 ) ;
    }
    Move( C , 0 , T , k ) ;
    return 0 ;
}


int DeleteChild( SqBiTree T , int e )
{
    int i = MAX_TREE_SIZE - 1 ;
    if( e <= 0 || e > MAX_TREE_SIZE )
    {
        printf( "ERROR!\n" ) ;
        exit( 1 ) ;
    }
    while( T[i] == 0 )
    {
        i-- ;
    }
    int j ;
    int k ;
    for( j = 0 ; pow( 2, j ) * e <= i ; j++ )
    {
        for( k = 0 ;  k < pow( 2 , j ) ; k++ )
        {
            T[ ( ( int ) pow(2 , j ) ) * e - 1 + k ] = 0 ;
        }
    }
    return 0 ;
}


int PreOrderTraverse( SqBiTree T , int e )
{
    if( T[ e - 1 ] != 0 )
    {
        printf( "%d " , T[ e - 1 ] ) ;
    }
    if( T[ 2 * e - 1 ] != 0 )
    {
        PreOrderTraverse( T , 2 * e ) ;
    }
    if( T[ 2 * e ] != 0 )
    {
        PreOrderTraverse( T , 2 * e + 1 ) ;
    }
    return 0 ;
}


int InOrderTraverse( SqBiTree T , int e )
{
    if( T[ 2 * e - 1 ] != 0 )
    {
        InOrderTraverse( T , 2 * e ) ;
    }
    if( T[ e - 1 ] != 0 )
    {
        printf( "%d " , T[ e - 1 ] ) ;
    }
    if( T[ 2 * e ] != 0 )
    {
        InOrderTraverse( T , 2 * e + 1 ) ;
    }
    return 0 ;
}


int PostOrderTraverse( SqBiTree T , int e )
{
    if( T[ 2 * e - 1 ] != 0 )
    {
        PostOrderTraverse( T , 2 * e ) ;
    }
    if( T[ 2 * e ] != 0 )
    {
        PostOrderTraverse( T , 2 * e + 1 ) ;
    }
    if( T[ e - 1 ] != 0 )
    {
        printf( "%d " , T[ e - 1 ] ) ;
    }
    return 0 ;
}


int PrintBiTree( SqBiTree T )
{
    int i ;
    for( i = 0 ; i < MAX_TREE_SIZE ; i++ )
    {
        if( T[i] != 0 )
        {
            printf( "%d " , T[i] ) ;
        }
    }
    printf( "\n" ) ;
    return 0 ;
}

主函数测试

#include "Streehead.h"


int main()
{
    SqBiTree T ;
    SqBiTree C = { 20 } ;
    InitBiTree( T ) ;
    CreateBiTree( T ) ;
    PrintBiTree( T ) ;
    /*int dea = BiTreeDepth( T ) ;
    printf( "the death of the tree is %d\n" , dea ) ;
    printf( "the root of the tree is %d\n" , Root( T ) ) ;
    Assign( T , 9 , 20 ) ;
    printf( "the value of e is %d\n" , Value( T , 9 ) ) ;
    printf( "the parent of e is %d\n" , Parent( T , 10 ) ) ;
    printf( "the leftchild of e is %d\n" , LeftChild( T , 5 ) ) ;
    printf( "the rightchild of e is %d\n" , RightChild( T , 5 ) ) ;
    printf( "the leftsibling of e is %d\n" , LeftSibling( T , 11 ) ) ;
    printf( "the rightsibling of e is %d\n" , RightSibling( T , 10 ) ) ;*/
    InsertChild( T , 2 , 0 , C ) ;
    PrintBiTree( T ) ;
    DeleteChild( T , 3 ) ;
    PrintBiTree( T ) ;
    printf( "前序\n") ;
    PreOrderTraverse( T , 1 ) ;
    printf( "\n中序\n" ) ;
    InOrderTraverse( T , 1 ) ;
    printf( "\n后序\n" ) ;
    PostOrderTraverse( T , 1 ) ;
    printf( "\n" ) ;
    return 0;
}

llcomeon1_
关注
专栏目录
二叉树的顺序存储代码
m0_62498487的博客
06-13 801
/擦汗ar datas[] = {'A' , 'B' , '#' , 'C' , '#' , '#' , '#' , '#' , 'D' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#' , '#'};printf("树的叶子结点个数为：%d\n",getCountLeaves(T , 1));
二叉树顺序存储结构
最新发布
qq_63981383的博客
09-13 1516
二叉树顺序存储结构
数据结构(C语言版)——二叉树的顺序存储结构(代码版)
热门推荐
qq_42683219的博客
09-30 1万+
一、代码 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #define OK 1 #define ERROR 0 #define MAXSIZE 30 typedef int Status; typedef struct biTree{ char data[MAXSIZE]; }BITREE,*BITREEPOINTER; int printMe
完全二叉树的顺序储存结构（C++完整代码）
qq_52284035的博客
06-18 8408
完全二叉树的定义：有一颗深度为h、具有n个节点的二叉树，若将它与一颗同深度的满二叉树中的所有节点按从上到下，从左到右的顺序分别进行编号，且该二叉树中的每个节点分别于满二叉树中的编号为1~n ...
二叉树的顺序存储方式
ahao214——Dreamspace
08-15 163
1、父节点和左孩子节点的编号下标有什么关系？ —— 0——>1 1——>3 3——>7 4——>9 —— i——>2i+1 2、父节点和右孩子节点的编号下标有什么关系？ —— 0——>2 1——>4 2——>6 3——>8 4——>10 —— i——>2i+2 ...
二叉树的顺序存储——深入了解数据结构代码篇（一）
aruewds的博客
04-14 444
目录关键代码 关键 顺序存储使用数组，同时顺序存储需要知道节点数n，使用length存储n 对于某个节点，2n左子节点，2n+1右子节点，n/2父节点。 对于第二点结论，如果对应数组下表从0开始，那么都需要加1。也就是，2n+1左子节点，2n+2右子节点，(n+1)/2父节点。 代码 #include <iostream> using namespace std; #define MAXSIZE 100 typedef int ElemType; typedef struct TreeNo
头歌数据结构二叉树的顺序存储及基本操作
05-18
总的来说，顺序存储的二叉树是一种简化了内存管理的数据结构，适用于静态二叉树或已知结构的二叉树，它可以简化存储和遍历操作，但灵活性较低。在实际应用中，我们还需要考虑其他存储方式，如链式存储，以适应更复杂...
二叉树的顺序存储结构
qq_41784749的博客
02-03 6157
完全二叉树的顺序存储结构的性质： 若i = 1, 则 i 是根结点，无父结点； 若i > 1, 则 i 的父结点为 i/2 ,向下取整 若 2i <= n, 则 i 有左儿子且为 2i；否则，i 无左儿子。 若 2i+1 <= n, 则 i 有右儿子且为2i+1；否则，i 无右儿子 若 i 为偶数, 且 i < n , 则有右兄弟，且为 i + 1。 若 i 为奇数, 且 i < n && i != 1, 则其左兄弟，且为 i-1 完全二叉树的顺序存储结构
二叉树顺序存储结构的基本操作
11-08
http://blog.csdn.net/ssw_1990/article/details/40511665代码。
Python实现顺序存储二叉树 顺序存储二叉树的遍历
storyfull
12-28 1509
Python实现顺序存储二叉树 顺序存储二叉树的遍历
二叉树的顺序存储结构------(C语言实现)
makabaka12138的博客
04-05 2512
上图所示的二叉树用顺序存储方式存为 A B C D E 0 F ... 相当于一个一维数组啦 下面是代码实现： //定义二叉树的最大结点数 #define MAX_SIZE 255 //下标为0的位置存储根结点 typedef Element SqBinTree[MAX_SIZE]; SqBinTree tree; ...
二叉树的顺序存储（相关基础操作代码实现）
a1369760658的博客
03-15 3909
#include <stdio.h> #include <math.h> //其中floor()函数为向下（左）取整，ceil()函数为向上（右）取整 #define MaxSize 10 typedef int ElemType; //定义树结点 typedef struct{ ElemType data; bool isEmpty; }Tree...
二叉树（C语言实现）——顺序存储结构
Mr_John
11-08 7462
/* 二叉树顺序存储结构一般仅适合于存储完全二叉树 */ #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; // 二叉树的..
（数据结构）二叉树的顺序存储结构
weixin_51927215的博客
03-29 8716
二叉树的存储结构有两种，分别为顺序存储和链式存储
顺序存储二叉树（java代码实现）
m0_46400910的博客
01-03 661
顺序存储二叉树（java代码实现） 思路 1. 先了解顺序存储二叉树的特点 - 顺序二叉树的实现用完全二叉树的特性 - 第n个元素的左子结点为2n+1 - 第n个元素的右子结点为2n+2 - 第n个元素的父结点为（n+1）/2 - n代表二叉树的第几个元素，从0开始（和数组一样） 2. (index * 2 + 1) < arr.length 表示为左部分 3. (index * 2 + 2) < arr.length表示为右部分 代码
二叉树顺序存储结构详解与实现
1. **顺序存储结构**：这种存储方式将完全二叉树的节点按照从上至下、从左至右的顺序存储在一维数组中。完全二叉树的特点是除了最后一层，其他所有层的节点都尽可能地填满，且最后一层的节点都靠左排列。通过公式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值