二叉树基本操作

最新推荐文章于 2017-10-28 19:12:23 发布
最新推荐文章于 2017-10-28 19:12:23 发布
阅读量475 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aa838260772/article/details/24620837
版权 
#include<stdio.h>
#include"tree.h"
#include<stdlib.h>
#include"stack.h"
#include"queue.h"
#include<math.h>
Bitree CreateTree(Bitree p)//先序递归法建立二叉树
{
    char c;
    printf("input:");
    scanf("%c",&c);
    if(c=='#') p=NULL;
    else{
        p=(Bitree)malloc(sizeof(Binode));
        p->alp=c;
        getchar();
        p->lchild=CreateTree(p->lchild);
        getchar();
        p->rchild=CreateTree(p->rchild);
    }
    return p;
}
void Visit(Bitree p)
{
    printf("%c",p->alp);
}
void Preorder(Bitree p)//遍历的递归法
{
    if(p!=NULL){
        Visit(p);
        Preorder(p->lchild);
        Preorder(p->rchild);
                }
}
void Inorder(Bitree p)
{
    if(p!=NULL){
        Inorder(p->lchild);
        Visit(p);
        Inorder(p->rchild);
                }
}
void Postorder(Bitree p)
{

    if(p!=NULL){
        Postorder(p->lchild);
        Postorder(p->rchild);
        Visit(p);
                }
}
void InorderTravel(Bitree p)//遍历非递归算法:中序
{
    linkstack s;
    initstack(&s);
    Bitree t=p;
    while(!empstack(s)||t)
        {
      while(t){push(&s,t);t=t->lchild;}
           t=pop(&s);
           Visit(t);
           t=t->rchild;
          }
}
void PreorderTravel(Bitree p)//先序
{
     linkstack s;
    initstack(&s);
    Bitree t=p;
    while(!empstack(s)||t)
    {
        while(t){push(&s,t);Visit(gettopstack(s));t=t->lchild;}
         t=pop(&s);t=t->rchild;
    }
}
void PostorderTravel(Bitree p)//后序
{
    linkstack s;
    initstack(&s);
    Bitree t=p,l;
    l=NULL;
    while(!empstack(s)||t)
    {
        while(t) {push(&s,t);t=t->lchild;}
        t=gettopstack(s);
        t=t->rchild;
        if(!t||t==l){l=pop(&s);Visit(l);t=NULL;}
    }
}
void LevelTravel(const Bitree p)//层次遍历上下左右
{
    linkqueue q;
    initqueue(&q);
    Bitree t;
    if(!p) printf("empty tree");
    else
       { t=p;
        enqueue(&q,p);
         while(!empqueue(q)){
        t=dequeue(&q);Visit(t);
        if(t->lchild) enqueue(&q,t->lchild);
        if(t->rchild) enqueue(&q,t->rchild);
                      }
   }
}
void InvertLevel(Bitree p)//下上右左，在上面加个栈
{
   linkqueue q;
    initqueue(&q);
    linkstack s;
    initstack(&s);
    Bitree t;
    if(!p) printf("empty tree");
    else
   {  t=p;
       enqueue(&q,p);
       while(!empqueue(q)){
        t=dequeue(&q);push(&s,t);
        if(t->lchild) enqueue(&q,t->lchild);
        if(t->rchild) enqueue(&q,t->rchild);
                      }
   }
  while(!empstack(s)){t=pop(&s);Visit(t);}
}

void  BitreeDepWid(Bitree p)//求二叉树的深度和宽度的非递归算法
{
    linkqueue q;
    initqueue(&q);
    Bitree t,l;
    l=t=p;
    int n,dep,wid;
    n=dep=wid=0;
    if(p)
    {
       enqueue(&q,t);
    while(!empqueue(q)){
        t=dequeue(&q);n++;
        if(t->lchild) enqueue(&q,t->lchild);
        if(t->rchild) enqueue(&q,t->rchild);
        if(t==l) {
                 dep++;
                 //l=getbasequeue(q);
                 //l=q.rear->bt;此句当q.rear为空的时候会出问题,->指向何处??
                 if(q.rear) l=q.rear->bt;
                 if(n>wid) wid=n;
                 n=0;
                    }
            }
   }
   printf("dep=%d wid=%d\n",dep,wid);
}
int  Depth(Bitree p)//二叉树深度的递归算法
{
  if(!p) return 0;
 return (Depth(p->lchild)>Depth(p->rchild)?Depth(p->lchild):Depth(p->rchild))+1;

}
int  IsComplete(Bitree p)//判断是否完全二叉树
{
    linkqueue q;//声明对象时不用malloc声明指针时要malloc
    initqueue(&q);
    Bitree t=p;
    if(!p) return 1;
    else {
        enqueue(&q,t);
        while(!empqueue(q))
        {
            t=dequeue(&q);
            if(t){enqueue(&q,t->lchild);enqueue(&q,t->rchild);}
            else {
                while(!empqueue(q)){
                        t=dequeue(&q);
                       if(t) return 0;
                                    }
                   }
        }
       return 1;
    }
}
void Swapp(Bitree p)//交换左右子树
 {
     Bitree t=p;
     if(t) {
        t=p->lchild;
        p->lchild=p->rchild;
        p->rchild=t;
        Swapp(p->lchild);
        Swapp(p->rchild);
     }
 }
int  BiCount(Bitree p)//计算一颗树度为二的节点数的和:1.递归2.递归遍历
 {//先序的
     if(!p) return 0;
     else if(p->lchild&&p->rchild)
        return BiCount(p->lchild)+BiCount(p->rchild)+1;
     else
     return BiCount(p->lchild)+BiCount(p->rchild);
 }
void DeleteTree(Bitree p)//递归删除以p为根节点的树
{
    if(p){
    DeleteTree(p->lchild);
    DeleteTree(p->rchild);
    free(p);}
}

void BiDelx(Bitree p)//删除子树
{   char x;
    if(!p) printf("no element in the tree\n");
    else {
            getchar();
            printf("input x:");
            scanf("%c",&x);
        if(x==p->alp) DeleteTree(p);
       else {Bitree t=p;
        linkqueue q;
        initqueue(&q);
        enqueue(&q,t);
      while(!empqueue(q))
        {    t=dequeue(&q);
            if(t->lchild)
            {
               if(t->lchild->alp==x) {DeleteTree(t->lchild);t->lchild=NULL;}
                          else enqueue(&q,t->lchild);
            }
            if(t->rchild)
              {
            if(t->rchild->alp==x)  {DeleteTree(t->rchild);t->rchild=NULL;}
                         else enqueue(&q,t->rchild);
               }
      }
    }
  }
}

void SearchParent(Bitree p)//查找所有父节点
{
      getchar();
     char x;
   printf("input x:");
   scanf("%c",&x);
   linkstack s;
   initstack(&s);
   Bitree t,l;
   t=p;l=NULL;
   while(t||!empstack(s))
    {
        while(t&&t->alp!=x) {push(&s,t);t=t->lchild;}
      if(t)  if(t->alp==x) break;//如果不加if(t),t为空时t->alp会导致内存问题
    if(!t) {
        t=gettopstack(s);
        t=t->rchild;
       if(t&&t!=l){if(t->alp==x) break;}
       else {l=pop(&s);t=NULL;}
    }

  }
if(!empstack(s)) while(!empstack(s)){t=pop(&s);Visit(t);}
 else printf("not found");
}

Bitree BST_Insert(Bitree p,char x)//二叉排序树的插入均是在叶子节点上进行的
{
    Bitree t,l,k;
    t=(Bitree)malloc(sizeof(Binode));
    t->alp=x;
    t->lchild=t->rchild=NULL;
  if(!p) return t;
  else {  l=p;
        while(l)
      {    k=l;
        if(x<k->alp) l=k->lchild;
        else if(x>k->alp)  l=k->rchild;
        else {free(t);break;}
    }
      if(k->alp<x) k->rchild=t;
      if(k->alp>x)  k->lchild=t;
      return p;
       }
}
Bitree Create_BST()
{
    Bitree p;
    p=NULL;
   getchar();
   char ch;
   printf("input :");
 while((ch=getchar())!='#')
 {
     getchar();
    p=BST_Insert(p,ch);
     printf("input :");
 }
 return p;
}
/*
int Is_BST(Bitree p)//判断是否二叉排序树:1.非递归中序遍历2.层次遍历
{
   linkstack s;
   initstack(&s);
   Bitree t=p,l;
   l=NULL;
   while(t||!empstack(s))
   {
         while(t) {push(&s,t);t=t->lchild;}
         t=pop(&s);
         if(l&&t->alp<l->alp) return 0;
         l=t;
         t=t->rchild;
   }
 return 1;
}
*/
int Is_BST(Bitree p)//二叉排序树判定_层次遍历.利用队列
{
    linkqueue q;
    initqueue(&q);
    Bitree t;
    t=p;enqueue(&q,t);
    while(!empqueue(q))
    {
        t=dequeue(&q);
        if(t->lchild) {
           if(t->lchild->alp>t->alp) return 0;
          else  enqueue(&q,t->lchild);
                     }
        if(t->rchild) {
            if(t->rchild->alp<t->alp) return 0;
            else enqueue(&q,t->rchild);
                      }
    }
    return 1;
}

int Is_Balence(Bitree p)// 是否平衡二叉树
{
    if(p==NULL) return 1;
    int ldep=Depth(p->lchild);
    int rdep=Depth(p->rchild);
    if(abs(ldep-rdep)>1) return 0;
    else
return Is_Balence(p->lchild)&&Is_Balence(p->rchild);
}

aa838260772
关注
专栏目录
二叉树的基本操作
小葱的博客
05-07 1187
1。二叉树的特点：二叉树的特点： 1.每个节点最多有两棵子树，即二叉树中不存在度大于2的节点（分支数最大不超过2） 2.二叉树的子树有左右之分，也就是说二叉树是有序的。 2。二叉树的基本操作（递归）：以下面的二叉树为例：1.求二叉树的节点个数： 思路： (1)root 为空（整个二叉树的根节点为空） return 0; (2)root不为空 —>左子树的节点个数 + 右子树的节点
实验四 二叉树基本操作的实现
12-18
在本实验中，我们将深入探讨数据结构中的一个重要概念——二叉树，并实现其基本操作。二叉树是一种非线性的数据结构，它由一个有限集合的节点构成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验...
二叉树基本操作的程序实现.zip_二叉树的基本操作
09-21
这篇文档“二叉树基本操作的程序实现”涵盖了二叉树的一些核心概念和基本操作，旨在帮助初学者理解并实现这些概念。 二叉树由节点构成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的主要类型有...
二叉树-基于C语言实现的二叉树基本操作.zip
最新发布
04-26
本压缩包包含的是基于C语言实现的二叉树基本操作，是学习和理解二叉树概念以及其实现的一个宝贵资源。 在C语言中，实现二叉树通常涉及定义一个结构体来表示节点，这个结构体至少包含两个指针，分别指向左右子节点，...
二叉树基本操作_二叉树基本操作_
10-02
二叉树的这些基本操作构成了二叉树算法的基础。在实际应用中，我们还可能遇到其他操作，如遍历（前序、中序、后序）和平衡二叉树（如AVL树和红黑树）等。了解并熟练掌握这些基本操作，对于解决更复杂的算法问题具有...
二叉树的基本操作（C语言版）
缥缈
10-28 994
#include #include #define MaxSize 100 typedef char ElemType; typedef struct node { ElemType data;//数据类型 struct node *lchild;//指向左孩子 struct node *rchild;//指向右孩子 }BTNode; void CreateBTNode(B
名称：二叉树及其基本操作
BLSpan的博客
10-15 277
/* 名称：二叉树及其基本操作 说明：最近重新学习了二叉树，多了一个纬度，我去难度可不是上升一个层次。磨磨蹭蹭慢慢悠悠的把基本操作敲完了。在此记录一下。*///二叉树的存储结构 typedef struct BiTNode { int data; //数据域 struct BiTNode *lchild,*rchild; //指针域}BiTNo
二叉树的建立和基本操作
热门推荐
Roope的专栏
11-14 1万+
树形结构要多利用递归来求解，递归的关键就是想清楚所有的基准情形，然后扩展到一般情况，写代码的时候最好把基准情况放在前面，把一般情况放在后面！ 定义二叉树结构体： [cpp] view plaincopy typedef struct BinaryTreeNode   {       TelemType data;       stru
二叉树的基本操作　C++代码实现
Tanswer_
10-29 1万+
首先定义节点typedef struct BTree { int value; struct BTree *lchild; struct BTree *rchild; }BTree;前序递归建立二叉树/* **num 前序序列 **index 下标 */ BTree *CreateBTree(BTree *node,int *num,int& index) {
数据结构算法总结
aa838260772的专栏
09-08 1385
//链表基本操作tatus ListOppose(LinkList &L) { linklist p,q; p=L; p=p->next; L->next=NULL; while(p){ q=p; p=p->next; q->next=L->next; L->next=q; }
二叉树基础操作实现教程与代码解析
以上介绍的二叉树基本操作是数据结构学习中的核心内容，对于初学者来说，通过程序实现这些操作可以加深对其理论的理解，并为处理更复杂的数据结构打下坚实的基础。在实际编程实践中，通常会用递归或非递归的方式实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值