c語言二叉樹遍歷
『壹』 c語言二叉樹的遍歷。
二叉樹的前中後遍歷（遞歸與非遞歸）
#include<stdio.h>
#include<stdlib.h>
typedef struct NODE
{
char value;
struct NODE *LChild;
struct NODE *RChild;
}BiTNode,*BiTree; //二叉樹數據結構
BiTree root;
typedef struct node
{
BiTNode *pointer;
struct node *link;
}LinkStackNode,*LinkStack; //鏈棧數據結構
LinkStack S;
int count = 0;
//BiTNode * InitTree(BiTree Tree);
BiTNode *CreateTree(BiTree Tree); //創建二叉樹
void PreOrder(BiTree Tree); //遞歸前序遍歷二叉樹
void MidOrder(BiTree Tree); //遞歸中序遍歷二叉樹
void PostOrder(BiTree Tree); //遞歸後序遍歷二叉樹
void NPreOrder(BiTree Tree); //非遞歸前序遍歷二叉樹
void NMidOrder(BiTree Tree); //非遞歸中序遍歷二叉樹
void NPostOrder(BiTree Tree); //非遞歸後序遍歷二叉樹
//---------------------------------------------------
LinkStackNode *InitLinkStack(LinkStack top); //初始化鏈棧
void Push(LinkStack top,BiTNode *p); //進棧操作
BiTNode * Pop(LinkStack top); //出棧操作
//int IsEmpty(LinkStack S); //判斷棧是否為空
void main()
{
//BiTree tree;
//root = InitTree(tree);
root = CreateTree(root);
PreOrder(root);
printf("\n");
MidOrder(root);
printf("\n");
PostOrder(root);
printf("\n");
NPreOrder(root);
printf("\n");
NMidOrder(root);
printf("\n");
NPostOrder(root);
printf("\n");
}
/*BiTNode * InitTree(BiTree Tree)
{
//BiTNode *root;
//root = Tree;
Tree = (BiTNode *)malloc(sizeof(BiTNode));
Tree = NULL;
//Tree->LChild = NULL;
//Tree->RChild = NULL;
return Tree;
}*/
//二叉樹的擴展先序遍歷的創建
BiTNode * CreateTree(BiTree Tree)
{
char ch;
ch = getchar();
if(ch == '.')
Tree = NULL;
else
{
Tree = (BiTNode *)malloc(sizeof(BiTNode));
if(Tree)
{
Tree->value = ch;
Tree->LChild = CreateTree(Tree->LChild);
Tree->RChild = CreateTree(Tree->RChild);
}
}
return Tree;
}
//遞歸前序遍歷二叉樹
void PreOrder(BiTree Tree)
{
if(Tree)
{
printf("%c",Tree->value);
PreOrder(Tree->LChild);
PreOrder(Tree->RChild);
}
}
//遞歸中序遍歷二叉樹
void MidOrder(BiTree Tree)
{
if(Tree)
{
MidOrder(Tree->LChild);
printf("%c",Tree->value);
MidOrder(Tree->RChild);
}
}
//遞歸後序遍歷二叉樹
void PostOrder(BiTree Tree)
{
if(Tree)
{
PostOrder(Tree->LChild);
PostOrder(Tree->RChild);
printf("%c",Tree->value);
}
}
//非遞歸前序遍歷二叉樹
void NPreOrder(BiTree Tree)
{
BiTNode *p;
S = InitLinkStack(S);
p = Tree;
while(p || count != 0)
{
if(p)
{
if(p->RChild)
Push(S,p->RChild);
printf("%c",p->value);
p = p->LChild;
}
else
p = Pop(S);
}
}
//非遞歸中序遍歷二叉樹
void NMidOrder(BiTree Tree)
{
//char ch;
BiTNode *p;
S = InitLinkStack(S);
p = Tree;
while(p || count != 0)
{
if(p)
{
Push(S,p);
p = p->LChild;
}
else
{
p = Pop(S);
printf("%c",p->value);
p = p->RChild;
}
}
}
//非遞歸後序遍歷二叉樹
void NPostOrder(BiTree Tree)
{
BiTNode *p,*q = NULL;
S = InitLinkStack(S);
p = Tree;
while(p || count != 0)
{
if(p)
{
Push(S,p);
p = p->LChild;
}
else
{
p = S->link->pointer;
if(p->RChild == NULL || p->RChild == q)
{
p = Pop(S);
printf("%c",p->value);
q = p;
p = NULL;
}
else
{
//p = Pop(S);
p = p->RChild;
}
}
}
}
//初始化鏈棧
LinkStackNode *InitLinkStack(LinkStack top)
{
top = (LinkStackNode *)malloc(sizeof(LinkStackNode));
return top;
}
//進棧操作
void Push(LinkStack top,BiTNode *p)
{
LinkStackNode *temp;
temp = (LinkStackNode *)malloc(sizeof(LinkStackNode));
if(temp)
{
temp->pointer = p;
temp->link = top->link;
top->link = temp;
count++;
}
}
//出棧操作
BiTNode * Pop(LinkStack top)
{
//char ch;
BiTNode *p;
LinkStackNode *temp;
p = (BiTNode *)malloc(sizeof(BiTNode));
temp = top->link;
if(temp)
{
top->link = temp->link;
p = temp->pointer;
free(temp);
count--;
}
return p;
}
『貳』 C語言二叉樹遍歷代碼
1.t = malloc(sizeof(tree));
2.t->rchild =createTree();
3.void qianxu(tree *t)
4.zhongxu(t->lchild );//再讀左子樹
printf("%c",t->data);//先讀根結點
zhongxu(t->rchild );//再讀右子樹
5.houxu(t->lchild );//再讀左子樹
houxu(t->rchild );//再讀右子樹
printf("%c",t->data);//先讀根結點
6.return 0;
7.n=count(t->lchild)+count(t->rchild)+1;
8.t1->data=t->data;
9.return t1;
10.return m+1;
PS:注意有些語句結尾是沒有分號的
『叄』 二叉樹的遍歷程序！數據結構C語言！要能運行的！
#include<iostream>
using
namespace
std;
#define
OK
1
#define
ERROR
0
#define
OVERFLOW
-1
typedef
int
Status
;
typedef
char
TElemType;
typedef
struct
TreeNode{
//定義的樹結點
TElemType
Data;
struct
TreeNode
*lchild,*rchild;
}TreeNode,*Treep;
Treep
CreateTree(Treep
&T)
//使用先序遍歷優勢創建
{
char
ch;
//
cout<<"\n請你輸入你要創建的樹元素：";
cin>>ch;
if(ch
==
'#')
//若是"#",代表該節點為空
T
=
NULL;
else
{
T
=
new
TreeNode;
//申請空間
if(!T)
return
ERROR;
//空間申請失敗返回錯誤信息
T->Data
=
ch;
//鍵盤輸入結點信息
CreateTree(T->lchild);
//遞歸調用創建左子樹
CreateTree(T->rchild);
//遞歸調用創建右子樹
}
return
T;
}
void
TreeTreaverseF(Treep
T)
//二叉樹先序遍歷
{
if(T)
{
cout<<T->Data;
//輸出根節點值
TreeTreaverseF(T->lchild);
//遞歸調用輸出左子樹
TreeTreaverseF(T->rchild);
//遞歸調用輸出右子樹
}
}
void
TreeTreaverseS(Treep
T)
//中序遍歷二叉樹
{
if(T)
{
TreeTreaverseS(T->lchild);
//遞歸調用輸出左子樹
cout<<T->Data;
//輸出左節點
TreeTreaverseS(T->rchild);
//遞歸調用輸出右子樹
}
}
void
TreeTreaverseT(Treep
T)
{
if(T)
{
TreeTreaverseT(T->lchild);
//遞歸調用輸出左子樹
TreeTreaverseT(T->rchild);
//遞歸調用輸出右子樹
cout<<T->Data;
//輸出右節點
}
}
int
main()
{
Treep
T=NULL;
cout<<"\n開始創建樹狀結構...\n";
cout<<"\n各元素以空格隔開\n";
CreateTree(T);
cout<<"\n先序遍歷輸出樹...\n";
TreeTreaverseF(T);
cout<<endl<<endl;
cout<<"\n中序遍歷輸出樹...\n";
TreeTreaverseS(T);
cout<<endl<<endl;
cout<<"\n後序遍歷輸出樹...\n";
TreeTreaverseT(T);
cout<<endl<<endl;
return
0;
}
『肆』 求用C語言實現二叉樹層次遍歷的遞歸演算法，謝謝！！！
演算法思想：層次遍歷目前最普遍用的就是隊列的那種方式，不是遞歸，但是用到while循環，既然題目要求用遞歸，可以用遞歸實現該while循環功能。演算法如下：
void TransLevele(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
if (r->left != NULL)
{
InsertQueue(r->left);
}
if (r->right != NULL)
{
InsertQueue(r->right);
}
Tree *t = DeleteQueue();
TransLevele(t);
}
//測試程序，創建樹輸入例如ABD##E##C##,根左右創建的方式。
如下代碼是測試通過的。
#include "stdlib.h"
#define MAX 100
typedef int Element;
typedef struct tree
{
Element ch;
struct tree *left;
struct tree *right;
}Tree;
typedef struct queue
{
Tree *a[MAX];
int front;
int rear;
}Queue;
Queue Qu;
void Init();
int InsertQueue(Element ch);
Tree *DeleteQueue();
void CreateTree(Tree **r);
void TransLevele(Tree *r);
void PrintTree(Tree *r);
int main()
{
Tree *r=NULL;
CreateTree(&r);
PrintTree(r);
printf("\n");
TransLevele(r);
return 0;
}
void Init()
{
int i=0;
for (i=0; i<MAX; i++)
{
Qu.a[i] = NULL;
}
Qu.front = 0;
Qu.rear = 0;
}
int InsertQueue(Tree *r)
{
if ( (Qu.rear+1)%MAX == Qu.front)
{
printf("Queue full!");
return 0;
}
Qu.a[Qu.rear] = r;
Qu.rear = (Qu.rear+1)%MAX;
return 1;
}
Tree *DeleteQueue()
{
if (Qu.front == Qu.rear)
{
printf("Queue empty");
return NULL;
}
Tree *t=NULL;
t = Qu.a[Qu.front];
Qu.front = (Qu.front+1)%MAX;
return t;
}
void CreateTree(Tree **r)
{
Element ch;
ch=getchar();
if (ch=='#')
{
(*r)=NULL;
return ;
}
*r = (Tree *)malloc(sizeof(Tree));
(*r)->ch = ch;
CreateTree(&((*r)->left));
CreateTree(&((*r)->right));
}
void PrintTree(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
PrintTree(r->left);
PrintTree(r->right);
}
void TransLevele(Tree *r)
{
if (r==NULL)
{
return ;
}
printf("%c",r->ch);
if (r->left != NULL)
{
InsertQueue(r->left);
}
if (r->right != NULL)
{
InsertQueue(r->right);
}
Tree *t = DeleteQueue();
TransLevele(t);
}
『伍』 C語言 二叉樹 遍歷問題
並不是你所說的那樣。
首先我們要知道遍歷是為了讓二叉樹的所有結點都掃描一遍，而前中後，三個遍歷方式，說的是他的顯示順序。
前序的特點：我們注意研究一下前序遍歷的結果，你會發現，對於每個二叉樹（只有根結點，左結點，右結點。一棵樹，是一個個小的二叉樹組成）在結果中，你都會發現，根結點必定在左結點前。你可以認真看看，就算，是子樹中也是根結點在左結點前。（比如，左結點成了另一個子樹的根結點，這個左結點對應的上一級根結點，也會顯示在這個左結點之前）
中序的特點：經過前序遍歷的分析 ，我們可以直接得出，中序遍歷結果中，每個根結點都會放在左結點和右結點中間。當然發生如，A的左結點是B，B的右結點是C，時中序遍歷結果會是
BCA，雖然A未在中間，但我們要分析，對於A是根結點，左結點B在其前面，對於B是根結點，右結點C在其後面。這符合根結點在左右結點中間的特點。
後序的特點：是先遍歷左右結點，才返回來遍歷根結點。參照前序和中序，就能明白
最後要注意的，可能 你也發現了，左結點的遍歷一定在右結點前。
下面附上遍歷的遞歸演算法
/*1 、前序遍歷二叉樹的遞歸演算法 */
void preorder(bintree t)
{
if (t) {
printf("%c",t->data);
preorder(t->lchild);
preorder(t->rchild);
}
}
/*2 、中序遍歷二叉樹的遞歸演算法 */
void inorder(bintree t)
{
if (t) {
inorder(t->lchild);
printf("%c",t->data);
inorder(t->rchild);
}
}
/*3 、後序遍歷二叉樹的遞歸演算法 */
void postorder(bintree t)
{
if (t) {
postorder(t->lchild);
postorder(t->rchild);
printf("%c",t->data);
}
}
說那麼多，我自己也復習下，哈哈
『陸』 C語言二叉樹遍歷查找問題
二叉樹的遍歷分為以下三種：
先序遍歷：遍歷順序規則為【根左右】
中序遍歷：遍歷順序規則為【左根右】
後序遍歷：遍歷順序規則為【左右根】
什麼是【根左右】？就是先遍歷根，再遍歷左孩子，最後遍歷右孩子；
舉個例子，看下圖：
先序遍歷：ABCDEFGHK
中序遍歷：BDCAEHGKF
後序遍歷：DCBHKGFEA
以中序遍歷為例：
中序遍歷的規則是【左根右】，我們從root節點A看起；
此時A是根節點，遍歷A的左子樹；
A的左子樹存在，找到B，此時B看做根節點，遍歷B的左子樹；
B的左子樹不存在，返回B，根據【左根右】的遍歷規則，記錄B，遍歷B的右子樹；
B的右子樹存在，找到C，此時C看做根節點，遍歷C的左子樹；
C的左子樹存在，找到D，由於D是葉子節點，無左子樹，記錄D，無右子樹，返回C，根據【左根右】的遍歷規則，記錄C，遍歷C的右子樹；
C的右子樹不存在，返回B，B的右子樹遍歷完，返回A；
至此，A的左子樹遍歷完畢，根據【左根右】的遍歷規則，記錄A，遍歷A的右子樹；
A的右子樹存在，找到E，此時E看做根節點，遍歷E的左子樹；
E的左子樹不存在，返回E，根據【左根右】的遍歷規則，記錄E，遍歷E的右子樹；
E的右子樹存在，找到F，此時F看做根節點，遍歷F的左子樹；
F的左子樹存在，找到G，此時G看做根節點，遍歷G的左子樹；
G的左子樹存在，找到H，由於H是葉子節點，無左子樹，記錄H，無右子樹，返回G，根據【左根右】的遍歷規則，記錄G，遍歷G的右子樹；
G的右子樹存在，找到K，由於K是葉子節點，無左子樹，記錄K，無右子樹，返回G，根據【左根右】的遍歷規則，記錄F，遍歷F的右子樹；
F的右子樹不存在，返回F，E的右子樹遍歷完畢，返回A；
至此，A的右子樹也遍歷完畢；
最終我們得到上圖的中序遍歷為BDCAEHGKF，無非是按照遍歷規則來的；
根據「中序遍歷」的分析，相信先序遍歷和後序遍歷也可以輕松寫出~
『柒』 二叉樹的建立與遍歷(C語言)
樓主你好~~~「ф」字元的源代碼我忘記了，我這里有一個自己寫過的遍歷演算法
#include<iostream.h>
typedef struct btnode
{
char data;
struct btnode *Lchild,*Rchild;
}*bitreptr;
void Create(bitreptr &p)
{
char n;
p=new btnode;
cin>>n;
if(n!='#')
{
p->data=n;
Create(p->Lchild);
Create(p->Rchild);
}
else
p=NULL;
}
void preorder(bitreptr &p)
{
if(p)
{
cout<<p->data<<" ";
preorder(p->Lchild);
preorder(p->Rchild);
}
}
void midorder(bitreptr &p)
{
if(p)
{
midorder(p->Lchild);
cout<<p->data<<" ";
midorder(p->Rchild);
}
}
void postorder(bitreptr &p)
{
if(p)
{
postorder(p->Lchild);
postorder(p->Rchild);
cout<<p->data<<" ";
}
}
void change(bitreptr &p)
{
bitreptr t,q;
if(p)
{
t=p->Lchild;
q=p->Rchild;
p->Lchild=q;
p->Rchild=t;
change(p->Lchild);
change(p->Rchild);
}
}
void main()
{
char i;
cout<<"請選擇所需功能（'A'輸出該二叉樹序列，'B'輸出交換後二叉樹序列)"<<endl;
cin>>i;
bitreptr p;
cout<<"輸入數據：";
Create(p);
switch(i)
{
case 'A':
{
cout<<"前序:";
preorder(p);
cout<<endl;
cout<<"中序:";
midorder(p);
cout<<endl;
cout<<"後序:";
postorder(p);
cout<<endl;
}break;
case 'B':
{
change(p);
cout<<"交換二叉樹前序:";
preorder(p);
cout<<endl;
cout<<"交換二叉樹中序:";
midorder(p);
cout<<endl;
cout<<"交換二叉樹後序:";
postorder(p);
cout<<endl;
}break;
}
}
這個演算法輸入時要以「#」代表空節點，及將[測試數據] 「ABCффDEфGффFффф」改成「ABC##DE#G##F###」即可。另外我的演算法包括了二叉樹左右子樹交換的代碼「change(bitreptr &p)」，只要樓主稍作修改就可以得到你想要的完美結果~
『捌』 C語言二叉樹的創建和遍歷
我寫了一個二叉樹 你給看看 一定能行的 我自己用了
#include "stdio.h"
#include "malloc.h"
#include "string.h"
#include "stdlib.h"
#define Max 20 //結點的最大個數
typedef struct BinTNode{
char data;
struct BinTNode *lchild,*rchild;
}BinTNode,*BinTree; //自定義二叉樹的結點類型
//定義二叉樹的指針
int NodeNum,leaf; //NodeNum為結點數，leaf為葉子數
//==========以廣義表顯示二叉樹==============
void DisTree(BinTree T)
{
if(T)
{
printf("%c",T->data);
if((T->lchild)||(T->rchild))
{
if(T->lchild)
{
printf("%c",'(');
DisTree(T->lchild);
}
if(T->rchild)
{
printf("%c",',');
DisTree(T->rchild);
printf("%c",')');
}
}
}
}
//==========基於先序遍歷演算法創建二叉樹==============
//=====要求輸入先序序列，其中加入虛結點"#"以示空指針的位置==========
BinTree CreatBinTree(BinTree T)
{
char ch;
ch=getchar();
if(ch=='#')
T=NULL;
else
{
if(!(T=(BinTNode *)malloc(sizeof(BinTNode))))
printf("Error!");
T->data=ch;
T->lchild=CreatBinTree(T->lchild);
T->rchild=CreatBinTree(T->rchild);
}
return T;
}
//========NLR 先序遍歷=============
void Preorder(BinTree T)
{
if(T)
{
printf("%c",T->data);
Preorder(T->lchild);
Preorder(T->rchild);
}
}
//========LNR 中序遍歷===============
void Inorder(BinTree T)
{
if(T){
Inorder(T->lchild);
printf("%c",T->data);
Inorder(T->rchild);
}
}
//==========LRN 後序遍歷============
void Postorder(BinTree T)
{
if(T){
Postorder(T->lchild);
Postorder(T->rchild);
printf("%c",T->data);
}
}
//=====採用後序遍歷求二叉樹的深度、結點數及葉子數的遞歸演算法========
int TreeDepth(BinTree T)
{
int hl,hr,max;
if(T){
hl=TreeDepth(T->lchild); //求左深度
hr=TreeDepth(T->rchild); //求右深度
max=hl>hr? hl:hr; //取左右深度的最大值
NodeNum=NodeNum+1; //求結點數
if(hl==0&&hr==0)
leaf=leaf+1; //若左右深度為0，即為葉子。
return(max+1);
}
else return(0);
}
//====利用"先進先出"（FIFO）隊列，按層次遍歷二叉樹==========
void Levelorder(BinTree T)
{
int front=0,rear=1;
BinTNode *cq[Max],*p; //定義結點的指針數組cq
cq[1]=T; //根入隊
while(front!=rear)
{
front=(front+1)%NodeNum;
p=cq[front]; //出隊
printf("%c",p->data); //出隊，輸出結點的值
if(p->lchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->lchild; //左子樹入隊
}
if(p->rchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->rchild; //右子樹入隊
}
}
}
//==========主函數=================
void main()
{
BinTree T,root;
int i,depth;
printf("\n");
printf("輸入完全二叉樹的先序序列:"); //輸入完全二叉樹的先序序列，
// 用#代表虛結點，如ABD###CE##F##
root=CreatBinTree(T); //創建二叉樹，返回根結點
DisTree(root);
printf("\n");
do //從菜單中選擇遍歷方式，輸入序號。
{
printf("\t********** 菜單 ************\n");
printf("\n");
printf("\t1: 先序遍歷\n");
printf("\t2: 中序遍歷\n");
printf("\t3: 後序遍歷\n");
printf("\t4: 該樹的深度,結點數,葉子數\n");
printf("\t5: 層次遍歷\n"); //按層次遍歷之前，先選擇4，求出該樹的結點數。
printf("\t0: 退出\n");
printf("\t*******************************\n");
scanf("%d",&i);
//輸入菜單序號（0-5）
switch(i)
{
case 1: {printf("Print Bin_tree Preorder: ");
Preorder(root); //先序遍歷
}break;
case 2: {printf("Print Bin_Tree Inorder: ");
Inorder(root); //中序遍歷
}break;
case 3: {printf("Print Bin_Tree Postorder: ");
Postorder(root); //後序遍歷
}break;
case 4: {depth=TreeDepth(root); //求樹的深度及葉子數
printf("樹深=%d 樹總結點數=%d",depth,NodeNum);
printf(" 樹葉子數=%d",leaf);
}break;
case 5: {printf("LevePrint Bin_Tree: ");
Levelorder(root); //按層次遍歷
}break;
default: exit(1);
}
}while(i>=0&&i<6);
}
兄弟你看看 不懂再往下留言 記得給我的勞動成果一點點獎勵哦！！
『玖』 如何用C語言實現層次遍歷二叉樹
下面是c語言的前序遍歷二叉樹的演算法，在這里假設的節點元素值假設的為字元型，
說明：演算法中用到了結構體，也用到了遞歸的方法，你看看怎麼樣，祝你好運！
#include"stdio.h"
typedef
char
elemtype;
typedef
struct
node
//定義鏈表結構
{
elemtype
data;
//定義節點值
struct
note
*lchild;
//定義左子節點值
struct
note
*rchild;
//定義右節點值
}btree;
preorder(btree
*root)
//前序遍歷
{
if(roof!=null)
//如果不是空節點
{
printf("%c\n",root->data);
//輸出當前節點
preorder(root->lchild);
//遞歸前序遍歷左子節點
preorder(root->rchild);
//遞歸前序遍歷右子節點
}
return;
//結束
}
『拾』 C語言二叉樹遍歷程序
先看下creat這個函數:
status creat(bitnode *t)/*先序建立二叉樹*/
{
char ch;
ch=getch();putch(ch);
if(ch=='0') t=NULL;
else
{
t=(bitnode *)malloc(sizeof(bitnode));
if(!t)
exit(OVERFLOW);
t->data=ch;
creat(t->lchild);
creat(t->rchild);
}
return OK;
}
其中有句代碼是t=(bitnode *)malloc(sizeof(bitnode));
這是給t賦值，由於t是參數，這樣做是不能返回的。
我知道你的意思是想通過指針返回，但是那樣的用法應該是對t所指向的變數賦值，也就是對*t賦值。
如果你還沒理解的話看下函數里的遞歸調用：creat(t->lchild);調用函數後，本意是要給t->lchild賦值的，但是是做不到的，因為要改變一個變數的值的話，應該傳的是它的地址。
可能你覺得有點亂了，我舉個函數中用指針做參數來返回的例子：
假如要用指針返回一個整型的變數，那麼指針應該是指向整型變數的，即int*
這里應該是要返回一個struct bitnode *類型的，也就是返回的值就是個指針，那麼參數就應該是一個指向這種指針的指針，即struct bitnode **
可以這么修改：
status creat(bitnode **t) //多了個*
{
char ch;
ch=getch();putch(ch);
if(ch=='0') *t=NULL; //多了個*
else
{
*t=(bitnode *)malloc(sizeof(bitnode)); //多了個*
if(!*t) //多了個*
exit(OVERFLOW);
(*t)->data=ch;
creat(&(*t)->lchild); //注意不同
creat(&(*t)->rchild);
}
return OK;
}
主函數這么改
status main()
{
bitnode* t1; //多了個*
creat(&t1);
pre(t1,print); //少了個&
getch();
return 0;
}
另外一個編譯錯誤就是
int pre(bitnode *t,status (*visit)())
指針函數後面應該帶參數，改為
int pre(bitnode *t,status (*visit)(bitnode *))