二叉樹演算法c語言代碼

❶ C語言二叉樹遞歸演算法怎麼做

#include<stdio.h>
#include<string.h>

structtreenode{
intvalue;
treenode*left;
treenode*right;
};
typedeftreenode*BiTree;

voidvisit(treenode*node)
{
printf("%2d",node->value);
}

//結點總數
intnode(BiTreeT)
{
if(!T){
return0;
}
returnnode(T->left)+node(T->right)+1;
}

//前序
voidpreOrder(BiTreeT)
{
if(T){
visit(T);
preOrder(T->left);
preOrder(T->right);
吵盯}
}

//中序
voidinOrder(BiTreeT)
{
if(T){
inOrder(T->left);
液枝visit(T);
inOrder(T->right);
升埋和}
}

//後序
voidpostOrder(BiTreeT)
{
if(T){
postOrder(T->left);
postOrder(T->right);
visit(T);
}
}

//葉子節點數
intleafnode(BiTreeT)
{
if(T){
if(!T->left&&!T->right)
return1;
else
leafnode(T->left)+leafnode(T->right);
}else{
return0;
}
}

intheight(BiTreeT)
{
if(T){
intlh=height(T->left);
intrh=height(T->right);
return(lh>rh?lh:rh)+1;
}else{
return0;
}
}

intmain()
{


return0;
}

❷ 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
#include
#define MAXSIZE 100 //二叉樹中最多的結點數
typedef char TElemType;
typedef struct BiTNode
{
TElemType data;

BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//定義函數指針
typedef void(* Visit)(BiTree);
//二叉樹的初始化
void Init_BiTree(BiTree *T)
{
*T = NULL;
}
//判斷二叉樹是否為空,返回1
int IsEmpty_BiTree(BiTree *T)
{

return *T == NULL;
}
//創建二叉樹
void Create_BiTree(BiTree *T)
{
char ch;
ch = getchar();
//當輸入的是"#"時，認為該子樹為空

if(ch == '#')

*T = NULL;
//創建樹結點
else{

*T = (BiTree)malloc(sizeof(BiTNode));

(*T)->data = ch; //生成樹結點
//生成左子樹
Create_BiTree(&(*T)->lchild);

//生成右子樹
Create_BiTree(&(*T)->rchild);

}
}
//輸出結點的值
void Print_BiTreeNode(BiTree T)
{
printf("%c\t",T->data);

}
//先序遍歷二叉樹
void PreOrder_BiTree(BiTree T,Visit visit)
{
if(!IsEmpty_BiTree(&T))
{
visit(T);

PreOrder_BiTree(T->lchild,visit);
PreOrder_BiTree(T->rchild,visit);

}
}
int main(){
BiTree T;
//將二叉樹初始為一個空的二叉樹
Init_BiTree(&T);
//創建二叉樹
Create_BiTree(&T);
//先序遍歷
printf("\n先序遍歷結果：");
PreOrder_BiTree(T,Print_BiTreeNode);
return 0;
}

❹ 二叉樹的C語言程序求教

typedef char DataType;//給char起個別名 DataType

//定義二叉樹的數據結構
typedef struct node{
DataType data;//二叉樹存儲的數據
struct node *lchild, *rchild;//二叉樹的左、右子樹的指針
}BinTNode;

typedef BinTNode *BinTree ; //自定義一個數據類型（二叉樹的指針類型）
#include <stdio.h>
#include <malloc.h>

//以前棗纖埋序遍歷構建二叉樹
void CreatBinTree(BinTree *T)
{
char ch;//定義臨時變數ch，用來接受數據
if ((ch=getchar())==' ')
*T=NULL;//如果輸入為空，則停止構建二叉樹
else{*T=(BinTNode *)malloc(sizeof(BinTNode));//為二叉樹分配內存空間
(*T)->data=ch;//豎皮把輸入的數據存入二叉樹
CreatBinTree(&(*T)->lchild);//構建左子樹（遞歸）
CreatBinTree(&(*T)->rchild);//構建左子樹（遞歸）
}
}

//求二叉樹的結點數
int Node(BinTree T)
{ int static nodes=0;//定義一個變數存儲二叉樹的結點數
if(T)//如果二叉樹不為空（是結點），執行此語句
{
Node(T->lchild);//看左子樹是不是個結點（遞歸）
nodes++;//結點數加1
Node(T->rchild);//看右子樹是不是個結點（遞歸）
}
return nodes;//返回結點數
}

//求二叉樹的葉子數
int Leaf(BinTree T)
{ int static leaves=0;//定義一個變數存儲二叉樹的葉子數
if(T)//如果二叉樹不為空，執行此語句
{
Leaf(T->lchild);//看凳螞左子樹是不是葉子（遞歸）
if(!(T->lchild||T->rchild))//如果二叉樹T的左、右結點都為空，則執行此語句（即是葉子）
leaves++;//葉子數加1
Leaf(T->rchild);//看右子樹是不是葉子（遞歸）
}
return leaves;//返回葉子數
}

#include <stdio.h>
void main()
{ BinTree root;
CreatBinTree(&root);//構建二叉樹
int nodes=Node(root);//求此二叉樹的結點數
int leaves=Leaf(root);//求此二叉樹的葉子數
printf("\nnodes=%d leaves=%d",nodes,leaves);
}

上面是我的理解，好久沒有寫過代碼了，如有錯誤，請指出。

❺ 求數據結構（C語言版）建立二叉樹的代碼~~急~~謝謝了

BT.H文件
#include
<stdio.h>
#include
<malloc.h>
#include
<conio.h>
#define
TRUE
1
#define
FALSE
0
#define
ERROR
0
#define
OK
1
#define
Stack_Size
50
#define
NUM
50
#define
MAXSIZE
50
//隊列的最大長度
//定義二叉樹
typedef
char
DataType;
typedef
struct
Node
{
DataType
data;
struct
Node
*LChild;
struct
Node
*RChild;
}BiTNode,
*BiTree;
//定義stack
typedef
BiTree
StackElementType;
typedef
struct
{
StackElementType
elem[Stack_Size];
int
top;
}SeqStack;
//定義隊列
typedef
BiTree
QueueElementType;
typedef
struct
{
QueueElementType
element[MAXSIZE];
int
front;
int
rear;
}SeqQueue;
//隊列的抽象
void
InitQueue(SeqQueue
*Q)
{
Q->front=Q->rear=0;
}
int
EnterQueue(SeqQueue
*Q,
QueueElementType
x)
{
if((Q->rear+1)%MAXSIZE==Q->front)
return(FALSE);
Q->element[Q->rear]=x;
Q->rear=(Q->rear+1)%MAXSIZE;
return(TRUE);
}

❻ 求代碼——二叉樹——要C語言的

#include <stdio.h>
#include <stdlib.h>
#define STACK_MAX_SIZE 30
#define QUEUE_MAX_SIZE 30
#ifndef elemType
typedef char elemType;
#endif
/************************************************************************/
/* 以下是關於二叉樹操作的11個簡單演算法 */
/************************************************************************/
struct BTreeNode{
elemType data;
struct BTreeNode *left;
struct BTreeNode *right;
};

/* 1.初始化二叉樹 */
void initBTree(struct BTreeNode* *bt)
{
*bt = NULL;
return;
}

/* 2.建立山枝迅二叉樹(根據a所指向的二叉樹廣義表字元串建立) */
void createBTree(struct BTreeNode* *bt, char *a)
{
struct BTreeNode *p;
struct BTreeNode *s[STACK_MAX_SIZE];/* 定義s數組為存儲根結點指針的棧使用 */
int top = -1; /* 定義top作為s棧的棧頂指針，初值為-1,表示空棧 */
int k; /* 用k作為處理結點的左子樹和右子樹，k = 1處理左子樹，k = 2處理右子樹 */
int i = 0; /* 用i掃描數組a中存儲的二叉樹廣義表字元串，初值為0 */
*bt = NULL; /* 把樹根指針置為空，即從空樹開始建立二叉樹 */
/* 每循環一次處理一個字元，直到掃描到字元串結束符\0為止 */
while(a[i] != '\0'){
switch(a[i]){
case ' ':
break; /* 對空格不作任何處理 */
case '(':
if(top == STACK_MAX_SIZE - 1){
printf("棧空間太小！\n");
exit(1);
}
top++;
s[top] = p;
k = 1;
break;
case ')':
if(top == -1){
printf("二叉樹廣義表字元串錯誤!\n");
exit(1);
}
top--;
break;
case ',':
k = 2;
break;
default:
p = (BTreeNode *)malloc(sizeof(struct BTreeNode));
p->data = a[i];
p->left = p->逗此right = NULL;
if(*bt == NULL){
*bt = p;
}else{
if( k == 1){
s[top]->left = p;
}else{
s[top]->right = p;
}
}
}
i++; /* 為掃描下一個字元修改i值搭芹 */
}
return;
}

/* 3.檢查二叉樹是否為空，為空則返回1,否則返回0 */
int emptyBTree(struct BTreeNode *bt)
{
if(bt == NULL){
return 1;
}else{
return 0;
}
}

/* 4.求二叉樹深度 */
int BTreeDepth(struct BTreeNode *bt)
{
if(bt == NULL){
return 0; /* 對於空樹，返回0結束遞歸 */
}else{
int dep1 = BTreeDepth(bt->left); /* 計算左子樹的深度 */
int dep2 = BTreeDepth(bt->right); /* 計算右子樹的深度 */
if(dep1 > dep2){
return dep1 + 1;
}else{
return dep2 + 1;
}
}
}

/* 5.從二叉樹中查找值為x的結點，若存在則返回元素存儲位置，否則返回空值 */
elemType *findBTree(struct BTreeNode *bt, elemType x)
{
if(bt == NULL){
return NULL;
}else{
if(bt->data == x){
return &(bt->data);
}else{ /* 分別向左右子樹遞歸查找 */
elemType *p;
if(p = findBTree(bt->left, x)){
return p;
}
if(p = findBTree(bt->right, x)){
return p;
}
return NULL;
}
}
}

/* 6.輸出二叉樹(前序遍歷) */
void printBTree(struct BTreeNode *bt)
{
/* 樹為空時結束遞歸，否則執行如下操作 */
if(bt != NULL){
printf("%c", bt->data); /* 輸出根結點的值 */
if(bt->left != NULL || bt->right != NULL){
printf("(");
printBTree(bt->left);
if(bt->right != NULL){
printf(",");
}
printBTree(bt->right);
printf(")");
}
}
return;
}

/* 7.清除二叉樹，使之變為一棵空樹 */
void clearBTree(struct BTreeNode* *bt)
{
if(*bt != NULL){
clearBTree(&((*bt)->left));
clearBTree(&((*bt)->right));
free(*bt);
*bt = NULL;
}
return;
}

/* 8.前序遍歷 */
void preOrder(struct BTreeNode *bt)
{
if(bt != NULL){
printf("%c ", bt->data); /* 訪問根結點 */
preOrder(bt->left); /* 前序遍歷左子樹 */
preOrder(bt->right); /* 前序遍歷右子樹 */
}
return;
}

/* 9.前序遍歷 */
void inOrder(struct BTreeNode *bt)
{
if(bt != NULL){
inOrder(bt->left); /* 中序遍歷左子樹 */
printf("%c ", bt->data); /* 訪問根結點 */
inOrder(bt->right); /* 中序遍歷右子樹 */
}
return;
}

/* 10.後序遍歷 */
void postOrder(struct BTreeNode *bt)
{
if(bt != NULL){
postOrder(bt->left); /* 後序遍歷左子樹 */
postOrder(bt->right); /* 後序遍歷右子樹 */
printf("%c ", bt->data); /* 訪問根結點 */
}
return;
}

/* 11.按層遍歷 */
void levelOrder(struct BTreeNode *bt)
{
struct BTreeNode *p;
struct BTreeNode *q[QUEUE_MAX_SIZE];
int front = 0, rear = 0;
/* 將樹根指針進隊 */
if(bt != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = bt;
}
while(front != rear){ /* 隊列非空 */
front = (front + 1) % QUEUE_MAX_SIZE; /* 使隊首指針指向隊首元素 */
p = q[front];
printf("%c ", p->data);
/* 若結點存在左孩子，則左孩子結點指針進隊 */
if(p->left != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = p->left;
}
/* 若結點存在右孩子，則右孩子結點指針進隊 */
if(p->right != NULL){
rear = (rear + 1) % QUEUE_MAX_SIZE;
q[rear] = p->right;
}
}
return;
}

/************************************************************************/

int main(int argc, char *argv[])
{
struct BTreeNode *bt; /* 指向二叉樹根結點的指針 */
char *b; /* 用於存入二叉樹廣義表的字元串 */
elemType x, *px;
initBTree(&bt);
printf("輸入二叉樹廣義表的字元串：\n");
/* scanf("%s", b); */
b = "a(b(c), d(e(f, g), h(, i)))";
createBTree(&bt, b);
if(bt != NULL)
printf(" %c ", bt->data);
printf("以廣義表的形式輸出：\n");
printBTree(bt); /* 以廣義表的形式輸出二叉樹 */
printf("\n");
printf("前序："); /* 前序遍歷 */
preOrder(bt);
printf("\n");
printf("中序："); /* 中序遍歷 */
inOrder(bt);
printf("\n");
printf("後序："); /* 後序遍歷 */
postOrder(bt);
printf("\n");
printf("按層："); /* 按層遍歷 */
levelOrder(bt);
printf("\n");
/* 從二叉樹中查找一個元素結點 */
printf("輸入一個待查找的字元：\n");
scanf(" %c", &x); /* 格式串中的空格跳過空白字元 */
px = findBTree(bt, x);
if(px){
printf("查找成功：%c\n", *px);
}else{
printf("查找失敗！\n");
}
printf("二叉樹的深度為：");
printf("%d\n", BTreeDepth(bt));
clearBTree(&bt);
return 0;
}

❼ 用c語言寫二叉樹，源代碼。

//定義結構體
typedef struct btnode
{
char data;
struct btnode *lchild,*rchild;
}*bitreptr;
//建立二叉樹
void create_btr(bitreptr t)
{
getchar();
if(x=='#')
t=NULL;
else
{
p=new node;
p->data=x;
t=p;
create_btr(t->lchild);
create_btr(t->rchild);
}
}
//中序遍歷二叉樹
void inorder(bitreptr p)
{
if(p)
{
inorder(p->lchild);//訪問左子樹
printf("%c",p->data);//訪問根節點
inorder(p->rchild);//訪問右子樹
}
}
其他的細節你內自己去完善，我就寫到這里容了