4树的概念和表示方法

根结点：树的开始
叶子结点：树的末端
父结点：一个结点的上一个
孩子结点：一个结点的下一个
兄弟结点：属于同一个父结点

结点的度：拥有子树的个数
树的度：一棵树中最大的结点的度

树的深度/高度：层数（根节点根据情况定义）

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

typedef struct TreeNode{
    int data;
    int parent;
}Node;

Node* node[5];	//存放的数组
int size;		//当前元素个数
int maxSize;	//当前最大元素个数

void Init()
{
    size=0;
    maxSize=5;
}

void insert_root(int key)
{
    Node* new_node(Node*)malloc(sizeof(Node));//创建根节点
    new_node->data=key;//数据赋值
    new_node->parent=-1;//根节点特殊下标为-1
    node[size]=new_node;//将根节点地址存入数组
    size++;
}
    
void insert_child(int key,int parent_node)
{
    if(size==maxSize)//如果满了
    {
        //提示或者扩容
    }
    else
    {
        //先找到这个父节点的下标
        int parent_index=find_parent(parent_node);	//查找父节点
        if(parent_index==-1)	//没找到这个父节点
        {
            //跳出
}
        else
        {
            Node* new_node(Node*)malloc(sizeof(Node));//创建新节点
            new_node->data=key;//数据赋值
            new_node->parent=parent_index;//父节点下标赋值
            node[size]=new_node;//将新节点地址存入数组
            size++;
        }
    }
}

void find_parent(int parent_node)
{
    for(int i=0;i<size;i++)
    {				
        if(parent_node==node[i]->data)
        {
            return i;
        }
    }
    return -1;
}

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


typedef struct Linklist{
    int data;
    struct Linklist *next;
}ListNode;//链表结点

typedef struct Child{
    int data;
    struct Linklist *next;
}Node;//数组结点

Node *node_array[20];
int size;
int maxSize;


void Init(int key)
{
    size=0;
    maxSize=20;
    node_array[size]=(Node*)malloc(sizeof(Node));
    node_array[size]->data=key;
    node_array[size]->next=NULL;
}

int find_parent(int parent)
{
    for(int i=0;i<size;i++)
    {
        if(node_array[i]==parent)
        {
            return i;
        }
	}
    return -1;
}
//创造树
void Creat_Tree(int parent,int key)
{
    
    //找父节点
    int index= find_parent(parent);
    if(index==-1)
    {
        //没找到
    }
    else
    {
        //先将其放入数组，再链入链表
        if(size==maxSize)
        {
            //数组是否满
        }
        else
        {
            node_array[size]=(Node*)malloc(sizeof(Node));
            node_array[size]->data=key;
            node_array[size]->next=NULL;
            
            ListNode* new_node=(ListNode*)malloc(sizeof(ListNode));
            new_node->data=index;
            new_node->next=node_array[size]->next;
            node_array[size]->next=new_node;
            size++;
        }
    }
}

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

typedef struct ChildBro{
    int key;
    struct ChildBro *child;
    struct ChildBro *sibling;
}Node;

Node *root;		//根指针

void Init(int key)
{
    root=(Node*)malloc(sizeof(Node));
    root->key=key;
    root->child=NULL;
    root->silbing=NULL;
    
}

void insert(int key,int parent)
{
    //定位结点
    
    Node* temp;
    
    if(temp==NULL)
    {
        
    }
    else
    {
        Node*node=(Node*)malloc(sizeof(Node));
        node->key=key;
        node->child=NULL;
        node->sibling=NULL;
        if(temp->child==NULL)
        {
            temp->child=node;
        }
        else
        {
            node->sibling=temp->child;
            temp->child=node;
        }
    }
}