二叉树c语言打印

‘壹’ 用c语言实现二叉排序树排序，并按递减顺序打印各个数据

#include <stdio.h>
#include <malloc.h>
typedef int KeyType;
typedef char InfoType[10];
typedef struct node //记录类型
{
KeyType key; //关键字项
InfoType data; //其他数据域
struct node *lchild,*rchild; //左右孩子指针
} BSTNode;
int InsertBST(BSTNode *&p,KeyType k)
{
if (p==NULL) //原树为空, 新插入的记录为根结点
{
p=(BSTNode *)malloc(sizeof(BSTNode));
p->key=k;
p->lchild=p->rchild=NULL;
return 1;
}
else if (k==p->key) //树中存在相同关键字的结点,返回0
return 0;
else if (k<p->key)
return InsertBST(p->lchild,k); //插入到*p的左子树中
else
return InsertBST(p->rchild,k); //插入到*p的右子树中
}
BSTNode *CreateBST(KeyType A[],int n) //返回BST树根结点指针
{
BSTNode *bt=NULL; //初始时bt为空树
int i=0;
while (i<n)
{
InsertBST(bt,A[i]); //将关键字A[i]插入二叉排序树T中
i++;
}
return bt; //返回建立的二叉排序树的根指针
}

void DispInDescrease(BSTNode *bt){ //按从小到大输出查找树中的内容，对该树中序遍历即可
if(bt){
DispInDescrease(bt->lchild);
printf("%d\t",bt->key);
DispInDescrease(bt->rchild);
}
}
void main()
{
BSTNode *bt,*p,*f;
int n=9;
KeyType a[]={1,12,5,8,3,10,7,13,9};
bt=CreateBST(a,n);
DispInDescrease(bt);
}
//已上机验证成功

‘贰’ c语言广义表形式输入二叉树，从下到上按层打印改树； 不知道哪错了，请各位大侠帮帮忙！

太长了 懒得看 给你看我的把
#include "stdio.h"
#include "malloc.h"
#define MaxSize 20

typedef struct tnode
{
int data;
struct tnode *lchild,*rchild;
}BTNode;

//建立二叉树运算算法
void CreatBTree(BTNode *&bt,char *str)
{
BTNode *St[MaxSize],*p=NULL;
int top=-1,k,j=0;
char ch;
bt=NULL; //建立的二叉树初始化时为空
ch=str[0];
while(ch!='\0')
{
switch(ch)
{
case '(': top++;St[top]=p;k=1;break; //为左孩子结点
case ')': top--;break;
case ',': k=2;break; //为右孩子结点
default : p=(BTNode *)malloc(sizeof(BTNode));
p->data =ch;p->lchild =p->rchild =NULL;
if(bt==NULL) //p为二叉树的根结点
bt=p;
else //已建立二叉树根结点
{
switch(k)
{
case 1: St[top]->lchild =p;break;
case 2: St[top]->rchild =p;break;
}
}
}
j++;ch=str[j];
}
}
//求二叉树高度运算算法(递归法)
int BTHeight(BTNode *bt)
{
int lchilddep,rchilddep;
if(bt==NULL) //空树高度为0
return 0;
else
{
lchilddep=BTHeight(bt->lchild);//求左子树的高度
rchilddep=BTHeight(bt->rchild);//求右子树的高度
return (lchilddep>rchilddep)?(lchilddep+1):(rchilddep+1);
}
}
//求二叉树结点个数运算算法(递归法)
int NodeCount(BTNode *bt)
{
int num1,num2;
if(bt==NULL) //空树结点个数为0
return 0;
else
{
num1=NodeCount(bt->lchild ); //求出左子树的结点树
num2=NodeCount(bt->rchild ); //求出右子树的结点树
return (num1+num2+1);
}
}
//求二叉树叶子结点个数运算算法(递归法)
int LeafCount(BTNode *bt)
{
int num1,num2;
if(bt==NULL)
return 0; //空树叶子结点个数为0
else if(bt->lchild ==NULL&&bt->rchild ==NULL)
return 1; //若为叶子结点返回1
else
{
num1=LeafCount(bt->lchild ); //求出左子树的叶子结点树
num2=LeafCount(bt->rchild ); //求出右子树的叶子结点树
return num1+num2;
}
}
//以括号表示法输出二叉树运算算法(递归法)
void DispBTree(BTNode *bt)
{
if(bt!=NULL)
{
printf("%c",bt->data);
if(bt->lchild !=NULL || bt->rchild!=NULL)
{
printf("(");
DispBTree(bt->lchild ); //以递归法处理左子树
if(bt->rchild !=NULL)
printf(",");
DispBTree(bt->rchild ); //以递归法处理右子树
printf(")");
}
}
}

//先序遍历
void PreOrder(BTNode *bt)
{
if(bt!=NULL)
{
printf("%c",bt->data );
PreOrder(bt->lchild );
PreOrder(bt->rchild );
}
}

//中序遍历
void InOrder(BTNode *bt)
{
if(bt!=NULL)
{
InOrder(bt->lchild );
printf("%c",bt->data );
InOrder(bt->rchild );
}
}

//后序遍历
void PostOrder(BTNode *bt)
{
if(bt!=NULL)
{
PostOrder(bt->lchild );
PostOrder(bt->rchild );
printf("%c",bt->data );
}
}
int main() //主函数
{
BTNode *bt;
CreatBTree(bt,"A(B(D,E(G,H),C(,F(I)))");
printf("二叉数bt以括号法显示为: "); DispBTree(bt);printf("\n");
printf("先序发遍历二叉数bt为: "); PreOrder(bt); printf("\n");
printf("中序发遍历二叉数bt为: "); InOrder(bt); printf("\n");
printf("后序发遍历二叉数bt为: "); PostOrder(bt); printf("\n");
printf("二叉数bt的高度为： %d\n", BTHeight(bt));
printf("二叉数bt的结点数为： %d\n", NodeCount(bt));
printf("二叉数bt的叶子结点数为： %d\n", LeafCount(bt));
printf("\n");
return 0;
}

‘叁’ 用C语言 输出二叉树，要求输出树的形状。 PrintTree（BiTree T，int level）

typedef struct _BinaryTree_
{
ElementType Element;
struct _BinaryTree_ * Left;
struct _BinaryTree_ * Right;
}BiTree;

void PrintTree(BiTree* T,int level)
{
if(level)
{
printf((*T).Element);
if((*T).Left!=NULL)
PrintTree((*T).Left,level--);
if((*T).Right!=NULL)
PrintTree((*T).Right,level--);
}
}

‘肆’ 数据结构二叉树问题，PreorderSearch(T1,k,s）之后怎么用C语言打印出s（倒数第7行）

#include<stdio.h>
#include<malloc.h>
#defineM10
typedefstructbnode
{
	chardata;
	structbnode*lchild;
	structbnode*rchild;
}Bnode,*BTree;

/*建立二叉树*/
voidcreat_BTree(BTree*T)
{
	charn;
	n=getchar();
	if(n=='#')	*T=NULL;
	elseif(n=='
')return;
else
	{
		(*T)=(BTree)malloc(sizeof(Bnode));
		(*T)->data=n;
		creat_BTree(&(*T)->lchild);
		creat_BTree(&(*T)->rchild);
	}
}
/*前序遍历*/
voidr_preorder(BTreeT)
{
	if(T)
	{

		printf("%c",T->data);
		r_preorder(T->lchild);
		r_preorder(T->rchild);
	}
}
/*后序遍历*/
voidr_posorder(BTreeT)
{
	if(T)
	{
		r_posorder(T->lchild);
		r_posorder(T->rchild);
		printf("%c",T->data);
	}
}
/*层次遍历*/
voidr_levelorder(BTreeT)
{
BTreeq[1024];
BTreep;
intfront=0,rear=0;
if(T)
{
q[rear]=T;
rear=(rear+1)%M;
}
while(front!=rear)
{
p=q[front];
printf("%c",p->data);
if(p->lchild)
{
q[rear]=p->lchild;
rear=(rear+1)%M;
}
if(p->rchild)
{
q[rear]=p->rchild;
rear=(rear+1)%M;
}
front=front+1;
}
}

intmain()
{
	BTreeT;
	T=NULL;
	intselect;	
	while(1)
	{
	printf("
请选择要进行的操作：
");
	printf("1创建二叉树
");
	printf("2前序遍历
");
	printf("3后序遍历
");
	printf("4层次遍历
");
	printf("5结束程序
");
	printf("=========================
");
	scanf("%d",&select);
getchar();
	switch(select)
	{
	case1:
		{
			printf("请按前序次序输入各结点的值，以#表示空树（输入时可连续输入）
");
			creat_BTree(&T);
			break;
		}
	case2:
		{
			if(!T)printf("未建树，请先执行1操作建树！
");
			elser_preorder(T);
			break;
		}
	case3:
		{
			if(!T)printf("未建树，请先执行1操作建树！
");
			elser_posorder(T);
			break;
		}
	case4:
		{
			if(!T)printf("未建树，请先执行1操作建树！
");
			elser_levelorder(T);
			break;
		}
	default:;
}
}
}

‘伍’ c语言数组实现二叉树的问题，怎么把二叉树按顺序打印出来。

#include<stdio.h> #include<stdlib.h> struct BiTNode *stack[100]; struct BiTNode//定义结构体 { char data; struct BiTNode *lchild,*rchild; }; void later(struct BiTNode *&p) //前序创建树 { char ch; scanf("%c",&ch); if(ch==' ') p=NULL; else { p=(struct BiTNode *)malloc(sizeof(struct BiTNode)); p->data=ch; later(p->lchild); later(p->rchild); } } void print(struct BiTNode *p) //前序遍历（输出二叉树） { int i=-1; while(1) { while(p!=NULL) { stack[++i]=p->rchild;/*printf("ok？\n");*/ printf("%c",p->data); p=p->lchild; } if(i!=-1) { p=stack[i]; i--; } else return; } } void main()//主函数 { struct BiTNode *p,*t; later(p); print(p); }

‘陆’ 用数据结构(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 = 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语言写二叉树，源代码。

二叉树是采用递归定义的，实现起来代码简洁（也许并不简单）。并且它在具体的计算机科学中有很重要的运用，是一种很重要的数据结构，二叉树有三种遍历和建立的方式。今天先学习一下它的建立和打印。
以下代码在Win-Tc1.9.1下编译通过。

#include <stdio.h>
#define ElemType char
//节点声明，数据域、左孩子指针、右孩子指针
typedef struct BiTNode{
char data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//先序建立二叉树
BiTree CreateBiTree(){
char ch;
BiTree T;
scanf("%c",&ch);
if(ch=='#')T=NULL;
else{
T = (BiTree)malloc(sizeof(BiTNode));
T->data = ch;
T->lchild = CreateBiTree();
T->rchild = CreateBiTree();
}
return T;//返回根节点
}
//先序遍历二叉树
void PreOrderTraverse(BiTree T){
if(T){
printf("%c",T->data);
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}

//中序遍历
void InOrderTraverse(BiTree T){
if(T){
PreOrderTraverse(T->lchild);
printf("%c",T->data);
PreOrderTraverse(T->rchild);
}
}
//后序遍历
void PostOrderTraverse(BiTree T){
if(T){
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
printf("%c",T->data);
}
}
void main(){
BiTree T;
T = CreateBiTree();//建立
PreOrderTraverse(T);//输出
getch();
}

‘捌’ c语言如何打印二叉树，打印出二叉树的形状！！！！

classnode
{
public:
charch;
structnode*l,*r;
node(charc,node*lchild,node*rchild):ch(c),l(lchild),r(rchild){}
};
voidspace(intn)
{
for(inti=0;i<n;i++)
cout<<'';
}
/*以
*右子树
*根
*左子树
*的形式打印
*/
voidprint(node*T,intn)
{
if(!T)return;
print(T->r,n+2);
space(n);
cout<<T->ch<<endl;
print(T->l,n+2);
}
intmain()
{
node*T=newnode('A',
newnode('B',NULL,NULL),
newnode('C',
newnode('D',NULL,NULL),
newnode('E',NULL,NULL)));

print(T,0);
}