‘壹’ 请问c语言如何创建二叉树
创建二叉树的源程序如下：
#include <cstdlib>
#include <stdio.h>
typedef struct node
{ //树的结点
int data;
struct node* left;
struct node* right;
} Node;
typedef struct
{ //树根
Node* root；
} Tree;
void insert(Tree* tree, int value)//创建树
{
Node* node=(Node*)malloc(sizeof(Node));//创建一个节点
node->data = value;
node->left = NULL;
node->right = NULL;
if (tree->root == NULL)//判断树是不是空树
{
tree->root = node;
}
else
{//不是空树
Node* temp = tree->root;//从树根开始
while (temp != NULL)
{
if (value < temp->data)//小于就进左儿子
{
if (temp->left == NULL)
{
temp->left = node;
return;
}
else
{//继续判断
temp = temp->left;
}
}
else {//否则进右儿子
if (temp->right == NULL)
{
temp->right = node;
return;
}
else {//继续判断
temp = temp->right;
}
}
}
}
return；
}
void inorder(Node* node)//树的中序遍历
{
if (node != NULL)
{
inorder(node->left);
printf("%d ",node->data);
inorder(node->right);
}
}
int main()
{
Tree tree;
tree.root = NULL;//创建一个空树
int n;
scanf("%d",&n);
for (int i = 0; i < n; i++)//输入n个数并创建这个树
{
int temp;
scanf("%d",&temp);
insert(&tree, temp);
}
inorder(tree.root);//中序遍历
getchar();
getchar();
return 0;
}
(1)c语言实现根树扩展阅读：
简单二叉树定义范例：此树的顺序结构为：ABCDE
#include <cstdlib>
#include <stdio.h>
#include <string>
int main()
{
node* p = newnode;
node* p = head;
head = p;
string str;
cin >> str;
creat(p, str, 0)//默认根结点在str下标0的位置
return 0;
}
//p为树的根结点（已开辟动态内存）,str为二叉树的顺序存储数组ABCD##E或其他顺序存储数组，r当前结点所在顺序存储数组位置
void creat(node* p, string str, int r)
{
p->data = str[r];
if (str[r * 2 + 1] == '#' || r * 2 + 1 > str.size() - 1)p->lch = NULL；
else
{
p->lch = newnode;
creat(p->lch, str, r * 2 + 1);
}
if (str[r * 2 + 2] == '#' || r * 2 + 2 > str.size() - 1)p->rch = NULL;
else
{
p->rch = newnode;
creat(p->rch, str, r * 2 + 2);
}
}
‘贰’ 看了半天用c语言实现二叉树的建立与遍历，居然没看懂。
如何建立二叉树,为了方便理解中递推法
案例1:
#Include <stdio.h>
#include <stdlib.h>
struct Data{
int num;
struct Data* left; // 左节点指针
struct Data* right; // 右节点指针
};
typedef struct Data Data;
// 创建节点
Data* create_node(int data){
Data *node = (Data*)malloc(sizeof(Data));
node->left = NULL;
node->right = NULL;
node->num = data;
return node;
};
// 给二叉树有序地插入节点
bool insert_node(Data *root, int data){
while(1){
if(data == root->num){
return false;
}
else if(data > root->num){ // 如果输入的数值 大于 当前根节点的数值，就插入当前根节点的右边
if(root->right == NULL){ // 如果当前根的右节点指针为空就插入
root->right = create_node(data);
return true;
}else{ // 如果当前根的右节点指针不为空就继续遍历下一个根
root = root->right;
}
}
esle if(data < root->num){
// 如果输入的数值 小于 当前根节点的数值, 就插入当前根节点的左端
if(root->left == NULL){ //如果当前根的左节点指针为空就插入
root->left = create_node(data);
return true;
}else{ // 如果当前根的左节点不为空，就继续变量下一个根
root = root->left;
}
}
}
}
int main(){
Data *root = NULL;
while(1){
int num;
printf("请输入数值:");
scanf("%d",&num);
if(num < 0)break; // 如果输入的是负数就退出循环
if(root == NULL){
root = create_node(num); // 创建父树根
}else{
if(!insert_node(root)){ // 向二叉树添加节点
printf("插入失败\n");
}
}
}
}
‘叁’ 用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语言实现二叉树的程序，可以输入输出和遍历
#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>
typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
}
BiTNode,*BiTree;//定义结点类型
BiTree CreateBiTree()//创建树
{
char p;BiTree T;
scanf("%c",&p);
if(p==' ')
T=NULL;
else
{
T=(BiTNode *)malloc(sizeof(BiTNode));//为结点开辟空间
T->data=p;
T->lchild=CreateBiTree();
T->rchild=CreateBiTree();
}
return (T);
}
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()//主函数
{
BiTree Ta;
Ta=CreateBiTree();
printf("先序遍历:");
printf("\n");
PreOrder(Ta);
printf("\n");
printf("中序遍历:");
printf("\n");
InOrder(Ta);
printf("\n");
printf("后序遍历:");
printf("\n");
PostOrder(Ta);
}
给你个简单的例子：
AB***
其中*代表空格
复杂点的例子
ABC**DE*f**g***
其中*代表空格
‘陆’ 建立一棵二叉树，编程实现求从根节点到给定节点之间的路径 C语言
它的算法思想应该是
1，以一指针指向该叶子结点并向上（父结点）找，把父节点入栈（方便输出路径）
2，把指针指向父节点，重复上面的过程，直到节点的父节点为空
3，依次出栈输出信息，路径就出来了
（注：此二叉树的节点应包括父指针，左右指针，数据域）
就这么多吧！ 要学习程序，就得自己尝试写，写多了就会了
还有什么不懂的可以给我留言 ！！
‘柒’ 用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<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语言版
# include <stdio.h>
# include <malloc.h>
struct BTNode
{
int data;
struct BTNode * pLchild;//p是指针，L是左，child是孩子
struct BTNode * pRchild;
};
//函数声明
struct BTNode * CreateBTree(void);//创建树
void PreTraverseBTree(struct BTNode * pT);//先序遍历
void InTraverseBTree(struct BTNode * pT);//中序遍历
void PostTraverseBTree(struct BTNode * pT);//后续遍历
int main(void)
{
struct BTNode * pT = CreateBTree();
PreTraverseBTree(pT);
printf("\n");
InTraverseBTree(pT);
printf("\n");
PostTraverseBTree(pT);
return 0;
}
//创建树
struct BTNode * CreateBTree(void)
{
struct BTNode * pA = (struct BTNode * )malloc(sizeof(BTNode));
struct BTNode * pB = (struct BTNode * )malloc(sizeof(BTNode));
struct BTNode * pC = (struct BTNode * )malloc(sizeof(BTNode));
struct BTNode * pD = (struct BTNode * )malloc(sizeof(BTNode));
struct BTNode * pE = (struct BTNode * )malloc(sizeof(BTNode));
pA->data = 'A';
pB->data = 'B';
pC->data = 'C';
pD->data = 'D';
pE->data = 'E';
pA->pLchild = pB;
pA->pRchild = pC;
pB->pLchild = NULL;
pB->pRchild = NULL;
pC->pLchild = pD;
pC->pRchild = NULL;
pD->pLchild = NULL;
pD->pRchild = pE;
pE->pLchild = NULL;
pE->pRchild = NULL;
return pA;
}
//先序遍历
void PreTraverseBTree(struct BTNode * pT)
{ //先访问根节点，再先序访问左子树，最后先序访问右子树
if ( pT != NULL)
{
printf("%c\n",pT->data);//访问根节点
//pT->pLchild可以代表整个左子树
PreTraverseBTree(pT->pLchild);
PreTraverseBTree(pT->pRchild);
}
return;
}
//中序遍历
void InTraverseBTree(struct BTNode * pT)
{
if(pT != NULL )
{
if (NULL != pT->pLchild)
{
InTraverseBTree(pT->pLchild);
}
printf("%c\n",pT->data);
if (NULL != pT->pRchild)
{
InTraverseBTree(pT->pRchild);
}
}
return;
}
//后续遍历
void PostTraverseBTree(struct BTNode * pT)
{
if(pT != NULL )
{
if (NULL != pT->pLchild)
{
PostTraverseBTree(pT->pLchild);
}
if (NULL != pT->pRchild)
{
PostTraverseBTree(pT->pRchild);
}
printf("%c\n",pT->data);
}
return;
}
‘拾’ 二叉树怎样用C语言实现
以下代码可实现二叉树的递归创建与中序遍历，但在输入时需在输入完有效数据后再连续输入多个负数才可以。
#include <stdio.h>
#include <stdlib.h>
typedef struct BitNode
{
int data;
struct BitNode *lchile,*rchild;
}*BiTree;
BiTree CreateBiTree(BiTree &T)
{
int d;
scanf("%d",&d);
if (d<0)
return NULL;
else
{
if (!(T=(BiTree)malloc(sizeof(BiTree))))
{
exit(1);
}
T->data=d;//先根序创建二叉树
printf("%d ",T->data);
T->lchile=CreateBiTree(T->lchile);//创建左子树
T->rchild=CreateBiTree(T->rchild);//创建右子树
return T;
}
}
void InOrderView(BiTree &T)//中序遍历二叉树
{
if(T)
{
InOrderView(T->lchile);
printf("%d ",T->data);
InOrderView(T->rchild);
}
}
void main()
{
BiTree T;
T=CreateBiTree(T);//递归创建二叉树
InOrderView(T);
}