1. 求c语言数据结构二叉树的建树，前序遍历，输出树的代码，能用采纳。
#include
#include
#define MAXSIZE 100 //二叉树中最多的结点数
typedef char TElemType;
typedef struct BiTNode
{
TElemType data;
struct 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;
}
2. 二叉树的先序遍历算法------将其用c语言编写程序
void preorder(BiTree T)
{
if(p!=NULL)
{
printf("%c",T->data);
preorder(T->lchild);
preorder(T->rchild);
}
}
3. 数据结构用c语言写：创建树，并进行先序，中序，后序遍历！
#include <iostream>
using namespace std;
class Node
{
public:
Node(){ this->pLchild = this->pRchild = NULL; }
char data;
Node * pLchild;
Node * pRchild;
};
Node * CreateTree()
{
Node * root = new Node;
root->data = 'A';
Node * pB = new Node;
pB->data = 'B';
Node * pC = new Node;
pC->data = 'C';
Node * pD = new Node;
pD->data = 'D';
Node * pE = new Node;
pE->data = 'E';
root->pLchild = pB;
root->pRchild = pC;
pC->pLchild = pD;
pD->pRchild = pE;
return root;
}
void InTraverseTree(Node * pT) //中序遍历
{
if (NULL == pT)
return;
else
{
InTraverseTree(pT->pLchild);
cout << pT->data;
InTraverseTree(pT->pRchild);
}
}
void PostTraverseTree(Node * pT) //后序遍历
{
if (NULL == pT)
return;
else
{
PostTraverseTree(pT->pLchild);
PostTraverseTree(pT->pRchild);
cout << pT->data;
}
}
void PreTraverseTree(Node * pT) //先序遍历
{
if (NULL==pT)
{
return;
}
else
{
cout << pT->data;
PreTraverseTree(pT->pLchild);
PreTraverseTree(pT->pRchild);
}
}
void destroyTree(Node * PT) //销毁二叉树
{
if (NULL == PT)
return;
else
{
destroyTree(PT->pLchild);
destroyTree(PT->pRchild);
delete PT;
}
}
int main()
{
Node * pT = CreateTree();
cout << "先序遍历";
PreTraverseTree(pT);
destroyTree(pT);
/*cout << "\n中序遍历" ;
InTraverseTree(pT);
cout << "\n后序遍历";
PostTraverseTree(pT);*/
// PreTraverseTree(pT);
//cout << endl;
system("pause");
return 0;
}
用C++写的 不过跟C没什么区别
4. c语言实现二叉树的先序,中序,后序的递归和非递归算法和层次遍历算法
#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
}
5. C语言实现左孩子右兄弟树的建立，插入，层次遍历，可以加分
问的有些问题，程序建立的2叉树只能是完全2叉树，其他的树只能手动建立，我这里给你完全2叉树的建立和遍历，完全2叉树是没有插入的，给你函数
#include
#include
typedef
struct
_node_
{
int
data;
struct
_node_
*lchild,*rchild;
}bitree;
//递归建立完全2x树，root每次遍历后都会返回上层树的根节点，这点容易理解错，最终返回的root是整个2x树的根节点，传参int
i
是给2x树赋值：1,2,3,4,5……，int
n是想建立的总共节点数。
bitree
*CreatBitree(int
i,int
n)
{
bitree
*root
=
(bitree*)malloc(sizeof(bitree));
root->data
=
i;
if(i
*
2
<=
n)
root->lchild
=
CreatBitree(2
*
i,n);
else
root->lchild
=
NULL;
if(i
*
2
+
1
<=n)
root
->rchild
=
CreatBitree
(2
*
i
＋1，n）；
else
root->rchild
=
NULL;
return
root;
}
//遍历
void
proorder(bitree*
root)
{
if(root
==
NULL)
return;
printf("%d
",root->data);
proorder(root->lchild);
proorder(root->rchild);
}//这是根左右遍历即前序遍历，如果想改成中序或者后序只需要把printf改到lchild后和rchild后即可
写完才发现你要层次遍历啊？！，那个还要引入个队列的建立，需要建队，出队，入队的函数，全写出来很麻烦的，写2x树的都不是初学了，我假设你已经有了队列相关函数，给出函数功能注释，然后直接给你层次遍历的函数吧：
void
noorder(bitree
*root)
{
sequeue
*sq;//用的顺序队列，没有用链式的，要不更麻烦了，sequeue是typedef的队列结构体
sq
=
CreatEmptySequeue();//建立空队列
EnSequeue(sq,root);//根节点入队
while(!EmptySequeue(sq))//判断队列是否空
{
root
=
Desequeue;//出列
printf("%d",root->data);
if(root->lchild
!=NULL)
EnSequeue(sq,root->lchild);
if(root->rchild
!=
NULL)
EnSequeue(sq
,root->rchild);
}
return;
}
算法描述，
利用队列的先进先出的特性，首先把根节点入队列，然后开始循环，先判断队列是否空，取出队首元素并打印，然后检查出列节点的左节点，有的话入队，没有的话检查右节点，有的话入队，开始下次循环，这时队列里是第二层的左节点和有节点，这次是先打印2层左节点，然后让2层的左孩子节点入队，右孩子入队，然后打印2层右节点，然后2层右节点的左孩子入队，右孩子入队，队列中现在是第3层节点左边依次向右，依次类推，层次打印2x树
看在我折腾了那么多，时隔这么久才有我给答案，分就别吝啬了哈~~~嘿嘿
6. 关于二叉树的建立与前序遍历问题（c语言）
x=getchar();
getchar();你输入的俩位数第二个字符不是“#”， if (x=='#') break;这个是不会结束的，而且底下的程序有问题，p=(struct node*)malloc(sizeof(struct node));
p->data=x;
p->llink=NULL;
p->rlink=NULL;
if (x<p->data) q->llink=p;
else q->rlink=p;
x都付给了p->data,下面还进行比较干嘛？if (x<p->data)。
7. C语言数据结构树的前序遍历算法求指教
首先创建二叉树，个人喜欢用先序次序创建，如
int CreateBiTree(Tree *T)// 按先序次序输入二叉树中结点的值，'#'字符表示空树，构造二叉链表表示的二叉树T
{
char ch;
scanf("%c",&ch);
if (ch=='#') T = NULL;
else {
if (!(T = (Tree *)malloc(sizeof(Tree)))) return ERROR;
T->data=ch; // 生成根结点
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree(T->rchild); // 构造右子树
}
return OK;
}
再者，调用前序遍历函数，再运用输出函数输出前序遍历的二叉树，如：
int Visit(int e ) // 输出元素e的值
{
printf("%c", e );
return OK;
}
int main()
{
Tree *T;
CreateBiTree(T); //调用按先序次序输入二叉树中结点的值（一个字符），构造二叉链
pre_order(T,Visit);//调用前序遍历二叉树算法
}
8. 设计一个c语言程序，实现二叉树的前序、中序、后序的递归、非递归遍历运算
#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("先序递归遍历二叉树： ");
PreOrderTraverse(T,visit); // 先序递归遍历二叉树T
printf("\n中序递归遍历二叉树： ");
InOrderTraverse(T,visit); // 中序递归遍历二叉树T
printf(" \n后序递归遍历二叉树：");
PostOrderTraverse(T,visit); // 后序递归遍历二叉树T
printf("\n");
}