以后续遍历的方式递归建立二叉树and二级指针问题

[懒得搭理你]

怎么样以后续遍历的方式递归建立二叉树，想了好久也不行啊，求助前辈大侠们了。
还有一个小问题,如下：
#include<stdio.h>
#include<stdlib.h>

typedef char datatype;
int d; /*二叉树的深度 */
typedef struct node /*二叉树结点定义*/
{
datatype data;
struct node *lchild,*rchild;
struct node *parent;
}bintnode;

typedef bintnode *bintree;

void main()
{
bintree *p,*t;
*p=(bintnode *)malloc(sizeof(bintnode));
(*p)->data='0';
*t=*p;
//*t=(bintnode *)malloc(sizeof(bintnode));
printf("%c",(*t)->data);
}
怎么运行不了，*P怎么解释?
回答满意的话，追加分。

[wozuiqiang001]

吧main函数改成如下：
void main()
{
bintree *p,*t;
p=(bintree *)malloc(sizeof(bintree));
t=(bintree *)malloc(sizeof(bintree));
*p=(bintnode *)malloc(sizeof(bintnode));
(*p)->data='0';
*t=*p;
//*t=(bintnode *)malloc(sizeof(bintnode));
printf("%c",(*t)->data);
}
原因：
p是一个指向指针变量的指针，在没规定他指向什么变量时候，不能用*p这样来访问它指向的对象（还没有指向对象）

[yin138]

首先你的意思是想建立两个节点将放入树中是吧？

void main()   
{
    //bintree已经是一具指向树节点的指针了，你再声明成指针，那就是指针的指针了 
    //bintree *p,*t; 
    bintree tree;
    
    //建立一个节点,并让树指南，以成为树根
    tree = (bintree)malloc(sizeof(bintnode));
    //*p=(bintnode *)malloc(sizeof(bintnode)); //这里不需要*
    //根结点数据为空
    //(*p)->data='0';
    p->data = '0';
   //建立左孩子
    p->lchild = (bintnode*)malloc(sizeof(bintnode));
    //....
  }

先不要说你的先序遍历问题吧，你估计对于数据结构类型不是很了解，可查相关资料，不然写树，你会疯的。

建议采用如下方式写义

typedef struct node{
///...
}node_t, *pnode_t;
typedef tree_t pnode_t;

tree_t mytree = (tree_t)malloc(sizeof(node_t));
mytree->lchild = (pnode_t)malloc(sizeof(node_t));
mytree->rchild = (pnode_t)malloc(sizeof(node_t));
mytree->data = 'x';
//....

//给个使用树的例子
void freetree(tree_t root)
{
   if (root->lchild != NULL) freetree(root->lchild);
   if (root->rchild != NULL) freetree(root->rchild);
   free(root);
}

[kensun0]

#include "Stdio.h"
#include "Conio.h"

typedef struct BiTNode{
char data;
struct BiTNode * lchild,* rchild;
} BiTree ;
int main(void)
{
/* 此处添加你自己的代码 */

CreatBiTree();

getch();
return 0;
}

CreatBiTree(BiTree *T)
{
char ch;
scanf ("%c",&ch);
fflush (stdin);
if (ch==' ')
{
T=NULL;

}
else
{
T=(BiTree *)malloc(sizeof(BiTree));
if (!T)
printf ("overflow");

T->data=ch;
printf ("%c\n",T->data);

CreatBiTree(T->rchild);
CreatBiTree(T->lchild);
}
return 0;
}

[懒得搭理你]

[Quote=引用 4 楼 kensun0 的回复:]
#include "Stdio.h"
#include "Conio.h"

typedef struct BiTNode{
char data;
struct BiTNode * lchild,* rchild;
} BiTree ;
int main(void)
{
/* 此处添加你自己的代码 */

CreatBiTree();

getch(……
[/Quote]
貌似你这样不行吧

[懒得搭理你]

[Quote=引用 3 楼 yin138 的回复:]
首先你的意思是想建立两个节点将放入树中是吧？

C/C++ code

void main()
{
//bintree已经是一具指向树节点的指针了，你再声明成指针，那就是指针的指针了
//bintree *p,*t;
bintree tree;

//建立一个节点,并让树指南，以成为树根
tree = (bintree……
[/Quote]
我的意思是后续遍历的方式创建树，但是我写的，系统总是提示指针出错

[wozuiqiang001]

楼主是想用后序的方法还原树吧？
先序我倒是的做过一个，不过没用递归，
一定要注意使用指针前是要先赋值的

[kensun0]

呃。。不是不行，树是生成了，就是无法引用。。。

/* 标准文档模板 */

#include "Stdio.h"
#include "Conio.h"

typedef struct BiTNode{
    char data;
    struct BiTNode * lchild,* rchild;
    } BiTree ;
int main(void)
{
 /* 此处添加你自己的代码 */
    BiTree a;
    BiTree *p;
    p=&a;

    CreatBiTree(&p);

    Preorder(p);
    printf ("\n");
    inorderout(p);
    printf ("\n");
    Postorder(p);

    getch();
    return 0;
}

CreatBiTree(BiTree **T)
{
    char ch;
    scanf ("%c",&ch);
    fflush (stdin);

    if (ch==' ')
    {
         *T=NULL;

    }
    else
    {
        *T=(BiTree *)malloc(sizeof(BiTree));
        if (!T)
            printf ("overflow");

        (*T)->data=ch;
        printf ("%c\n",(*T)->data);
        /* printf ("%d",T); */

        CreatBiTree(&(*T)->lchild);
        CreatBiTree(&(*T)->rchild);
    }
    return 0;
}

Preorder(BiTree *T)
{
    if (T)
    {
        printf ("%c",T->data);  /*访问结点数据*/
        Preorder(T->lchild);    /*先序遍历二叉树T的左子树*/
        Preorder(T->rchild);    /*先序遍历二叉树T的右子树*/
    }
}

inorderout(BiTree *T)
{
    if(T)
 {
    inorderout(T->lchild);      /*中序遍历二叉树T的左子树*/
    printf ("%c",T->data);            /*访问结点数据*/
    inorderout(T->rchild);       /*中序遍历二叉树T的右子树*/
 }
}
Postorder(BiTree *T)
{
    if (T)
    {
        Postorder(T->lchild);      /*后序遍历二叉树T的左子树*/
        Postorder(T->rchild);    /*后序遍历二叉树T的右子树*/
        printf ("%c",T->data);   /*访问结点数据*/
    }
}
    

[kensun0]

我郁闷，这是先序树，你把建树函数的l和r互换应该就行了。。。

[懒得搭理你]

[Quote=引用 7 楼 wozuiqiang001 的回复:]
楼主是想用后序的方法还原树吧？
先序我倒是的做过一个，不过没用递归，
一定要注意使用指针前是要先赋值的
[/Quote]
对 对 对 我就是被那个指针搞晕掉了

[懒得搭理你]

[Quote=引用 9 楼 kensun0 的回复:]
我郁闷，这是先序树，你把建树函数的l和r互换应该就行了。。。
[/Quote]
不可能 我试过

[懒得搭理你]

[Quote=引用 14 楼 kensun0 的回复:]
呃。。是不对，我再改改

引用 11 楼 wangyinbin 的回复:
引用 9 楼 kensun0 的回复:
我郁闷，这是先序树，你把建树函数的l和r互换应该就行了。。。

不可能 我试过
[/Quote]
那个我早改过了，我的思路是：遍历时先将所有的节点指针初始化，等到了最叶子节点时，再赋值

[kensun0]

到这个程度，你就不会自己改改啊。。。[Quote=引用 11 楼 wangyinbin 的回复:]
引用 9 楼 kensun0 的回复:
我郁闷，这是先序树，你把建树函数的l和r互换应该就行了。。。

不可能 我试过
[/Quote]

[kensun0]

你改成与历遍方式相对的不就是建树的顺序了

CreatBiTree(BiTree **T)
{
    char ch;
    scanf ("%c",&ch);
    fflush (stdin);

    if (ch==' ')
    {
         *T=NULL;

    }
    else
    {
        *T=(BiTree *)malloc(sizeof(BiTree));
        if (!T)
            printf ("overflow");


        CreatBiTree(&(*T)->lchild);
        CreatBiTree(&(*T)->rchild);
        (*T)->data=ch;
    }
    return 0;
}

[kensun0]

呃。。是不对，我再改改[Quote=引用 11 楼 wangyinbin 的回复:]
引用 9 楼 kensun0 的回复:
我郁闷，这是先序树，你把建树函数的l和r互换应该就行了。。。

不可能 我试过
[/Quote]

[懒得搭理你]

[Quote=引用 17 楼 kensun0 的回复:]
基本思想是先建好先序树的结点位置，然后使用后序树的赋值方法。
[/Quote]
你是怎么输入的，我怎么感觉有问题啊

[kensun0]

这个貌似是对的，好费劲啊。。

#include "Stdio.h"
#include "Conio.h"
#include "queue.c"

typedef struct BiTNode{
    char data;
    struct BiTNode * lchild,* rchild;
    } BiTree ;

LinkQueue Q;

int main(void)
{
    BiTree *p;

    InitQueue(&Q);

    CreatBiTree(&p);

    Q2Post(&p) ;

    printf ("preorder:");
    Preorder(p);
    printf ("\n");

    printf ("inorder:");
    inorderout(p);
    printf ("\n");

    printf ("postorder:");
    Postorder(p);
    printf ("\n");


    getch();
    return 0;
}

CreatBiTree(BiTree **T)
{
    char ch;

    scanf ("%c",&ch);
    fflush (stdin);

    if (ch==' ')
    {
        *T=NULL;

    }
    else
    {

        *T=(BiTree *)malloc(sizeof(BiTree));
        if (!T)
            printf ("overflow");

        EnQueue (&Q,ch);
        CreatBiTree(&(*T)->lchild);
        CreatBiTree(&(*T)->rchild);

    }
    return 0;
}

Q2Post(BiTree **T)
{
    if (*T)
    {
        Q2Post(&(*T)->lchild);              /*后序遍历二叉树T的左子树*/
        Q2Post(&(*T)->rchild);              /*后序遍历二叉树T的右子树*/
        DeQueue (&Q,&(*T)->data);           /*OUT结点数据*/
    }
}


/*li bian function */

Preorder(BiTree *T)
{
    if (T)
    {
        printf ("%c",T->data);  /*访问结点数据*/
        Preorder(T->lchild);    /*先序遍历二叉树T的左子树*/
        Preorder(T->rchild);    /*先序遍历二叉树T的右子树*/
    }
}

inorderout(BiTree *T)
{
    if(T)
    {
    inorderout(T->lchild);      /*中序遍历二叉树T的左子树*/
    printf ("%c",T->data);      /*访问结点数据*/
    inorderout(T->rchild);      /*中序遍历二叉树T的右子树*/
    }
}
Postorder(BiTree *T)
{
    if (T)
    {
        Postorder(T->lchild);    /*后序遍历二叉树T的左子树*/
        Postorder(T->rchild);    /*后序遍历二叉树T的右子树*/
        printf ("%c",T->data);   /*访问结点数据*/
    }
}

用到队列了，自己写的

#include "Stdio.h"
#include "Conio.h"
#define QElemType char

typedef struct QNode{
    QElemType data;
    struct QNode * next;
    }QNode, *QueuePtr;

typedef struct {
    QueuePtr front;
    QueuePtr rear;
    } LinkQueue;

InitQueue(LinkQueue *Q)
{
    (*Q).rear=(QueuePtr)malloc(sizeof(QNode));
    (*Q).front=(*Q).rear;
    if (!(*Q).front)
    {
        printf ("overflow");
        return -1;
    }
    (*Q).front->next=NULL;
    return 0;
}

DestroyQueue(LinkQueue *Q)
{
    while ((*Q).front)
    {
        (*Q).rear=(*Q).front->next;
        free ((*Q).front);
        (*Q).front=(*Q).rear;
    }
    return 0;
}

EnQueue (LinkQueue *Q ,QElemType e)
{
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode)) ;
    if (!p)
    {
        printf ("overflow");
        return -1;
    }
    p->data=e;
    p->next=NULL;
    (*Q).rear->next=p;
    (*Q).rear=p;
    return 0;
}

DeQueue (LinkQueue *Q ,QElemType *e)
{
    QueuePtr p;
    if ((*Q).rear==(*Q).front)
        return -1;
    p=(*Q).front->next;
    *e=p->data;
    (*Q).front->next=p->next;

    if ((*Q).rear==p)
        (*Q).rear=(*Q).front;
    free (p);
    return 0;
}

[Quote=引用 15 楼 wangyinbin 的回复:]
引用 14 楼 kensun0 的回复:
呃。。是不对，我再改改

引用 11 楼 wangyinbin 的回复:
引用 9 楼 kensun0 的回复:
我郁闷，这是先序树，你把建树函数的l和r互换应该就行了。。。

不可能 我试过

那个我早改过了，我的思路是：遍历时先将所有的节点指针初始化，等到了最叶子节点时，再赋值
[/Quote]

[kensun0]

基本思想是先建好先序树的结点位置，然后使用后序树的赋值方法。

[懒得搭理你]

[Quote=引用 19 楼 kensun0 的回复:]
正常输入啊。。。空格说明没孩子。先没左孩子，再没右孩子。
比如：1，2，空，空，3，空，空。
树型 1
2 3


引用 18 楼 wangyinbin 的回复:
引用 17 楼 kensun0 的回复:
基本思想是先建好先序树的结点位置，然后使用后序树的赋值方法。

你是怎么输入的，我怎么感觉有问题啊
[/Quote]
和我想的不一样
结贴!

[kensun0]

正常输入啊。。。空格说明没孩子。先没左孩子，再没右孩子。
比如：1，2，空，空，3，空，空。
树型 1
2 3

[Quote=引用 18 楼 wangyinbin 的回复:]
引用 17 楼 kensun0 的回复:
基本思想是先建好先序树的结点位置，然后使用后序树的赋值方法。

你是怎么输入的，我怎么感觉有问题啊
[/Quote]

[zhaowoxin]

为什么要用二级指针啊？？？
跪求解
本人数据结构很不好的！！！
[Quote=引用 13 楼 kensun0 的回复:]
你改成与历遍方式相对的不就是建树的顺序了

C/C++ code
CreatBiTree(BiTree **T)
{
char ch;
scanf ("%c",&ch);
fflush (stdin);

if (ch==' ')
{
*T=NULL;

}
else
{
……
[/Quote]