数据结构-树

1.树

1.1定义

1.2基本概念

2.二叉树

1.树

1.1定义

树(Tree)是n(n>=0)个节点的有限集合 T，它满足两个条件：

有且仅有一个特定的称为根（Root）的节点；

其余的节点可以分为m（m≥0）个互不相交的有限集合T1、T2、……、Tm，

其中每一个集合又是一棵树，并称为其根的子树（Subtree）。

特征：一对多，每个节点最多有一个前驱，但可以有多个后继（根节点无前驱，叶节点无后继）

关于树的节点：和链表类似，树存储结构中也将存储的各个元素称为 "结点"。

1.2基本概念

(1) 度数：一个节点的子树的个数(一个节点的子树的个数称为该节点的度数,3)

(2) 树度数：树中节点的最大度数

(3) 叶节点或终端节点: 度数为零的节点

(4) 分支节点：度数不为零的节点(B一层)

(5) 内部节点：除根节点以外的分支节点（B，C，D）

(6) 节点层次: 根节点的层次为1，根节点子树的根为第2层，以此类推

(7) 树的深度或高度: 树中所有节点层次的最大值

2.二叉树

2.1概念

二叉树（Binary Tree）是n（n≥0）个节点的有限集合，它或者是空集（n＝0），

或者是由一个根节点以及两棵互不相交的、分别称为左子树和右子树的二叉树组成。

二叉树与普通有序树不同，二叉树严格区分左孩子和右孩子，即使只有一个子节点也要区分左右。//二叉树：节点最大的度数2

满二叉树: 深度为k（k>=1）时节点数为2^k - 1(2的k次幂-1)

完全二叉树: 只有最下面两层有度数小于2的节点，且最下面一层的叶节点集中在最左边的若干位置上。(先挂树的左边向右, 从上向下挂)

2.2性质

1. 二叉树第k层（k>=1），节点最多是2的k-1次方个

2. 深度为k（k>=1）的二叉树最多有2的k次方-1个

3. 任意一棵二叉树，树叶的数目比度数为2的节点数目多1

总节点数=各类节点数之和 n=n0+n1+n2

总节点数=所有子节点数+1 n=n1+2*n2+1

n0+n1+n2=n1+2*n2+1

n0==n2+1

2.3顺序存储

顺序存储结构：完全二叉树节点的编号方法是从上到下，从左到右，根节点为1号节点。

设完全二叉树的节点数为n

某节点编号为i

当 i >1（不是根节点）时，有父节点，其编号为 i/2;

当 2*i <= n 时，有左孩子，其编号为 2*i ,否则没有左孩子，本身是叶节点;

当 2*i+1 <= n 时，有右孩子，其编号为 2*i+1 ,否则没有右孩子；

(2)节点编号

根节点编号 1

根节点左子节点编号： 2 即 2 * 1

根节点右子节点编号： 3 即 2 * 1 + 1

第n个节点

左子节点编号： 2 * n

右子节点编号： 2 * n + 1

有n个节点的完全二叉树可以用有n+1 个元素的数组进行顺序存储，节点号和数组下标一一对应，下标为零的元素不用。

2.4二叉树的遍历

前序：根左右

中序：左根右

后序：左右根

前序：ABCDEFGHK

中序：BDCAEHGKF

后序：DCBHKGFEA

练习

已知遍历结果如下，试画出对应的二叉树

前序： A B C E H F I J D G K

中序： A H E C I F J B D K G

2.5链式存储

用链表实现，基于完全二叉树规律来构建树，按照完全二叉树的编号方法，从上到下，从左到右。

第i个节点：

左子节点编号： 2*i （2*i<=n代表有左子）

右子节点编号: 2*i+1 (2*i+1<=n代表有右子)

可以根据左右节点编号来判断是否对二叉树构建完成

#ifndef _BITREE_H_
#define _BITREE_H_

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

typedef char datatype_tree;
typedef struct tree_node_t
{
    datatype_tree data;         // 数据域
    struct tree_node_t *lchild; // 左子left
    struct tree_node_t *rchild; // 右子right
} bitree_node_t, *bitree_list_t;

// 1.创建一棵树
bitree_list_t CreateBitree(int n, int i);

// 2.遍历前序
void PreOrder(bitree_list_t t);

// 中序
void InOrder(bitree_list_t t);

// 后序
void PostOrder(bitree_list_t t);

// 层次遍历
void unOrder(bitree_list_t *t);

// 释放
void dele(bitree_list_t t);
#endif

#include "tree.h"

// 1.创建一棵树
bitree_list_t CreateBitree(int n, int i)
{
    // 创建一个根节点
    bitree_node_t *t = (bitree_node_t *)malloc(sizeof(bitree_node_t));
    if (t == NULL)
    {
        printf(" t mallloc error \n");
        return NULL;
    }

    t->data = i;

    // 判断左孩子是否存在
    if (2 * i <= n)
    {
        // 左孩子如果存在，就创建左孩子节点
        t->lchild = CreateBitree(n, 2 * i);
    }
    else
    {
        t->lchild = NULL;
    }
    // 判断右孩子
    if (2 * i + 1 <= n)
    {
        // 右孩子如果存在，就创建右孩子节点
        t->rchild = CreateBitree(n, 2 * i + 1);
    }
    else
    {
        t->rchild = NULL;
    }

    return t;
}

// 2.遍历前序
void PreOrder(bitree_list_t t)
{
    if (t == NULL)
    {
        return;
    }

    // 根
    printf("%d ", t->data);
    // 左孩子
    if (t->lchild != NULL)
        PreOrder(t->lchild);
    // 右孩子
    if (t->rchild != NULL)
        PreOrder(t->rchild);
}

// 中序
void InOrder(bitree_list_t t)
{
    // 左孩子
    if (t->lchild != NULL)
        InOrder(t->lchild);

    // 根
    printf("%d ", t->data);

    // 右孩子
    if (t->rchild != NULL)
        InOrder(t->rchild);
}

// 后序
void PostOrder(bitree_list_t t)
{
    // 左孩子
    if (t->lchild != NULL)
        PostOrder(t->lchild);

    // 右孩子
    if (t->rchild != NULL)
        PostOrder(t->rchild);

    // 根
    printf("%d ", t->data);
}

// 层次遍历
void unOrder(bitree_list_t *t)
{
}

// 释放树
void dele(bitree_list_t t)
{

    if (t == NULL)
    {
        return;
    }

    if (t->lchild != NULL)
        dele(t->lchild);

    if (t->rchild != NULL)
        dele(t->rchild);

    free(t);
    t = NULL;

    return;
}