c语言求二叉树的宽度
1. c语言 二叉树
#include<stdio.h>
#include<stdlib.h>
typedef struct Node
{
int e;
struct Node *l, *r;
} Node;
Node *init() //先序遍历构造二叉树
{
char n;
Node *p;
scanf("%c", &n);
if (n=='0')
return NULL;
p = (Node*)malloc(sizeof(Node));
if (!p)
exit(0);
p->e = n-'0';
p->l = init();
p->r = init();
return p;
}
void DLR(Node *head) //先序遍历二叉树（递归算法）
{
if (head)
{
printf("%d", head->e);
DLR(head->l);
DLR(head->r);
}
}
void destory(Node *head) //销毁二叉树
{
Node *l, *r;
if (!head)
return;
l = head->l;
r = head->r;
free(head);
destory(l);
destory(r);
}
int main()
{
Node *head = init();
DLR(head);
destory(head);
return 0;
}
2. 求一份 c语言 求二叉树的宽度（后序遍历）
二叉树的宽度是如何定义的，你这不说一下？
3. 计算机c语言中 什么是二叉树
在计算机科学中，二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。
二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的 i -1次方个结点；深度为k的二叉树至多有2^(k) -1个结点；对任何一棵二叉树T，如果其终端结点数(即叶子结点数)为n0，度为2的结点数为n2，则n0 = n2 + 1。
树是由一个或多个结点组成的有限集合，其中：
⒈必有一个特定的称为根(ROOT)的结点；二叉树
⒉剩下的结点被分成n>=0个互不相交的集合T1、T2、......Tn，而且， 这些集合的每一个又都是树。树T1、T2、......Tn被称作根的子树(Subtree)。
树的递归定义如下：（1）至少有一个结点（称为根）（2）其它是互不相交的子树
1.树的度——也即是宽度，简单地说，就是结点的分支数。以组成该树各结点中最大的度作为该树的度，如上图的树，其度为2;树中度为零的结点称为叶结点或终端结点。树中度不为零的结点称为分枝结点或非终端结点。除根结点外的分枝结点统称为内部结点。
2.树的深度——组成该树各结点的最大层次。
3.森林——指若干棵互不相交的树的集合，如上图，去掉根结点A，其原来的二棵子树T1、T2、T3的集合{T1,T2,T3}就为森林；
4.有序树——指树中同层结点从左到右有次序排列，它们之间的次序不能互换，这样的树称为有序树，否则称为无序树。
4. 求二叉树的深度(深度优先)用栈
int BiTreeDepth( btnode * b)
{
struct
{
int lno;//保存结点的层数
btnode * p;
}Q[MAXSIZE];//建立队列
int front,rear;
int lnum;
front=rear=0;
if(b!=NULL)
{
rear++;
Q[rear].p=b;
Q[rear].lno=1;
while(rear!=front)
{
front++;
b=Q[front].p;
lnum=Q[front].lno;
if(b->lchild!=NULL)
{
rear++;
Q[rear].p=b->lchild;
Q[rear].lno=lnum+1;
}
if(b->rchild!=NULL)
{
rear++;
Q[rear].p=b->rchild ;
Q[rear].lno=lnum+1;
}
}
}
return Q[rear].lno;
}
这是我的实验程序，我的btnode相当于你的TNode，你可以自己修改一下哈。这段程序很有用的，它建立一个队列，并且给每个树的结点编上了层号，如果你把这个队列进行出队输出，输出的为树按层次遍历的序列。当然也可以用这个程序求二叉树的宽度：
int btwidth(btnode *b)//求二叉树的宽度
{
struct
{
int lno;//保存结点的层数
btnode * p;
}Q[MAXSIZE];//建立队列
int front,rear;
int lnum,max,i,n;
front=rear=0;
if(b!=NULL)
{
rear++;
Q[rear].p=b;
Q[rear].lno=1;
while(rear!=front)
{
front++;
b=Q[front].p;
lnum=Q[front].lno;
if(b->lchild!=NULL)
{
rear++;
Q[rear].p=b->lchild;
Q[rear].lno=lnum+1;
}
if(b->rchild!=NULL)
{
rear++;
Q[rear].p=b->rchild ;
Q[rear].lno=lnum+1;
}
}
max=0;
lnum=1;
i=1;
while(i<=rear)//此时rear等于二叉树结点的个数
{
n=0;
while(i<=rear&&Q[i].lno==lnum)
{
n++;
i++;
}
lnum=Q[i].lno;
if(n>max)//求结点数最多的一层结点的个数
max=n;
}
return max;
}
else
return 0;
}
希望对你有所帮助，相互讨论，呵呵
至于用栈实现，我还在调试中，^_^
5. C语言二叉树
在create_tree中，参数t只在一开始被bintree初始化，此时他们同时指向未初始化的内存。当执行到t=(tree * )malloc(sizeof(tree));时候，t被赋予了新的内存空间，注意，这里新分配的内存仅仅是分配给了t，与bintree没有关系。每次进入create_tree后都为局部变量t分配内存，而你在函数退出之后无法进行内存回收，进而造成内存泄露。
正确的做法是，给create_tree传递一个指针类型的引用，tree *&t，这样你在操作t的时候就像在操作bintree一样，才能达到给bintree分配内存的目的。
最后别忘了写一个释放内存的方法：
void free_tree(tree *t)
{
if (t)
{
free_tree(t->lchild);
free_tree(t->rchild);
printf("\n%c has freed.", t->data);
free(t);
}
}
6. 用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");
}
7. 二叉树的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);
}
上面是我的理解，好久没有写过代码了，如有错误，请指出。
8. c语言中二叉树个数计算方法
递归……非空树的总结点数=左子树结点数+右子树结点数+1（也就是根结点）。
伪代码：
int
node_counter(TreeNode
*root)
{
if
(root==null)
return
0;
else
return
node_counter(root->left)
+
node_counter(root->right)
+
1;
}
9. C语言二叉树的深度指什么怎么求
从根节点到叶子结点一次经过的结点形成树的一条路径，最长路径的长度为树的深度。根节点的深度为1。
解体思路：
1.如果根节点为空，则深度为0，返回0，递归的出口。
2.如果根节点不为空，那么深度至少为1，然后我们求他们左右子树的深度，
3.比较左右子树深度值，返回较大的那一个
4.通过递归调用
#include<iostream>
#include<stdlib.h>
usingnamespacestd;
structBinaryTreeNode
{
intm_nValue;
BinaryTreeNode*m_pLeft;
BinaryTreeNode*m_pRight;
};
//创建二叉树结点
BinaryTreeNode*CreateBinaryTreeNode(intvalue)
{
BinaryTreeNode*pNode=newBinaryTreeNode();
pNode->m_nValue=value;
pNode->m_pLeft=NULL;
pNode->m_pRight=NULL;
returnpNode;
}
//连接二叉树结点
voidConnectTreeNodes(BinaryTreeNode*pParent,BinaryTreeNode*pLeft,BinaryTreeNode*pRight)
{
if(pParent!=NULL)
{
pParent->m_pLeft=pLeft;
pParent->m_pRight=pRight;
}
}
//求二叉树深度
intTreeDepth(BinaryTreeNode*pRoot)//计算二叉树深度
{
if(pRoot==NULL)//如果pRoot为NULL，则深度为0，这也是递归的返回条件
return0;
//如果pRoot不为NULL，那么深度至少为1，所以left和right=1
intleft=1;
intright=1;
left+=TreeDepth(pRoot->m_pLeft);//求出左子树的深度
right+=TreeDepth(pRoot->m_pRight);//求出右子树深度
returnleft>right?left:right;//返回深度较大的那一个
}
voidmain()
{
//1
///
//23
///\
//456
///
//7
//创建树结点
BinaryTreeNode*pNode1=CreateBinaryTreeNode(1);
BinaryTreeNode*pNode2=CreateBinaryTreeNode(2);
BinaryTreeNode*pNode3=CreateBinaryTreeNode(3);
BinaryTreeNode*pNode4=CreateBinaryTreeNode(4);
BinaryTreeNode*pNode5=CreateBinaryTreeNode(5);
BinaryTreeNode*pNode6=CreateBinaryTreeNode(6);
BinaryTreeNode*pNode7=CreateBinaryTreeNode(7);
//连接树结点
ConnectTreeNodes(pNode1,pNode2,pNode3);
ConnectTreeNodes(pNode2,pNode4,pNode5);
ConnectTreeNodes(pNode3,NULL,pNode6);
ConnectTreeNodes(pNode5,pNode7,NULL);
intdepth=TreeDepth(pNode1);
cout<<depth<<endl;
system("pause");
}
出处：http://www.cnblogs.com/xwdreamer
10. 数据结构C语言求二叉树宽度
void没有返回a的值，主函数输出的值就是你定义的a=0的值