二叉树的建立


在数据结构的书里,看了半天,还是没有回过味来,不知其然。
简单的按照书里的意思就是:比如现在有int 1--31,一个数一个数的添加进去,构建成一个二叉树,可是里面的代码和分析我看了半天也没明白。
哪位大虾能给我个有详细文档的代码吗?感激不尽

8 个解决方案

#1


可是里面的代码和分析

--------------------

贴出来看看

#2


输入一串字符,按字母顺序构造一棵二叉排序树,每个结点的值就是一个字符。然后求该树的深度、叶子结点

数,再按中序遍历打印出来。

#include<stdio.h>
#include<malloc.h>
#define Len sizeof(btnode)
#define null 0
/*定义结点*/
typedef struct node{
        char data;
        struct node *lchild,*rchild;
            }btnode;
btnode *T;
/*定义一个插入算法*/
struct node *insert(btnode *s,btnode *t)
{if(t=null)
 t=s;
 else if(s->data<t->data)
 t->lchild=insert(s,t->lchild);
 else t->rchild=insert(s,t->rchild);
 return t;
}
/*生成一棵二叉树*/
btnode *creat_bintree()
{
 char ch;
 btnode *t,*s;
 printf("\n enter ch in order:");
 ch=getchar();
 if(ch='') t=null;
 else{t=(btnode *)malloc(Len);
 t->data=ch;
 t->lchild=null;
 t->rchild=null;
 s=insert(s,t);
 getchar();
}
return t;
 }
/*求二叉树的深度*/
int counth(btnode *t)
{int h,lh,rh;
 if(t=null) h=0;
 else{h=1;lh=counth(t->lchild);rh=counth(t->rchild);
 if(lh>rh) h=h+lh;
 else h=h+rh;
}
return h;
}
/*求二叉树的叶子结点数*/
int countleaf(btnode *t)
{
int leaf;
if (t=null) leaf=0;
else
if((t->lchild=null)&&(t->rchild=null)) leaf=1;
else leaf=countleaf(t->lchild)+countleaf(t->rchild);
return leaf;
}
/*中序遍历该树*/
void visit(btnode *t)
{putchar(t->data);
 printf("\t");
}

void inorder(btnode *t)
{if (t)
  {inorder(t->lchild);
   visit(t);
   inorder(t->rchild);
   }
}

int main()
{
 int depth,leaf_sum;
 btnode *T;
 T=creat_bintree();
 printf("\n");
 inorder(T);
 printf("\n");
 depth=counth(T);
 printf("the depth of the tree is %d\n",depth);
 leaf_sum=countleaf(T);
 printf("the number of leaves are:%d\n",leaf_sum);
 return 0;
}

#3


再不懂,
也得看 .....

建议楼主先看算法,
不要直接看代码,
从代码看算法,那是舍本逐末啊 ...

#4


至于代码,
这个是基本数据结构,
任何基础教程上都应该有参考代码,
也可以搜索一下。

【再转一个, 这个貌似比较简单一些】
#include <alloc.h>

#define ERROR 0;
#define FALSE 0;
#define TRUE 1;
#define OK 1;


typedef int ElemType;
typedef int Status;
typedef int KeyType;

#define EQ(a,b)  ((a)==(b))
#define LT(a,b)  ((a)< (b))
#define LQ(a,b)  ((a)<=(b))

typedef struct BinaryTree

{
  ElemType data;
  struct BinaryTree *l;
  struct BinaryTree *r;
}*BiTree,BiNode;

BiNode * new()
{
  return( (BiNode *)malloc(sizeof(BiNode)) );
}

CreateSubTree(BiTree *T,ElemType *all,int i)
{
  if ((all[i]==0)||i>16)
    {
      *T=NULL;
      return OK;
    }
  *T=new();
  if(*T==NULL) return ERROR;
  (*T)->data=all[i];
  CreateSubTree(&((*T)->l),all,2*i);
  CreateSubTree(&((*T)->r),all,2*i+1);
}

CreateBiTree(BiTree *T)
{
  ElemType all[16]={0,1,2,3,0,0,4,5,0,0,0,0,6,0,0,0,};
  CreateSubTree(T,all,1);
}

printelem(ElemType d)
{
  printf("%d\n",d);
}

PreOrderTraverse(BiTree T,int (*Visit)(ElemType d))
{
  if(T){
    if(Visit(T->data))
      if(PreOrderTraverse(T->l,Visit))
if(PreOrderTraverse(T->r,Visit)) return OK;
    return ERROR;
  } else  return OK;
}

InOrderTraverse(BiTree T,int (*Visit)(ElemType d))
{
  if(T){
    if(InOrderTraverse(T->l,Visit))
      if(Visit(T->data))
        if(InOrderTraverse(T->r,Visit)) return OK;
    return ERROR;
  }else return OK;
}

Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree *p){

  if(!T) {*p=f;return FALSE;}
  else if EQ(key,T->data){ *p=T;return TRUE;}
  else if LT(key,T->data) SearchBST(T->l,key,T,p);
  else SearchBST(T->r,key,T,p);
}

Status InsertBST(BiTree *T,ElemType e){
  BiTree p;
  BiTree s;
  if(!SearchBST(*T,e,NULL,&p)){
    s=(BiTree)malloc(sizeof(BiNode));
    s->data=e;s->l=s->r=NULL;
    if(!p) *T=s;
    else if (LT(e,p->data)) p->l=s;
    else p->r=s;
    return TRUE;
  }
  else return FALSE;
}

void Delete(BiTree *p){
 BiTree q,s;
  if(!(*p)->r){
    q=(*p);
    (*p)=(*p)->l;
    free(q);
  }
  else if(!(*p)->l){
    q=(*p);
    (*p)=(*p)->r;
    free(q);
  }
  else {

/*    q=(*p);
    s=(*p)->l;
    while(s->r) {q=s; s=s->r;}
    (*p)->data=s->data;
    if(q!=(*p) ) q->r=s->l;
    else q->l=s->l;
    free(s);
    */

    q=s=(*p)->l;
    while(s->r) s=s->r;
    s->r=(*p)->r;
    free(*p);
    (*p)=q;

  }
}

Status DeleteBST(BiTree *T,KeyType key){
  if (!(*T) )
    {return FALSE;}
  else{
    if ( EQ(key,(*T)->data)) Delete(T);
    else if ( LT(key,(*T)->data)) DeleteBST( &((*T)->l), key);
    else DeleteBST( &((*T)->r),key);
    return TRUE;
  }
}


int main()
{
  BiTree root;
  BiTree sroot=NULL;
  int i;
  int a[10]={45,23,12,3,33, 27,56,90,120,62};
  system("cls");
  CreateBiTree(&root);
  printf("PreOrderTraverse:\n");
  PreOrderTraverse(root,printelem);
  printf("InOrderTraverse:\n");
  InOrderTraverse(root,printelem);
  for(i=0;i<10;i++)
    InsertBST(&sroot,a[i]);
  printf("InOrderTraverse:\n");
  InOrderTraverse(sroot,printelem);
  for(i=0;i<3;i++)
  DeleteBST(&sroot,a[i]);
  printf("Now sroot has nodes:\n");
  InOrderTraverse(sroot,printelem);
  return 0;
}

#5


C++版的 比较清晰。。

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

template <typename T>
class BTree;

enum MarkType
{
F = 1,
M = 2,
B = 3,
L = 4
};

template <typename T>
class Node
{
public:
friend class BTree<Node>;
typedef T value_type;
Node(T datatmp, Node* lefttmp = 0, Node* righttmp = 0)
:data(datatmp), left(lefttmp), right(righttmp)
{

}
private:
T data;
Node* left;
Node* right;
};

template <typename T>
class BTree
{
private:
T* root;
public:
BTree();
~BTree();
void Create(const vector<typename T::value_type>& temp);
void Display(MarkType Mark) const;
bool Empty() const;
int Depth();
int Count();
int LeafCount();
void Print();
void Clear();
protected:
//&#65415;&#65392;&#65424;&#12539;
void PreOrder(T* temproot) const;
//&#65430;&#65424;&#65424;&#12539;
void InOrder(T* temproot) const;
//&#65402;&#12539;
void PostOrder(T* temproot) const;
//&#65394;耙&#12539;
void LevelOrder(T* temproot) const;

};

template <typename T>
BTree<T>::BTree()
{
}

template <typename T>
BTree<T>::~BTree()
{
}
template <typename T>
void BTree<T>::Create(const vector<typename T::value_type>& temp)
{
Clear();
queue<T*> que;

vector<typename T::value_type>::const_iterator it = temp.begin();
vector<typename T::value_type>::const_iterator itend = temp.end();
root = new T(*it);
que.push(root);
while (1)
{
T* ttemp;
ttemp = que.front();
que.pop();

                  it++;
                  if (it == itend)
break;

T* t1 = new T(*it);
ttemp->left = t1;
que.push(t1);

                  it++;
if (it == itend)
break;

                  T* t2 = new T(*it);
ttemp->right = t2;
que.push(t2);
}
}

template<typename T>
bool BTree<T>::Empty() const
{
return (root==0);
}

template<typename T>
void BTree<T>::Display(MarkType Mark) const
{
if (Mark == 1)
{
cout << "&#65415;&#65392;&#65424;鯊&#12539; ";
PreOrder(root);
cout << endl;
}
else if (Mark == 2)

cout << "&#65430;&#65424;&#65424;鯊&#12539; ";
InOrder(root);
cout << endl;
}
else if (Mark == 3)
{
cout << "&#65402;鯊&#12539; ";
PostOrder(root);
cout << endl;
}
else if (Mark == 4)
{
cout << "&#65394;耙鯊&#12539; ";
LevelOrder(root);
cout << endl;
}
}
template <typename T>
void BTree<T>::PreOrder(T* temproot) const
{
if (temproot == 0)
return ;
else
{
cout << temproot->data;
PreOrder(temproot->left);
PreOrder(temproot->right);
}
}
template <typename T>
void BTree<T>::InOrder(T* temproot) const
{
if (temproot == 0)
return ;
else
{
InOrder(temproot->left);
cout << temproot->data;
InOrder(temproot->right);
}
}
template <typename T>
void BTree<T>::PostOrder(T* temproot) const
{
if (temproot == 0)
return ;
else
{
PostOrder(temproot->left);
PostOrder(temproot->right);
cout << temproot->data;
}
}
template <typename T>
void BTree<T>::LevelOrder(T* temproot) const
{
queue<T*> que;
que.push(temproot);
while ( !que.empty() )
{
T* temp = que.front();
que.pop();
cout << temp->data;
if (temp->left)  que.push(temp->left);
if (temp->right) que.push(temp->right);

}
}

template <typename T>
void BTree<T>::Clear()
{

  
}

int main()
{


vector<int> nVec;
nVec.reserve(10);

nVec.push_back(1);
nVec.push_back(2);
nVec.push_back(3);
nVec.push_back(4);
nVec.push_back(5);
nVec.push_back(6);
nVec.push_back(7);


BTree<Node<int> >  btree;

btree.Create(nVec);
btree.Display(F);
btree.Display(M);
btree.Display(B);
btree.Display(L);

        cin.get();
return 0;
}

#6


先序序列建立:
int CreateBiTree(BiTree &T)
{
char ch;
ch=getchar();
if(ch == " ") T = NULL;
else
{
if(!(T= (BiTNode*)malloc(sizeof(BiTNode) ))) exit(0);
T->data = ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
return 1;

}
二叉树的创建是递归调用的,先输入根节点,然后是左子树、右子树。为空格时,相应的节点为空...
  a
 /
b
比如上面二叉树输入时应该:a b _ _ _//其中_代表空格,注意符号之间没有空格

#7


/*定义结点*/
typedef struct node{
        char data;
        struct node *lchild,*rchild;
            }btnode;
btnode *T;
/*定义一个插入算法*/
struct node *insert(btnode *s,btnode *t)
{if(t=null)
 t=s;
 else if(s->data<t->data)
 t->lchild=insert(s,t->lchild);
 else t->rchild=insert(s,t->rchild);
 return t;
}


回瞌睡虫:
貌似函数参数应该用引用:
struct node *insert(btnode *&s,btnode *&t)

#8


谢谢 ,受教了。
智能推荐

注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
© 2014-2019 ITdaan.com 粤ICP备14056181号  

赞助商广告