学习笔记（数据结构:树）6

树：n（n>=0）个结点的有限集合。n = 0 ,空树。

在任意一个非空树中，

1，有且仅有一个特定的根结点

2，当n>1 时，其余结点可分为m个互不相交的有限集合T1,T2,T3.。。。。Tm，其中每一个

集合又是一个树，并且称谓子树。

结点拥有子树的个数称谓结点的度。度为0的结点称谓叶结点。度不为0，称谓分支结点。

树的度数是指，这棵树中，最大的结点的度数，称谓树的度数。

树的深度或高度，从根开始，根为第一层，根的孩子为第二层。

树的存储，顺序结构，链式结构。

二叉树，binary tree

n个结点的有限集合，集合要么为空树，要么由一个根结点和两棵互不相交，分别称谓根结点的左子树和右子树的二叉树组成。。

特点，

1，每个结点最多两个子树。

2，左子树和右子树是有顺序的，次序不能颠倒。

3，如果某个结点只有一个子树，也要区分左，右子树。

特殊的二叉树

1，斜树，所有的结点都只有左子树，左斜树，所有结点都只有右子树，右树。

2，满二叉树，所有的分支结点都存在左右子树，并且叶子都在同一层上。

3，完全二叉树，对于一颗有n个结点的二叉树按层序编号，如果编号i（1<=i<=n）的结点于同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这可树为完全二叉树。

特性

1，在二叉树的第i层上最多有2^(i-1)个结点 i>=1

2,深度为k的二叉树至多有2^k  -1 个结点 k>=1

3,任意一个二叉树T，如果其叶子结点的个数是n0,度数为2的结点数为n2， n0 = n2 +1;

4,有n个结点的完全二叉树深度为(logn/log 2) +1;

层序，

前序，根左右，先访问根，然访问左，访问右。

中序，左根右，先从根开始（不是先访问根），从左开始访问，在访问根，在访问右结点。

后序，左右根，先从根开始（不是先访问根），先访问左，在访问右。在访问根。

tree.h

#ifndef TREE_H
#define TREE_H
typedef char DATATYPE;
typedef struct BiTNode
{
    DATATYPE data;
    struct BiTNode *lchild,*rchild;
}BiTNode;
void CreateTree(BiTNode **root);
void PreOrderTraverse(BiTNode *root);
void InOrderTraverse(BiTNode *root);
void PostOrderTraverse(BiTNode *root);
void DestroyTree(BiTNode *root);
#endif // TREE_H

tree.c

#include<stdio.h>
#include"tree.h"
#include<stdlib.h>
char data[] = "abdg##h##e##c#fi###";
int ind = 0;
void CreateTree(BiTNode **root)
{
    char c = data[ind++];
    if('#' == c)
    {
        *root = NULL;
    }
    else
    {
        *root = (BiTNode*)malloc(sizeof(BiTNode));
        if(NULL == *root)
        {
            perror("create error malloc");
            return ;
        }
        (*root)->data = c;
        CreateTree(&(*root)->lchild);
        CreateTree(&(*root)->rchild);
    }
    return;
}

void PreOrderTraverse(BiTNode *root)
{
    if(NULL == root)
    {
        return;
    }
    else
    {
        printf("%c",root->data);
        PreOrderTraverse(root->lchild);
        PreOrderTraverse(root->rchild);
    }
}

void InOrderTraverse(BiTNode *root)
{
    if(NULL == root)
    {
        return;
    }
    else
    {
        InOrderTraverse(root->lchild);
        printf("%c",root->data);
        InOrderTraverse(root->rchild);
    }
}

void PostOrderTraverse(BiTNode *root)
{
    if(NULL == root)
    {
        return;
    }
    else
    {
        PostOrderTraverse(root->lchild);
        PostOrderTraverse(root->rchild);
        printf("%c",root->data);
    }
}

void DestroyTree(BiTNode *root)
{
    if(NULL == root)
    {
        return;
    }
    DestroyTree(root->lchild);
    DestroyTree(root->rchild);
    free(root);
    return ;
}
Main.c
#include <stdio.h>
#include"tree.h"

int main()
{
    BiTNode *root = NULL;
    CreateTree(&root);
    PreOrderTraverse(root);
    printf("\n");
    InOrderTraverse(root);
    printf("\n");
    PostOrderTraverse(root);
    printf("\n");
    DestroyTree(root);
    printf("Hello World!\n");
    return 0;
}

hash.h

#ifndef HASH_H
#define HASH_H
typedef int DATATYPE;
typedef struct
{
    DATATYPE* head;
    int tlen;
}HS_TAB;
HS_TAB* CreateHsTable(int len);
int HsFun(HS_TAB *hs,DATATYPE *data);
int InsertHsTab(HS_TAB *hs,DATATYPE *data);
int SearchHs(HS_TAB *hs,DATATYPE *data);
#endif // HASH_H

hash.c

#include"hash.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
HS_TAB *CreateHsTable(int len)
{
    HS_TAB *hs = malloc(sizeof(HS_TAB));
    if(NULL == hs)
    {
        perror("create error.malloc1");
        return NULL;
    }
    hs->head = (DATATYPE*)malloc(sizeof(DATATYPE)*len);
    if(NULL == hs->head)
    {
        perror("create error.malloc2");
        return NULL;
    }
    int i = 0;
    for(i = 0;i < len;i++)
    {
        hs->head[i] = -1;
    }
    hs->tlen = len;
    return hs;
}

int HsFun(HS_TAB *hs, DATATYPE *data)
{
    return (*data)%hs->tlen;
}

int InsertHsTab(HS_TAB *hs, DATATYPE *data)
{
    int ind = HsFun(hs,data);
    while (hs->head[ind] != -1)
    {
        ind = (ind +1 )%hs->tlen;
    }
    memcpy(&hs->head[ind],data,sizeof(DATATYPE));
    return 0;
}

int SearchHs(HS_TAB *hs, DATATYPE *data)
{
    int ind = HsFun(hs,data);
    int old_ind = ind;
    while (hs->head[ind] != *data)
    {
        ind = (ind + 1)%hs->tlen;
        if(old_ind == ind)
        {
            return -1;
        }
    }
    return ind;
}