二叉树

最新推荐文章于 2022-07-09 13:48:50 发布

Alsnoa

最新推荐文章于 2022-07-09 13:48:50 发布

阅读量142

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/Alsnoa/article/details/80327266

版权

数据结构专栏收录该内容

13 篇文章 0 订阅

订阅专栏

引用文件stack_seq.h

#pragma once
#include<stdlib.h>
#include"binary_tree.h"
typedef TreeNode* TypeStack;

typedef struct SeqStack
{
    TypeStack* data;
    size_t size;
    size_t capacity;
    
}SeqStack;

void InitSeqStack(SeqStack* seqstack);

void DestoryStack(SeqStack* seqstack);

void SeqStackPush(SeqStack* seqstack, TypeStack value);

void SeqStackPop(SeqStack* seqstack);

int SeqStackTop(SeqStack* seqstack,TypeStack* value);

stack_seq.c

#include<stdio.h>
#include<stdlib.h>
#include"stack_seq.h"
#define TEST_HEADER printf("===============%s=================\n",__FUNCTION__);
                 
void InitSeqStack(SeqStack* seqstack)
{
    seqstack->size=0;
    seqstack->capacity=1000;
    seqstack->data=(TypeStack*)malloc(seqstack->capacity*sizeof(TypeStack));
}

void DestoryStack(SeqStack* seqstack)
{
    seqstack->size=0;
    free(seqstack->data);
    
}

void increase_capacity(SeqStack* seqstack)
{
       seqstack->capacity = seqstack->capacity*2+1;
       TypeStack* newptr=(TypeStack*)malloc(seqstack->capacity*sizeof(TypeStack));
       size_t i;   
       for(i=0;i<seqstack->size;i++)
       {
           newptr[i]=seqstack->data[i];
       }
       free(seqstack->data);
       seqstack->data=newptr;

}
void SeqStackPush(SeqStack* seqstack, TypeStack value)
{
       if(seqstack==NULL)
       {
           return;
       }
       if(seqstack->size >= seqstack->capacity)
       {
          
           increase_capacity(seqstack);

       }

       seqstack->data[seqstack->size]=value;
       
       ++seqstack->size;

       
}

void SeqStackPop(SeqStack* seqstack)
{
    if(seqstack==NULL)
    {
        return;
    }

    if(seqstack->size==0)
    {
        printf("No Data to be Pop.\n");
        return;
    }
     
     --seqstack->size;
}

int SeqStackTop(SeqStack* seqstack,TypeStack* value)
{
    if(seqstack==NULL)
    {
        return 0;
    }
    if(seqstack->size==0)
    {
        return 0;
    }
   *value=seqstack->data[seqstack->size-1];
   return 1;

}
void ShowStruct(SeqStack* seqstack)
{
    printf("Stack->top:%c \n",seqstack->data[seqstack->size-1]);
    printf("Stack->size:%lu \n",seqstack->size);
    printf("Stack->capacity:%lu \n",seqstack->capacity);
}
#if 0
void TestInit()
{
   TEST_HEADER;
   SeqStack seq;
   InitSeqStack(&seq);
   ShowStruct(&seq);

}

void TestDestory()
{
    TEST_HEADER;
    SeqStack seq;
    InitSeqStack(&seq);
    DestoryStack(&seq);
    ShowStruct(&seq);
}
void TestPush()
{
  TEST_HEADER;
  SeqStack seq;
  InitSeqStack(&seq);
  SeqStackPush(&seq,'a');
  SeqStackPush(&seq,'b');
  SeqStackPush(&seq,'c');
  SeqStackPush(&seq,'d');
  size_t i=0;
 for(i=0;i<1000;i++)
 {
  SeqStackPush(&seq,'d');

 }
  ShowStruct(&seq);
}

void TestPop()
{

  TEST_HEADER;
  SeqStack seq;
  InitSeqStack(&seq);
  SeqStackPush(&seq,'a');
  SeqStackPush(&seq,'b');
  SeqStackPush(&seq,'c');
  SeqStackPush(&seq,'d');
  size_t i=0;
 for(i=0;i<1000;i++)
 {
  SeqStackPush(&seq,'d');

 }
 
 for(i=0;i<1004;i++)
 {

  SeqStackPop(&seq);
 }
  ShowStruct(&seq);
}

void TestTop()
{

  TEST_HEADER;
  SeqStack seq;
  InitSeqStack(&seq);
  SeqStackPush(&seq,'a');
  SeqStackPush(&seq,'b');
  SeqStackPush(&seq,'c');
  SeqStackPush(&seq,'d');
  TypeStack value;
  int i=0;
  i = SeqStackTop(&seq,&value);
  printf("i:%d \n",i);
  printf("value:%c \n",value); 
}

int main()
{
    TestInit();
    TestDestory();
    TestPush();
    TestPop();
    TestTop();
    return 0;
}
#endif

queue_seq.h

#pragma once
#include"binary_tree.h"
#define MaxSize 1024
typedef TreeNode* TypeQueue;

typedef struct SeqQueue
{
    TypeQueue data[MaxSize];
    size_t head;
    size_t tail;
    size_t size;

}SeqQueue;
void SeqQueueInit(SeqQueue* seq);

void SeqQueueDestory(SeqQueue* seq);

void SeqQueuePush(SeqQueue* seq,TypeQueue value);

void SeqQueuePop(SeqQueue* seq);

int SeqQueueTop(SeqQueue* seq,TypeQueue* value);

queue_seq.c

#include<stdio.h>
#include<stdlib.h>
#include"queue_seq.h"
#define TEST_HEADER printf("\n=================%s==================\n",__FUNCTION__)

void SeqQueueInit(SeqQueue* seq)
{
    if(seq==NULL)
    {
        return;
    }
    seq->size=0;
    seq->head=0;
    seq->tail=0;

}

void SeqQueueDestory(SeqQueue* seq)
{
    if(seq==NULL)
   {
       return;
   }

    seq->size=0;
    seq->head=0;
    seq->tail=0;

}

//void Increase_MaxSize(SeqQueue* seq,TypeQueue value)
//{
//     
//}

void SeqQueuePush(SeqQueue* seq,TypeQueue value)
{
    if(seq==NULL)
    {
        return;
    }

    if( (seq->tail + 1) % MaxSize==seq->head)
    {
        printf("The SeqQueue is full!");
        return;
        
    } 

    if( seq->size==0 )
    {
        seq->data[seq->head]=value;
        ++seq->size; 
        return;
    }

      if(seq->tail==MaxSize-1)
      {
          seq->tail=0;
  
      }
      else
      {
  
          ++seq->tail;
      }
      
  
      seq->data[seq->tail]=value;
      ++seq->size;
  

}

void SeqQueuePop(SeqQueue* seq)
{
    if(seq==NULL)
    {
        return;
    }
    if(seq->size==0)
    {
        return;
    }
    if(seq->size==1)
    {
       --seq->size;
       return;
    }

    if(seq->head==MaxSize-1)
    {
        seq->head=0;

    }else{

      ++seq->head;
      

    }
    --seq->size;

}


int SeqQueueTop(SeqQueue* seq,TypeQueue* value)
{
    if(seq==NULL)
    {
        return 0;
    }
    if(seq->size==0)
    {
        return 0;
    }
    
    *value=seq->data[seq->head];
    return 1;
}

void StructShow(SeqQueue* seq)
{
    printf("Seq->top:%c \n",seq->data[seq->head]);
    printf("Seq->head:%d \n",seq->head);
    printf("Seq->tail:%d \n",seq->tail);
    printf("Seq->size:%d \n",seq->size);
    printf("\n");
}
#if 0
void Test()
{
  TEST_HEADER;
  size_t i;
  SeqQueue seq;
  TypeQueue value;
  SeqQueueInit(&seq);
  StructShow(&seq);
  SeqQueuePush(&seq,'a');
  SeqQueuePush(&seq,'b');
  SeqQueuePush(&seq,'c');
  SeqQueuePush(&seq,'d');
  StructShow(&seq);
  SeqQueuePop(&seq);
  SeqQueuePop(&seq);
  SeqQueuePop(&seq);
  StructShow(&seq);

  SeqQueuePush(&seq,'c');
  SeqQueuePush(&seq,'d');
  i=SeqQueueTop(&seq,&value);
  printf("ret:%d \n",i);
  printf("value:%c \n",value);

  SeqQueueDestory(&seq);
  StructShow(&seq);

}
int main()
{
    Test();
    return 0;
}
#endif

binary_tree.h

#pragma once 


typedef char TreeNodeType; 

typedef struct TreeNode { 
TreeNodeType data; 
struct TreeNode* lchild; 
struct TreeNode* rchild; 
} TreeNode; 

void TreeInit(TreeNode** root); 

void PreOrder(TreeNode* root); 

void InOrder(TreeNode* root); 

void PostOrder(TreeNode* root); 

void LevelOrder(TreeNode* root); 

/** 
 * * @brief 根据先序遍历结果(带有空节点标记), 
 * * 构造一棵树 
 * * 
 * * @param array[] 先序遍历的结果 
 * * @param size 数组中元素个数 
 * * @param null_node 数组中空节点的特殊标记. 
 * * 
 * * @return 
 * */ 
TreeNode* TreeCreate(TreeNodeType array[], size_t size, TreeNodeType null_node); 

void TreeDestroy(TreeNode** root); 

TreeNode* TreeClone(TreeNode* root); 

size_t TreeSize(TreeNode* root); 
/** 
 * * @brief 求一棵树的叶子节点个数 
 * * 
 * * @param root 
 * * 
 * * @return 
 * */ 
size_t TreeLeafSize(TreeNode* root); 

/** 
 * * @brief 求一棵树第 K 层节点的个数 
 * * 
 * * @param root 
 * * 
 * * @return 
 * */ 
size_t TreeKLevelSize(TreeNode* root, int K); 

size_t TreeHeight(TreeNode* root); 

TreeNode* TreeFind(TreeNode*node,TreeNodeType to_find); 

TreeNode* LChild(TreeNode* node); 

TreeNode* RChild(TreeNode* node); 

TreeNode* Parent(TreeNode* root, TreeNode* node); 

void PreOrderByLoop(TreeNode* root); 

void InOrderByLoop(TreeNode* root); 

void PostOrderByLoop(TreeNode* root); 

void TreeMirror(TreeNode* root); 

int IsCompleteTree(TreeNode* root);

binary_tree.c

#include<stdio.h>
#include<stdlib.h>
#include"binary_tree.h"
#include"queue_seq.h"
#include"stack_seq.h"
#define TEST_HEADER printf("===============%s===============\n",__FUNCTION__)
#define NULL_NODE  printf("#")
//typedef char TreeNodeType; 
//
//typedef struct TreeNode{ 
//
//   TreeNodeType data; 
//
//   struct TreeNode* lchild; 
//
//   struct TreeNode* rchild; 
//
//}TreeNode; 

TreeNode* CreatTreeNode(TreeNodeType value)
{
    TreeNode* tmp=(TreeNode*)malloc(sizeof(TreeNode));
    tmp->data=value;
    tmp->lchild=NULL;
    tmp->rchild=NULL;
    return tmp;
}

TreeNode* CreatTree_for_test()
{
   TreeNode* a=CreatTreeNode('a');
   TreeNode* b=CreatTreeNode('b');
   TreeNode* c=CreatTreeNode('c');
   TreeNode* d=CreatTreeNode('d');
   TreeNode* e=CreatTreeNode('e');
   TreeNode* f=CreatTreeNode('f');
   TreeNode* g=CreatTreeNode('g');
    
   a->lchild=b;
   a->rchild=c;
   b->lchild=d;
   b->rchild=e;
   c->lchild=f;
   c->rchild=NULL;
   d->lchild=NULL;
   d->rchild=g;
   e->lchild=NULL;
   e->rchild=NULL;
   f->lchild=NULL;
   f->rchild=NULL;
   g->lchild=NULL;
   g->rchild=NULL;

   return a;

}

void TreeInit(TreeNode** root)
{
    if(root==NULL)
    {
        NULL_NODE;
        return;
    }
    *root=NULL;
}

void PreOrder(TreeNode* root)
{
     if(root==NULL)
     {
         NULL_NODE;
         return;
     }
     printf("%c",root->data);
     PreOrder(root->lchild);
     PreOrder(root->rchild); 
}

void InOrder(TreeNode* root)
{
    if(root==NULL)
    {
        NULL_NODE;
        return;
    }

    InOrder(root->lchild);
    printf("%c",root->data);
    InOrder(root->rchild);
}

void PostOrder(TreeNode* root)
{
    if(root==NULL)
    {
        NULL_NODE;
        return;
    }
    PostOrder(root->lchild);
    PostOrder(root->rchild);
    printf("%c",root->data);
}

void LevelOrder(TreeNode* root)
{
     if(root==NULL)
    { 
       NULL_NODE;
       return;
    }
     SeqQueue tmp;
     TreeNode* value;
     SeqQueueInit(&tmp);
     SeqQueuePush(&tmp,root); 
     while(tmp.size!=0)
     {
   
         SeqQueueTop(&tmp,&value);  
         printf("%c",value->data);
         SeqQueuePop(&tmp);
         SeqQueuePush(&tmp,value->lchild);
         SeqQueuePush(&tmp,value->rchild);
     }


}

/** 
 * * @brief 根据先序遍历结果(带有空节点标记), 
 * * 构造一棵树 
 * * 
 * * @param array[] 先序遍历的结果 
 * * @param size 数组中元素个数 
 * * @param null_node 数组中空节点的特殊标记. 
 * * 
 * * @return 
 * */ 
  //TreeNodeType array[15]="abd#g##e##cf###";
  TreeNode* _treecreat(TreeNodeType array[], size_t size,size_t* index, TreeNodeType null_node)
{
    
    if(array[*index]==null_node)
    {
        (*index)++;
        return NULL;
    }
    TreeNode *root=CreatTreeNode(array[(*index)++]);
    root->lchild=_treecreat(array,size,index,null_node);
    root->rchild=_treecreat(array,size,index,null_node);
    return root;

}
TreeNode* TreeCreate(TreeNodeType array[], size_t size, TreeNodeType null_node)
{

    size_t index=0;
    return _treecreat(array,size,&index,null_node);
}

void TreeDestroy(TreeNode** root)
{
   if(root==NULL)
   {
       return;
   }
   if(*root==NULL)
   {
       return;
   }

   TreeDestroy(&(*root)->lchild);
   TreeDestroy(&(*root)->rchild);
   free(*root);
   *root=NULL;
}

TreeNode* TreeClone(TreeNode* root)
{
      if(root==NULL)
      {
          return NULL;
      }
   TreeNode* clone=CreatTreeNode(root->data);
    clone->lchild=TreeClone(root->lchild);
    clone->rchild=TreeClone(root->rchild);

  return clone;
}
  size_t _treesize(TreeNode* root) 
{

     if(root==NULL)
    { 
       return 0;
    }

     size_t count=0;
     SeqQueue tmp;
     TreeNode* value;
     
     SeqQueueInit(&tmp);
    
     SeqQueuePush(&tmp,root); 
     while(tmp.size!=0)
     {
   
         SeqQueueTop(&tmp,&value);  
        
         if(value==NULL)
         {
             SeqQueuePop(&tmp);
             continue;
         }
         SeqQueuePop(&tmp);
         count++; 
         SeqQueuePush(&tmp,value->lchild);
         SeqQueuePush(&tmp,value->rchild);
     }
    return count;
}

size_t TreeSize(TreeNode* root)
{
  //   return _treesize(root);
        if(root==NULL)
        {
            return 0;
        }
    return 1+TreeSize(root->lchild)+TreeSize(root->lchild);

 }

/** 
 * * @brief 求一棵树的叶子节点个数 
 * * 
 * * @param root 
 * * 
 * * @return 
 * */ 
size_t TreeLeafSize(TreeNode* root)
{
    if(root==NULL)
    {
        return 0;
    }
    if(root->rchild==NULL && root->lchild==NULL)
    {
        return 1;
    }
    return TreeLeafSize(root->lchild)+TreeLeafSize(root->rchild);
  // if(root==NULL)
  // {
  //     return 0;
  // }
  //   size_t count=0;
  //   SeqQueue tmp;
  //   TreeNode* value;
  //   
  //   SeqQueueInit(&tmp);
  //  
  //   SeqQueuePush(&tmp,root); 
  //   while(tmp.size!=0)
  //   {
  // 
  //       SeqQueueTop(&tmp,&value);  
  //      
  //       if(value==NULL)
  //       {
  //           SeqQueuePop(&tmp);
  //           continue;
  //       }

  //       if(value->lchild==NULL && value->rchild==NULL)
  //       {
  //          count++; 
  //       }

  //       SeqQueuePop(&tmp);
  //       SeqQueuePush(&tmp,value->lchild);
  //       SeqQueuePush(&tmp,value->rchild);
  //   }
  //  return count;


}

/** 
 * * @brief 求一棵树第 K 层节点的个数 
 * * 
 * * @param root 
 * * 
 * * @return 
 * */ 
size_t TreeKLevelSize(TreeNode* root, int K)
{
   if(root==NULL || K<1)
   {
       return 0;
   }
   if(K==1)
   {
       return 1;
   }
   return TreeKLevelSize(root->lchild,K-1)+TreeKLevelSize(root->rchild,K-1);

}

size_t TreeHeight(TreeNode* root)  
{
  if(root==NULL)
  {
      return 0;
  }

  size_t  lchildheight=TreeHeight(root->lchild);
  size_t  rchildheight=TreeHeight(root->rchild);

  return 1+(lchildheight>rchildheight ? lchildheight:rchildheight); 

}

TreeNode* TreeFind(TreeNode*node,TreeNodeType to_find)
{
     if(node==NULL)
     {
         return NULL;
     }
     if(node->data==to_find)
     {
         return node;
     }

        TreeNode * lresult= TreeFind(node->lchild,to_find);


        TreeNode * rresult= TreeFind(node->rchild,to_find);


    return  lresult!=NULL ? lresult:rresult;
}

TreeNode* LChild(TreeNode* node)
{
    if(node==NULL)
    {
        return NULL;
    }
    return node->lchild;
}

TreeNode* RChild(TreeNode* node)
{
    if(node==NULL)
    {
        return NULL;
    }
    return node->rchild;
}

TreeNode* Parent(TreeNode* root, TreeNode* node)
{
    if(root==NULL)
    {
        return NULL;
    }
    if(root->lchild==node ||root->rchild==node)
    {
        return root;
    }

    TreeNode* lresult=Parent(root->lchild,node);
    TreeNode* rresult=Parent(root->rchild,node);
    
   return lresult!=NULL? lresult:rresult;
}

void PreOrderByLoop(TreeNode* root)
{
  if(root==NULL)
  {
      return;
  }
  SeqStack stack;
  TreeNode* value;
  InitSeqStack(&stack);
  SeqStackPush(&stack,root);
  while(SeqStackTop(&stack,&value))
  {
        SeqStackPop(&stack);
        printf("%c",value->data);
        if(value->rchild!=NULL)
        {
        SeqStackPush(&stack,value->rchild);
        }
        if(value->lchild!=NULL)
        {
        SeqStackPush(&stack,value->lchild);
        }
  }
  
}

void InOrderByLoop(TreeNode* root)
{
  if(root==NULL)
  {
    return;
  }
  
  SeqStack stack;
  TreeNode* cur=root;
  TreeNode* value;
  InitSeqStack(&stack);
  while(1)
  {

    while(cur!=NULL)
    {
      SeqStackPush(&stack,cur);
      cur=cur->lchild;
    }

    size_t i=SeqStackTop(&stack,&value);
   
    if(i==0)
    {
      return;
    }
   
    SeqStackPop(&stack); 

    printf("%c",value->data);
    
    if(value->rchild!=NULL)
    {
      cur=value->rchild;  
    }
   
  }

}

void PostOrderByLoop(TreeNode* root)
{
  if(root==NULL)
  {
      return;
  }
  TreeNode* value;
  TreeNode* pre=NULL;
  TreeNode* cur=root;
  SeqStack stack;
  InitSeqStack(&stack);
    
  while(1)
  {
      while(cur!=NULL)
      {
          SeqStackPush(&stack,cur);
          pre=cur;
          cur=cur->lchild;
      }
       
      size_t i=SeqStackTop(&stack,&value);
       
      if(i==0)
      {
          return;
      }
        if(value->rchild==NULL||value->rchild==pre)
       {
         printf("%c",value->data);
         SeqStackPop(&stack);
         pre=value; 
       }
       else
       {
          cur=value->rchild;
       }
     
              
  }

}
void SwapTree(TreeNode* root){

TreeNode *tmp=root->lchild;
root->lchild=root->rchild;
root->rchild=tmp;
}
void TreeMirror(TreeNode* root)
{
  if(root==NULL)
  {
      return;
  }
   SwapTree(root);
   if(root->lchild!=NULL)
   {
   TreeMirror(root->lchild);

   }
   if(root->rchild!=NULL)
   {
   TreeMirror(root->rchild);
   }
}

int IsCompleteTree(TreeNode* root)
{
   if(root==NULL)
   {
       return 0;
   }
   int state_flag=0;
   SeqQueue queue;
   TreeNode* value;
   SeqQueueInit(&queue);
   SeqQueuePush(&queue,root);

   while(queue.size!=0)
   {
      SeqQueueTop(&queue,&value);
      if(value->lchild==NULL && value->rchild!=NULL)
      {
         return 0;
      }
      else if(value->lchild!=NULL && value->rchild==NULL)
      {
          SeqQueuePush(&queue,value->lchild);
          state_flag=1;
      }
      if(state_flag==1)
      {
        while(1)
        {
          SeqQueuePop(&queue);
          if(SeqQueueTop(&queue,&value)==0)
          {
               return 1;
          }
          if(value->lchild!=NULL || value->rchild!=NULL)
          {
              return 0;
          }
        }
      }
      if(value->lchild!=NULL)
      {

      SeqQueuePush(&queue,value->lchild);
      }
      if(value->rchild!=NULL)
      {

      SeqQueuePush(&queue,value->rchild);
      }
      SeqQueuePop(&queue);
   }
   return 1;
}

TreeNode* Completetree()
{
   TreeNode* a=CreatTreeNode('a');
   TreeNode* b=CreatTreeNode('b');
   TreeNode* c=CreatTreeNode('c');
   TreeNode* d=CreatTreeNode('d');
   TreeNode* e=CreatTreeNode('e');
   TreeNode* f=CreatTreeNode('f');

   TreeNode* g=CreatTreeNode('g');
   TreeNode* h=CreatTreeNode('h');
   a->lchild=b;
   a->rchild=c;
   b->lchild=d;
   b->rchild=e;
   c->lchild=f;
   c->rchild=g;
   d->lchild=h;
   return a;
}
//1. give a result  pre min order  to creat a tree/
void TestInit()
{
  TEST_HEADER;
  TreeNode* root=CreatTree_for_test();
  PreOrder(root);
  printf("\n");
  InOrder(root);
  printf("\n");
  PostOrder(root);
  printf("\n");
  TreeNodeType  array[]="abd#g##e##cf###";
  printf("%d \n",(int)sizeof(array));
  root=TreeCreate(array,sizeof(array),'#');
  
  PreOrder(root);
  printf("\n");
  TreeDestroy(&root);
  PreOrder(root);
  printf("\n");

  root=TreeClone(CreatTree_for_test());
  PreOrder(root);
  printf("\n");

  printf("The size of root is %lu.\n",TreeSize(root));
  printf("The leafsie of root is %lu.\n",TreeLeafSize(root));
  printf("The 3 level size of root is %lu .\n",TreeKLevelSize(root,3));
  printf("The height of tree is %lu .\n",TreeHeight(root));

  TreeNode *find=TreeFind(root,'e');
   printf("The find result is %c .\n",find->data);
   TreeNode *parent=Parent(root,root->lchild->rchild);
   printf("The parent expect is root->lchild :%p   acutally:%p .\n",root->lchild,parent);
  PreOrderByLoop(root);
  printf("\n");
   InOrderByLoop(root);
   printf("\n");
   PostOrderByLoop(root);
   printf("\n");

   TreeMirror(root);
   PreOrder(root);
   printf("\n");
  printf("%d \n",IsCompleteTree(root));

  root=Completetree();
  printf("%d \n",IsCompleteTree(root));
}
int main()
{
    TestInit();
    return 0;
}

Alsnoa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二叉树

引用文件stack_seq.h #pragma once#include&lt;stdlib.h&gt;#include"binary_tree.h"typedef TreeNode* TypeStack;typedef struct SeqStack{ TypeStack* data; size_t size; size_t capacity; ...
复制链接

扫一扫