A. 关于c语言二叉树
完全二叉树除了第一层和最后一层外,其余各层的结点数都是2的幂,所以都是偶数,因此,当最后一层的结点数为偶数时,树的总结点数才可能是奇数.
而完全二叉树只有最后一层的结点数为奇数时,树中才可能存在唯一的度为1的结点,即最后一个结点的父结点.但现在最后一层结点数为偶数,所以树中不存在度为1的结点,即n1=0.
所以n=n0+n2=2n0-1=699,n0=350
B. 关于C语言二叉树
首先二叉树的结点是由做孩子指针*lchild 右孩子指针*rchild 以及数据成员data
L表示左孩子R表示右孩子T表示他们的父结点
后序遍历的访问顺序是LRT
中序遍历的访问顺序是LTR
前序遍历的访问顺序是TLR
其中说的前中后就是指访问父结点的次序；
拓扑图在这里没法给出啊。。。
--------------------------------------------
这是我用C++类写的二叉树的头文件，里面有几个函数你可能用不到，你主要看看那几个遍历函数
#include<iostream>
using namespace std;
typedef char elemType;
struct bnode
{
bnode *lchild,*rchild;
elemType data;
};
class BinaryTree
{
public:
BinaryTree();
void create(bnode* &tempR);
void visite(bnode *T);
void preorder(bnode *T);
void inorder(bnode *T);
void postorder(bnode *T);
int high(bnode *T);
void convert(bnode* &tempR,string &a,int i);
void (bnode *T,bnode *&T1);
void level(bnode *T,int i);
void swap(bnode *T);
bnode *root;
private:
int count;
};
BinaryTree::BinaryTree()
{
root = NULL;
count = 0;
}
void BinaryTree::create(bnode* &tempR)
{
elemType x;
cin>>x;
if(x == '.')
{
tempR = NULL;
}
else
{
tempR = new bnode;
count++;
tempR->data = x;
create(tempR->lchild);
create(tempR->rchild);
}
}
void BinaryTree::visite(bnode *T)
{
if(T!=NULL)
cout<<T->data<<' ';
}
void BinaryTree::preorder(bnode *T)
{
if(T!=NULL)
{
visite(T);
preorder(T->lchild);
preorder(T->rchild);
}
}
void BinaryTree::inorder(bnode *T)
{
if(T!=NULL)
{
inorder(T->lchild);
visite(T);
inorder(T->rchild);
}
}
void BinaryTree::postorder(bnode *T)
{
if(T!=NULL)
{
postorder(T->lchild);
postorder(T->rchild);
visite(T);
}
}
int BinaryTree::high(bnode *T)
{
if(T==NULL)
return 0;
else if(high(T->lchild)>high(T->rchild))
return high(T->lchild)+1;
else
return high(T->rchild)+1;
}
void BinaryTree::level(bnode *T,int i)
{
if(T!=NULL)
{
level(T->lchild,i+1);
visite(T);
cout<<i<<' ';
level(T->rchild,i+1);
}
}
void BinaryTree::convert(bnode *&T,string &a,int i)
{
elemType x;
if(i<=a.length())
{
x = a[i-1];
T = new bnode;
count++;
T->data = x;
convert(T->lchild,a,2*i);
convert(T->rchild,a,2*i+1);
}
else
{
T=NULL;
}
}
void BinaryTree::(bnode *T,bnode *&T1)
{
elemType x;
if(T!=NULL)
{
x=T->data;
if(x == '.')
{
T1 = NULL;
}
else
{
T1 = new bnode;
T1->data = x;
T1->lchild = NULL;
T1->rchild = NULL;
(T->lchild,T1->lchild);
(T->rchild,T1->rchild);
}
}
}
void BinaryTree::swap(bnode *T)
{
if(T!=NULL)
{
bnode *temp;
temp=T->lchild;
T->lchild=T->rchild;
T->rchild=temp;
swap(T->lchild);
swap(T->rchild);
}
}
C. 在线等~C语言，二叉树2
先根据先序和中序创建二叉树，然后层次遍历输出，网络了一下，相关代码做一个链接吧，具体还是要自己写的。
根据先序和中序创建二叉树代码参考：
http://blog.csdn.net/hinyunsin/article/details/6315502
层次遍历
http://www.sharejs.com/codes/cpp/5558
voidLevelOrder(BTNode*b)
{
BTNode*p;
BTNode*qu[MaxSize];
intfront,rear;
front=rear=-1;
rear++;
qu[rear]=b;
while(front!=rear)
{
front=(front+1)%MaxSize;
p=qu[front];
printf("%c",p->data);
if(p->lchild!=NULL)
{
rear=(rear+1)%MaxSize;
qu[rear]=p->lchild;
}
if(p->rchild!=NULL)
{
rear=(rear+1)%MaxSize;
qu[rear]=p->rchild;
}
}
}
D. 请问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;
}
(4)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);
}
}
E. 中序表达式构建二叉树(C语言)
void Inorder (Tree *p)
{
if (p)
{
Inorder(p->Lchild); //遍历左子树
printf(“%d”,p->data); //访问根结点
Inorder(p->Rchild); //遍历右子树
}
}
F. c语言 c语言 二叉树构造问题
#include<locale.h>
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedefstructBiTNode{//二叉树结点
chardata; //数据
structBiTNode*lchild,*rchild; //左右孩子指针
}BiTNode,*BiTree;
intnn=0;
intCreateBiTree(BiTree*T){//按先序序列创建二叉树
chardata;
scanf("%c",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树
if(data== '#'){
*T=NULL;
}else{
*T=(BiTree)malloc(sizeof(BiTNode));nn++;
(*T)->data=data; //生成根结点
CreateBiTree(&(*T)->lchild);//构造左子树
CreateBiTree(&(*T)->rchild);//构造右子树
}
return0;
}
voidVisit(BiTreeT){//输出
if(T->data !='#'){
printf("%c",T->data);
}
}
voidPreOrder(BiTreeT){//先序遍历
if(T!=NULL){
Visit(T); //访问根节点
PreOrder(T->lchild); //访问左子结点
PreOrder(T->rchild); //访问右子结点
}
}
voidInOrder(BiTreeT){//中序遍历
if(T!=NULL){
InOrder(T->lchild); //访问左子结点
Visit(T); //访问根节点
InOrder(T->rchild); //访问右子结点
}
}
voidPostOrder(BiTreeT){//后序遍历
if(T!=NULL){
PostOrder(T->lchild); //访问左子结点
PostOrder(T->rchild); //访问右子结点
Visit(T); //访问根节点
}
}
voidPreOrder2(BiTreeT){//先序遍历(非递归)
//访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。
BiTree*stack=(BiTree*)malloc(nn*sizeof(BiTree));
int sp=0;
BiTreep=T;//p是遍历指针
while(p|| sp) { //栈不空或者p不空时循环
if(p!=NULL){
stack[sp]=p;sp++; //存入栈中
printf("%c",p->data);//访问根节点
p= p->lchild; //遍历左子树
}else{
sp--;p=stack[sp]; //退栈
p= p->rchild; //访问右子树
}
}
free(stack);
}
voidInOrder2(BiTreeT) {//中序遍历(非递归)
//T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
//先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。
BiTree*stack=(BiTree*)malloc(nn*sizeof(BiTree));
int sp=0;
BiTreep=T;//p是遍历指针
while(p|| sp) { //栈不空或者p不空时循环
if(p!=NULL){
stack[sp]=p;sp++; //存入栈中
p= p->lchild; //遍历左子树
}else{
sp--;p=stack[sp]; //退栈
printf("%c",p->data);
p= p->rchild; //访问右子树
}
}
free(stack);
}
typedef structBiTNodePost{
BiTreebiTree;
chartag;
}BiTNodePost,*BiTreePost;
voidPostOrder2(BiTreeT){//后序遍历(非递归)
BiTreePost*stack=(BiTreePost*)malloc(nn*sizeof(BiTreePost));
int sp=0;
BiTreep=T;//p是遍历指针
BiTreePostBT;
while(p!= NULL|| sp) {//栈不空或者p不空时循环
while(p!= NULL){//遍历左子树
BT=(BiTreePost)malloc(sizeof(BiTNodePost));
BT->biTree=p;
BT->tag ='L';//访问过左子树
stack[sp]=BT;sp++; //存入栈中
p= p->lchild;
}
while(sp&&(stack[sp-1])->tag =='R'){//左右子树访问完毕访问根节点
sp--;BT=stack[sp]; //退栈
printf("%c",BT->biTree->data);
free(BT);
}
if(sp) {//遍历右子树
BT=stack[sp-1];
BT->tag ='R';//访问过右子树
p= BT->biTree;
p= p->rchild;
}
}
free(stack);
}
voidLevelOrder(BiTreeT){//层次遍历
BiTreep;
BiTree*queue;
int h=0,t=0,n=0;
if(T==NULL)return;
p=T;
queue=(BiTree*)malloc(nn*sizeof(BiTree));
queue[t]=p;t=(t+1)%10;n++;//根节点入队
while(n){ //队列不空循环
p=queue[h]; //对头元素出队
printf("%c",p->data);//访问p指向的结点
h=(h+1)%10;n--; //退出队列
if(p->lchild!=NULL){//左子树不空，将左子树入队
queue[t]=p->lchild;t=(t+1)%10;n++;
}
if(p->rchild!=NULL){//右子树不空，将右子树入队
queue[t]=p->rchild;t=(t+1)%10;n++;
}
}
free(queue);
}
int main(){
BiTreeT;
setlocale(LC_ALL,"chs");
CreateBiTree(&T);
printf("先序遍历：");PreOrder(T);printf(" ");
printf("先序遍历(非递归)：");PreOrder2(T);printf(" ");
printf(" ");
printf("中序遍历：");InOrder(T);printf(" ");
printf("中序遍历(非递归)：");InOrder2(T);printf(" ");
printf(" ");
printf("后序遍历：");PostOrder(T);printf(" ");
printf("后序遍历(非递归)：");PostOrder2(T);printf(" ");
printf(" ");
printf("层次遍历：");LevelOrder(T);printf(" ");
return0;
}
//ABC##DE#G##F###
//先序遍历 ：AB CD EG F
//先序遍历(非递归)：AB CD EG F
//
//中序遍历 ：CB EG DF A
//中序遍历(非递归)：CB EG DF A
//
//后序遍历 ：CG EF DB A
//后序遍历(非递归)：CG EF DB A
//
//层次遍历 ：AB CD EF G
//
/// A
/// /
/// B
/// /
/// C D
/// /
/// E F
///
/// G
G. c语言 二叉树
void previsit(BiTree &T)
{
if(T!=NULL){
printf("%d\n",T->data);
previsit(T->lchild);
previsit(T->rchild);
}
}
前序遍历少了判断是否为NULL的判断
H. c语言绘制二叉树
你那里是打印出的啥？不会是没有存下数据打印了乱码吧？:)
[修改]
比如，我把和你的二叉树相关的代码去掉，改了一下：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <graphics.h>
int main()
{
char str[10];
int x = 100, y = 100;
int e = 9;
/* select a driver and mode that supports */
/* multiple drawing colors. */
int gdriver = DETECT, gmode = VGA, errorcode;
detectgraph(&gdriver, &gmode);
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "d:\\bc\\bgi");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
setcolor(BLACK);
setfillstyle(SOLID_FILL,BLACK);
fillellipse(x,y,9,9);
setcolor(WHITE);
circle(x,y,10);
sprintf(str,"%d",e);
outtextxy(x-3,y-2,str);
/* clean up */
getch();
/* colse */
closegraph();
return 0;
}
就能在圈圈里打印出"9"
I. C语言，二叉树
void insert(node ** tree, int val) {
node * temp = NULL; if(!(*tree)) {
temp = (node *)malloc(sizeof(node));
temp->left = temp->right = NULL;
temp->data = val; *tree = temp; return ;
}
if (val < (*tree)->data) {
insert(&(*tree)->left,val);
}else if (val > (*tree)->data) {
insert(&(*tree)->right,val);
}
}
J. c语言：二叉树
system("cls");//清屏
printf("input tree node elem(elem-->left-->right):\n");//屏幕上输出--请输入树节点元素，（元素-->左--》右） 如何输入，要看Pre_Create_BT函数