二叉樹編程實例

① 二叉樹問題編程

#include <stdio.h>
#include <stdlib.h>

typedef struct BiTNode{
char data;
struct BiTNode *Lchild,*Rchild;
}BiTNode,*BiTree;
//創建二拍絕數叉樹
void CreateBiTree(BiTree &T)
{
char ch;
scanf("%c",&ch);
if(ch==' ')T=NULL;
else
{
T=(BiTNode *)malloc(sizeof(BiTNode));
T->data=ch;
CreateBiTree(T->Lchild);
CreateBiTree(T->Rchild);
}
}
//求二叉樹的高度
int BiTreeHeight(BiTree &T)
{
int l=0,r=0;
if(T->Lchild)
l=BiTreeHeight(T->Lchild)+1;
if(T->Rchild)
r=BiTreeHeight(T->Rchild)+1;
if(T->Lchild==NULL && T->Rchild==NULL)
l=1;
if(l>=r)
return l;
else return r;
}
//求二叉樹的結點個數
int All_BiTNode(BiTree &T)
{
int i=0;
if(T==NULL)
return 0;
else i=All_BiTNode(T->Lchild)+All_BiTNode(T->Rchild)+1;
return i;
}
//求二叉樹出度為0的結點個數
int Out0_BitNode(BiTree &T)
{
int i=0;
if(T==NULL)
return 0;
else if(T->Lchild==NULL && T->Rchild==NULL)
i++;
else i=Out0_BitNode(T->Lchild)+Out0_BitNode(T->Rchild);
return i;
}
//求二叉樹出度為1的結點個數
int Out1_BitNode(BiTree &T)
{
int i=0;
if(T==NULL)
return 0;
else
{
i=Out1_BitNode(T->Lchild)+Out1_BitNode(T->Rchild);
if(T->Lchild==NULL && T->Rchild ||T->Lchild && T->Rchild==NULL)
i++;
}

return i;
}
/宏清/求二叉樹出度為2的結點個數
int Out2_BitNode(BiTree &T)
{
int i=0;
if(T==NULL)
return 0;
else
{
i=Out2_BitNode(T->Lchild)+Out2_BitNode(T->Rchild);
if(T->Lchild && T->Rchild)
i++;
}
return i;
}
//復制二叉樹襲首
BiTree Copy_BiTree(BiTree &T)
{
BiTree _T;
if(T)
{
_T=(BiTNode *)malloc(sizeof(BiTNode));
_T->data=T->data;
_T->Lchild=Copy_BiTree(T->Lchild);
_T->Rchild=Copy_BiTree(T->Rchild);
}
else return NULL;
return _T;
}
//交換二叉樹的左右子樹
BiTree Exchange_Left_Right(BiTree &T)
{
BiTree p;
if(T==NULL)
return T;
else
{
p=Exchange_Left_Right(T->Lchild);
T->Lchild=Exchange_Left_Right(T->Rchild);
T->Rchild=p;
}
return T;
}
//判斷兩棵樹相似
int BiTree_Resemble(BiTree &T1,BiTree &T2)
{
int l,r;
if(T1==NULL && T2==NULL)
return 1;
else if(T1==NULL && T2 || T1 && T2==NULL)
return 0;
l=BiTree_Resemble(T1->Lchild,T2->Lchild);
r=BiTree_Resemble(T1->Rchild,T2->Rchild);
if(l==1 && r==1)
return 1;
else
return 0;
}

void main()
{
char clear;
int i=0;
BiTree T,T2,_T;
CreateBiTree(T);
scanf("%c",&clear);
CreateBiTree(T2);
scanf("%c",&clear);
/* printf("二叉樹的高度為：%d\n",BiTreeHeight(T));
printf("總結點個數為：%d\n",All_BiTNode(T));
printf("度數為0的結點個數為：%d\n",Out0_BitNode(T));
printf("度數為1的結點個數為：%d\n",Out1_BitNode(T));
printf("度數為2的結點個數為：%d\n",Out2_BitNode(T));
_T=Copy_BiTree(T);
*/
i=BiTree_Resemble(T,T2);
if(i==1)
printf("相似\n");
else printf("不相似\n");
}

② 用C語言編程實現二叉樹的基本操作，並完成下述函數功能： (1) CreateBiTree( )：根據先序遍歷序列生成一棵

下面有一個建樹的例子。
class TreeNode{
public:
TreeNode *left;
TreeNode *right;
int value;
TreeNode(int v): value(v)
{
left = NULL;
right = NULL;
}
~TreeNode() {
if (left != NULL) delete left;
if (right != NULL) delete right;
}
};

void addToTree(TreeNode *curr, TreeNode *p) {
if(p->value <= curr->value) {
if(curr->left == NULL) {
curr->left = p;
return;
}
else addToTree(curr->left, p);
} else {
if(curr->right == NULL) {
curr->right = p;
return;
}
else addToTree(curr->right, p);
}
}
void printTree(TreeNode *p) {
if(p==NULL) return;
printTree(p->left);
printf("%d ", p->value);
printTree(p->right);
}
TreeNode * createBiTree(int[] a, int len)
{
TreeNode *root = new TreeNode(a[0]);
for(int i=1; i<5; i++) {
TreeNode *p = new TreeNode(a[i]);
addToTree(root, p);
}
return root;
}

void main() {
int a[] = {3, 4, 1, 2, 5};
CreateBiTeee(a, 5);
printTree(root);
delete root;
}

③ 用c語言實現二叉樹的程序，可以輸入輸出和遍歷

#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>

const int MaxLength=10;//結點個數不超過10個

typedef struct tree
{
char data;
struct tree *lchild,*rchild;
}tree;
//先序遞歸 建立二叉樹
void Createbitree(tree* &T)
{
char ch;
ch=getchar();
if(ch=='#')
T=NULL;
else
{
T=(tree*)malloc(sizeof(tree));
T->data =ch;
Createbitree(T->lchild );
Createbitree(T->rchild );
}
}
//先序遞歸遍歷
void PreOrderTraverse(tree* T)
{
if(T)
{
cout<<T->data;
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
//中序遞歸遍歷
void InOrderTraverse(tree* T)
{
if(T)
{
InOrderTraverse(T->lchild);
cout<<T->data;
InOrderTraverse(T->rchild);
}
}
void PostOrderTraverse(tree* T)
{
if(T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data;
}
}
//層序遍歷
void LevelOrderTraverse(tree* T)
{
tree* Q[MaxLength];
int front=0,rear=0;
tree* p;
if(T)//根結點入隊
{
Q[rear]=T;
rear=(rear+1)%MaxLength;
}
while(front!=rear)
{
p=Q[front]; //隊頭元素出隊
front=(front+1)%MaxLength;
cout<<p->data;
if(p->lchild)//左孩子不為空，入隊
{
Q[rear]=p->lchild;
rear=(rear+1)%MaxLength;
}
if(p->rchild)//右孩子不為空，入隊
{
Q[rear]=p->rchild;
rear=(rear+1)%MaxLength;
}
}
}
//主函數
void main()
{
cout<<"請按先序次序輸入二叉樹的數據:"<<endl;
tree* T;
Createbitree(T);
cout<<"二叉樹的先序序列為:"<<endl;
PreOrderTraverse(T);
cout<<endl<<"二叉樹的中序序列為:"<<endl;
InOrderTraverse(T);
cout<<endl<<"二叉樹的後序序列為:"<<endl;
PostOrderTraverse(T);
cout<<endl<<"二叉樹的層序序列為:"<<endl;
LevelOrderTraverse(T);
cout<<endl;
}
比如 1
2 3
4 5 6 7
按先序輸入是124##5##36##7##

④ C語言編程題建立二叉樹

#include<stdio.h>
#include<stdlib.h>

#define ERROR 0
#define OK 1
#define OVERFLOW -2
#define FLASE 0
#define TURE 1

typedef int Status;
typedef char TElemType;

typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild,*rchild;//左右孩子指針
}BiTNode,*BiTree;

//構造一個二叉樹
Status CreateBiTree(BiTree &T){
TElemType str[]="ABC$$D$EF$$G$$$";

static int i=0;

TElemType ch;
ch=str[i++];

if(ch=='$')
T=NULL;
else{
//創建樹結點雀汪
T=(BiTNode*)malloc(sizeof(BiTNode));
if(!T) exit(OVERFLOW);
T->data=ch;

//創建左子樹
CreateBiTree(T->頃戚仔lchild);

//創建右子樹
CreateBiTree(T->rchild);
}

return OK;
}

//輸出元素data
Status PrntTElem(TElemType data){
putchar(data);

return OK;
}

//先序遍歷二叉樹
Status PreOrderTraverse(BiTree T,Status(*visit)(TElemType e)){
if(T){
if((*visit)(T->data))
if(PreOrderTraverse(T->lchild,visit))
if(PreOrderTraverse(T->rchild,visit))
return OK;
return ERROR;
}
else return OK;
}

/仔世/中序遍歷二叉樹
Status InOrderTraverse(BiTree T,撣袱側惶乇耗岔同唱括Status(*visit)(TElemType e)){
if(T){
if(InOrderTraverse(T->lchild,visit))
if(visit(T->data))
if(InOrderTraverse(T->rchild,visit))
return OK;
return ERROR;
}
else return OK;
}

//後序遍歷二叉樹
Status PostOrderTraverse(BiTree T,Status(*visit)(TElemType e)){
if(T){
if(PostOrderTraverse(T->lchild,visit))
if(PostOrderTraverse(T->rchild,visit))
if(visit(T->data))
return OK;
return ERROR;
}
else return OK;
}

/ /求二叉樹深度
int BiTreeDepth(BiTree T){
int ldep=0,rdep=0;
if(T==NULL)
return 0;
ldep=BiTreeDepth(T->lchild);
rdep=BiTreeDepth(T->rchild);
if(ldep>=rdep)
return ldep+1;
else
return rdep+1;
}
//求葉子數
int BiTreeLeaves(BiTree T){
if(!T)
return 0;
else if(!T->lchild&&!T->rchild)
return 1;
else
return BiTreeLeaves(T->lchild)+BiTreeLeaves(T->rchild);
}

//銷毀
int DestroyBiTree(BiTree &T){
if(T){
if(DestroyBiTree(T->lchild))
if(DestroyBiTree(T->rchild))
T=NULL;
}
return OK;
}

void main()
{
BiTree T;

CreateBiTree(T);

printf("先序結果為:");
PreOrderTraverse(T,PrntTElem);

printf("\n中序結果為:");
InOrderTraverse(T,PrntTElem);

printf("\n後序結果為:");
PostOrderTraverse(T,PrntTElem);

printf("\n二叉樹的深度為: %d\n",BiTreeDepth(T));

printf("葉子數為: %d\n",BiTreeLeaves(T));

DestroyBiTree(T);

printf("先序結果為:");
PreOrderTraverse(T,PrntTElem);

printf("\n中序結果為:");
InOrderTraverse(T,PrntTElem);

printf("\n後序結果為:");
PostOrderTraverse(T,PrntTElem);

printf("\n");
}

⑤ 數據結構二叉樹的程序，用c語言怎麼實現

您好，想哪鏈手要實現一個二叉樹，需要用到結構體來存儲每個節點的信息，並使用指針來存儲每個節點的左右子節點的地址。具體的實現方法喚物可以參考下面的代碼示例：

#include <stdio.h>

#include <stdlib.h>

struct TreeNode {

int val;

struct TreeNode *left;

struct TreeNode *right;

};

struct TreeNode* createNode(int val) {

struct TreeNode* node = (struct TreeNode*) malloc(sizeof(struct TreeNode));

node->val = val;

node->left = NULL;

node->right = NULL;

return node;

}

void insertNode(struct TreeNode* root, int val) {

if (root == NULL) {

return;

}

if (val < root->李嫌val) {

if (root->left == NULL) {

root->left = createNode(val);

} else {

insertNode(root->left, val);

}

} else {

if (root->right == NULL) {

root->right = createNode(val);

} else {

insertNode(root->right, val);

}

}

}

void printTree(struct TreeNode* root) {

if (root == NULL) {

return;

}

printf("%d ", root->val);

printTree(root->left);

printTree(root->right);

}

int main() {

struct TreeNode* root = createNode(5);

insertNode(root, 3);

insertNode(root, 2);

insertNode(root, 4);

insertNode(root, 7);

insertNode(root, 6);

insertNode(root, 8);

printTree(root);

return 0;

}

在這段代碼中，我們定義了一個結構體 TreeNode 來表示二叉樹的每個節點，結構體中包含了一個節點的數值 val，以及指向左子節點和右子節點的指針 left 和 right。

⑥ 編寫一個程序，實現二叉樹的先序遍歷，中序遍歷，後序遍歷的各種遞歸和非遞歸演算法，以及層次遍歷的演算法

文件 main.cpp 代碼如下：

#include<malloc.h> // malloc()等
#include<stdio.h> // 標准輸入輸出頭文件，包括EOF(=^Z或F6)，NULL等
#include<stdlib.h> // atoi()，exit()
#include<math.h> // 數學函數頭文件，包括floor()，ceil()，abs()等

#define ClearBiTree DestroyBiTree // 清空二叉樹和銷毀二叉樹的操作一樣

typedef struct BiTNode
{
int data; // 結點的值
BiTNode *lchild,*rchild; // 左右孩子指針
}BiTNode,*BiTree;

int Nil=0; // 設咐凱整型以0為空
void visit(int e)
{ printf("%d ",e); // 以整型格式輸出
}
void InitBiTree(BiTree &T)
{ // 操作結果：構造空二叉樹T
T=NULL;
}

void CreateBiTree(BiTree &T)
{ // 演算法6.4：按先序次序輸入二叉樹中結點的值(可為字元型或整型，在主程中定義)，
// 構造二叉鏈表表示的二叉樹T。變數Nil表示空(子)樹。修改
int number;
scanf("%d",&number); // 輸入結點的值
if(number==Nil) // 結點鎮簡中的值為空
T=NULL;
else // 結點的值不為空
{ T=(BiTree)malloc(sizeof(BiTNode)); // 生成根結點
if(!T)
exit(OVERFLOW);
T->data=number; // 將值賦給T所指結點
CreateBiTree(T->lchild); // 遞歸構造左子樹
CreateBiTree(T->rchild); // 遞歸構造右子樹
}
}

void DestroyBiTree(BiTree &T)
{ // 初始條件：二叉樹T存在。操作結果：銷毀二叉樹T
if(T) // 非空樹
{ DestroyBiTree(T->lchild); // 遞歸銷毀左子樹，如無左子樹，則不執行任何操作
DestroyBiTree(T->rchild); // 遞歸銷毀右子樹，如無御山右子樹，則不執行任何操作
free(T); // 釋放根結點
T=NULL; // 空指針賦0
}
}

void PreOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數。修改演算法6.1
// 操作結果：先序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T) // T不空
{ Visit(T->data); // 先訪問根結點
PreOrderTraverse(T->lchild,Visit); // 再先序遍歷左子樹
PreOrderTraverse(T->rchild,Visit); // 最後先序遍歷右子樹
}
}

void InOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數
// 操作結果：中序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T)
{ InOrderTraverse(T->lchild,Visit); // 先中序遍歷左子樹
Visit(T->data); // 再訪問根結點
InOrderTraverse(T->rchild,Visit); // 最後中序遍歷右子樹
}
}

void PostOrderTraverse(BiTree T,void(*Visit)(int))
{ // 初始條件：二叉樹T存在，Visit是對結點操作的應用函數
// 操作結果：後序遞歸遍歷T，對每個結點調用函數Visit一次且僅一次
if(T) // T不空
{ PostOrderTraverse(T->lchild,Visit); // 先後序遍歷左子樹
PostOrderTraverse(T->rchild,Visit); // 再後序遍歷右子樹
Visit(T->data); // 最後訪問根結點
}
}

void main()
{
BiTree T;
InitBiTree(T); // 初始化二叉樹T
printf("按先序次序輸入二叉樹中結點的值,輸入0表示節點為空，輸入範例：1 2 0 0 3 0 0\n");
CreateBiTree(T); // 建立二叉樹T
printf("先序遞歸遍歷二叉樹：\n");
PreOrderTraverse(T,visit); // 先序遞歸遍歷二叉樹T
printf("\n中序遞歸遍歷二叉樹：\n");
InOrderTraverse(T,visit); // 中序遞歸遍歷二叉樹T
printf("\n後序遞歸遍歷二叉樹：\n");
PostOrderTraverse(T,visit); // 後序遞歸遍歷二叉樹T
}
這樣可以么？

⑦ 用C++寫一個二叉樹的程序

#include <stdio.h>
#include <stdlib.h>
typedef struct {
char data;
int weight;
} bitree_data_t;

typedef struct bitree
{
bitree_data_t data;
struct bitree *lchild, *rchild;
}bitree_t;

typedef bitree_t * data_t;
typedef struct linknode {
data_t data;
struct linknode *next;
}linknode_t, linkstack_t, linklist_t;

//創建一個鏈表
//1. 在內存總開辟頭結點的空間malloc
//2. 將頭結點的next域置空NULL
//3. 返回創建並設置好的鏈表的首地址
linklist_t *create_linklist()
{
linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));
node->next = NULL;

return node;
}

//判斷當前鏈表是否為空
int empty_linklist(linklist_t *ll)
{
return ll->next == NULL;
}
//求鏈表中當前有效元素的個數
int length_linklist(linklist_t *ll)
{
int length = 0;
while(ll->next != NULL)
{
ll = ll->next;
length++;
}

return length;
}
//獲得下標為index位置的元素，成功返回0，失敗返回-1
//1. 判斷index是否合法(部分判斷)
//2. 在保證ll->next 不為空的清空下，將ll的首地址向後移動index次
//3. 判斷ll->next 是否等於空，如果等於空，則返回-1，如果不為空，執行4.
//4. 當移動了index次之後，當前ll->next 的位置的節點就保存了我要獲得的
//數據
//5. *data = ll->next->data;
//6. 返回0
int get_linklist(linklist_t *ll, int index, data_t *data)
{
int i;
if(index < 0)
return -1;

for(i = 0; ll->next != NULL && i < index; i++)
{
ll = ll->next;
}

if(ll->next == NULL)
return -1;

*data = ll->next->data;
return 0;
}
//使用頭插法插入一個元素
//1. 創建一個節點node
//2. 將要插入的數據保存到node
//3. 執行插入操作
//4. 返回0
int insert_linklist(linklist_t *ll, data_t *data)
{
linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));
node->data = *data;

node->next = ll->next;
ll->next = node;
return 0;
}
//刪除鏈表中的一個節點:刪除頭結點的後一個位置(頭刪法)
//首先可以判斷當前鏈表是否為空，如果為空返回-1
//如果不為空則刪除頭結點的下一個位置的節點
//最後返回0
int delete_linklist(linklist_t *ll)
{
linknode_t *node;
if(empty_linklist(ll))
return -1;
node = ll->早鋒猛next;
ll->next = node->next;
free(node);

return 0;
}
//清空鏈表
//循環刪除鏈表的一個節點，然後判斷刪除函數的返回值是否為0
/陸橋/如果為0，繼續刪除，如果為-1則停止循環
int clear_linklist(linklist_t *ll)
{
while(delete_linklist(ll) == 0);
return 0;
}
/基做/銷毀鏈表
//1. 調用清空操作清空鏈表
//2. 刪除頭結點
//3. 返回0
int detory_linklist(linklist_t *ll)
{
clear_linklist(ll);
free(ll);
return 0;
}

void preorder(bitree_t *root)
{
if(root == NULL)
return ;
printf("[%c,%d]", root->data.data, root->data.weight);
preorder(root->lchild);
preorder(root->rchild);

return;
}

int insert_order_linklist(linklist_t *ll, data_t *data)
{
linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));
node->data = *data;
while(ll->next != NULL && ll->next->data->data.weight < node->data->data.weight)
{
ll = ll->next;
}

node->next = ll->next;
ll->next = node;

return 0;
}

bitree_t *huffman_bitree(linklist_t *ll)
{
bitree_t *node1, *node2, *root;
while(ll->next != NULL && ll->next->next != NULL)
{
get_linklist(ll, 0, &node1);
delete_linklist(ll);
get_linklist(ll, 0, &node2);
delete_linklist(ll);

root = (bitree_t *)malloc(sizeof(bitree_t));
root->data.data = '#';
root->data.weight = node1->data.weight + node2->data.weight;
root->lchild = node1;
root->rchild = node2;
insert_order_linklist(ll, &root);
}
get_linklist(ll, 0, &root);
delete_linklist(ll);

return root;
}

int main(void)
{
bitree_data_t data;
bitree_t *leaf;
linklist_t *ll;
ll = create_linklist();

while(scanf("[%c,%d]", &data.data, &data.weight) == 2)
{
getchar();

leaf = (bitree_t *)malloc(sizeof(bitree_t));
leaf->lchild = leaf->rchild = NULL;
leaf->data = data;
insert_order_linklist(ll, &leaf);
}
leaf = huffman_bitree(ll);
preorder(leaf);
putchar(10);
return 0;
}

⑧ 二叉樹c語言實現

#include<iostream.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct node {
char data;
struct node *lchild,*rchild;//
}BiTNode,*BiTree;
void CreatBiTree(BiTree &T)
{
char ch;
ch=getchar();
if (ch == ' ')
T = 0;
else {
T=(BiTNode*)malloc(sizeof(BiTNode));
T->data=ch;//生成根節點
CreatBiTree(T->lchild);//構造左子樹
CreatBiTree(T->rchild);//構造右子樹
}
}
void preorder(BiTree T)//前序遍歷
{
if (T!=NULL){
printf ("%c",T->data);
preorder(T->lchild);
preorder(T->rchild);
}
}
void inorder(BiTree T)//中序遍歷
{
if (T!=NULL){
inorder(T->lchild);
printf ("%c",T->data);
inorder(T->rchild);
}
}
void postorder(BiTree T)//後序遍歷
{
if (T!=NULL){
postorder(T->lchild);
postorder(T->rchild);
printf ("%c",T->data);
}
}
void main ()
{
cout<<"請輸入要創建的二叉樹包括空格:"<<endl ;
BiTree T;
CreatBiTree(T);//創建二叉樹
cout<<"前序遍歷的結果為:"<<endl;
preorder(T);
cout<<endl;
cout<<"中序遍歷的結果為:"<<endl;
inorder(T);
cout<<endl;
cout<<"後序遍歷的結果為:"<<endl;
postorder(T);
}

⑨ 用C語言編程 ：建立三層二叉樹，先根遍歷輸出，在線求高手

A
(B C)
(D E) (F G)

以這課樹為例

#include <stdio.h>
#include <stdlib.h>

typedef char Elem;

typedef struct Node
{
Elem data;
struct Node *pLchild;
struct Node *pRchild;
}BTreeNode, *BTree;

BTree CreateBTree(BTree T, Elem *str)//創建二叉樹旅塌
{
static int i = 0;

if ('0' == str[i])
{
T = NULL;
}
else
{
T = (BTree) malloc (sizeof(BTreeNode));
T->data = str[i++];

T->pLchild = CreateBTree(T->pLchild, str);
i++;
T->pRchild = CreateBTree(T->pRchild, str);
}

return T;
}

void PostTraverseBTree(BTree T)//後序
{
if (NULL != T)
{
PostTraverseBTree(T->pLchild);
PostTraverseBTree(T->pRchild);
printf("%c ", T->data);
}
}

void InTraverseBTree(BTree T)//中序
{
if (NULL != T)
{
InTraverseBTree(T->pLchild);
printf("%c ", T->data);
InTraverseBTree(T->pRchild);
}
}

void PreTraverseBTree(BTree T)//拆返圓先序
{
if (NULL != T)
{
printf("%c ", T->data);
PreTraverseBTree(T->pLchild);
PreTraverseBTree(T->pRchild);
}
}

int main(void)
{
BTree T = NULL;

Elem str[] = "ABD00E00CF00G00";

T = CreateBTree(T, str);
printf("\n\n");

printf("先世嫌序遍歷:\n");
PreTraverseBTree(T);
printf("\n\n");

printf("中序遍歷:\n");
InTraverseBTree(T);
printf("\n\n");

printf("後序遍歷:\n");
PostTraverseBTree(T);
printf("\n\n");
}

⑩ 用C語言編寫程序，創建一個二叉樹的二叉鏈表結構，然後輸出從根結點到所有葉子結點的路徑。

#include
#include
#include
typedef
struct
node
{
char
data;
struct
node
*lchild;
struct
node
*rchild;
}tnode;
tnode
*createtree()
{
tnode
*t;
char
ch;
ch=getchar();
if(ch=='0')
t=null;
else
{
t=(tnode
*)malloc(sizeof(tnode));
t->data=ch;
t->lchild=createtree();
t->rchild=createtree();
}
return
t;
}
void
listtree(tnode
*t)
{
if
(t!=null)
{
printf("%c",t->data);
if(t->lchild!=null||t->rchild!=null)
{
printf("(");
listtree(t->lchild);
if(t->rchild!=null)
printf(",");
listtree(t->rchild);
printf(")");
}
}
}
void
inorder(tnode
*t)
{
if(t!=null)
{
inorder(t->lchild);
printf("%c\t",t->data);
inorder(t->rchild);
}
}
void
leve(tnode
*t)
{
tnode
*quee[100];
int
front,rear;
front=-1;
rear=0;
quee[rear]=t;
while(front!=rear)
{
front++;
printf("%c\t",quee[front]->data);
if(quee[front]->lchild!=null)
{
rear++;
quee[rear]=quee[front]->lchild;
}
if(quee[front]->rchild!=null)
{
rear++;
quee[rear]=quee[front]->rchild;
}
}
}
main()
{
tnode
*t=null;
printf("請輸入二叉樹元素：");
t=createtree();
printf("廣義表的輸出：");
listtree(t);
printf("喊敗\n");
printf("二叉樹的中序遍歷：");
inorder(t);
printf("\n");
printf("二叉樹的層滾滲滾次遍歷：");
leve(t);
printf("\n");
system("pause"大余);
}
/*
輸入：ab00cd00e00f000
輸出：a(b,c((d,e))
中序遍歷：
b
a
d
c
e
層次遍歷：a
b
c
d
e
*/