编程代码树

‘壹’ C语言，判断树的编程

一般构树的题都用最小生成树算法，但鉴于你的这题的特殊性，直接深搜，O(n)的时间复杂度就可以过了
#include<cstdio>
#include<cstring>
using namespace std;
bool bo[1100];
int n,m,a[1100][1100];
void search(int x){
for(int i=1;i<=a[x][0];i++){//询问与x相连的每一个点是否染了色
int y=a[x][i];
if(!bo[y]){//如果y没有被染色，就把y染色，并用y去更新别的节点
bo[y]=1;
search(y);
}
}
}
int main(){
scanf("%d%d",&n,&m);//这里需要你输入结点个数和边数，比如你的那组数据就输入10 9表示10个点，9条边
if(m<n-1){printf("NO\n");return 0;}//如果你的边数比节点数-1还要小的话，那根本不可能联成一个整体
for(int i=1;i<=m;i++){
int x,y;scanf("%d%d",&x,&y);
a[x][++a[x][0]]=y;//记录下x这个点可以连到y这个点，下同
a[y][++a[y][0]]=x;
}
memset(bo,0,sizeof(bo));//刚开始时除节点1外没有一个节点是在这个图中的，然后从1开始往别的点染色
bo[1]=1;
search(1);
for(int i=1;i<=n;i++)
if(!bo[i]){//如果有点没有被染色就说明不能连成一棵树
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}

‘贰’ 求java图形界面树类编程源码举例。类似windows资源管理器那样的。如附图，2层2项即可。

publicvoidinit(){
ContainercontentPane=null;
=newDefaultMutableTreeNode("我的电脑");
1=newDefaultMutableTreeNode("网络");
2=newDefaultMutableTreeNode("硬盘");
1_1=newDefaultMutableTreeNode("无限");
1_2=newDefaultMutableTreeNode("有限");
2_1=newDefaultMutableTreeNode("A");
2_2=newDefaultMutableTreeNode("B");
treeNode.add(treeNode1);
treeNode.add(treeNode2);
treeNode1.add(treeNode1_1);
treeNode1.add(treeNode1_2);
treeNode2.add(treeNode2_1);
treeNode2.add(treeNode2_2);
JTreetree=newJTree(treeNode);
contentPane=getContentPane();
JPaneljp=newJPanel();
jp.add(tree);
contentPane.add(jp);
this.setSize(300,250);
this.setLocation(400,300);
this.setVisible(true);
}

‘叁’ 编程实现以上二叉树中序遍历操作，输出遍历序列，求写代码~~

#include<stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define OK 1
#define ERROR 0
#define OVERFLOW 0

typedef char TElemType;
typedef int Status;
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
typedef enum {Link,Thread} PointerTag;
typedef struct BiThrNode
{
TElemType data;
struct BiThrNode *lchild,*rchild;
PointerTag LTag,RTag;
}BiThrNode;
typedef BiThrNode *BiThrTree;

BiTree CreateBiTree(BiTree T) //先序遍历构造二叉树
{
char ch;
scanf("%c",&ch);
if(ch=='#') //#代表空指针
T=NULL;
else
{
T=(BiTNode *)malloc(sizeof(BiTNode)); //申请结点
if(!T)
exit(OVERFLOW);
T->data=ch; //生成根结点
T->lchild=CreateBiTree(T->lchild); //构造左子树
T->rchild=CreateBiTree(T->rchild); //构造右子树
}
return T;
}

Status InOrderTraverse(BiTree T,Status(*visit)(TElemType))
{//中序遍历二叉树
if(T)
{
if(InOrderTraverse(T->lchild,visit))
if(visit(T->data))
if(InOrderTraverse(T->rchild,visit))
return OK;
return ERROR;
}
else
return OK;
}

Status PrintElement(TElemType e)
{
printf("%-2c",e);
return OK;
}

void main()
{
BiTree T=NULL;
printf("请输入构造二叉树的字符序列：");
T=CreateBiTree(T);
if(T)
printf("二叉树建立成功！ ");
else
printf("二叉树构造失败！！！ ");
printf("中序遍历二叉树：");
InOrderTraverse(T,PrintElement);
printf(" ");
}

‘肆’ 求利用c\c++将字符串集构建成一棵树的程序代码

表达式树是树结构的一个经典应用。

常见的表达式：3+5*7+2为中缀表达式。

这里，我实现一种转换算法，那就是先把中缀式子转化为一棵树，然后使用不同的遍历遍历方式得到不同的表达式

【注】（仅仅给出没有括号时的代码，为了简化字符串处理，我没有使用字符串，而是使用了字符，因此不支持两位的数字算式）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct string_node {
char tag; //定义字符
struct string_node *left;
struct string_node *right;
struct string_node *parent;
};
struct string_node *gen_sub_tree(char*str, int len)
{
struct string_node *root;
int i = 0;
for (i = 0; i < len; i++) {
struct string_node *node = (struct string_node*)calloc(1, sizeof(structstring_node));
node->tag =str[i];
if(isdigit(str[i])) {
if (i != 0) {//运算由左至右，除了第一个操作数，其它全部为右操作数，高优先级的会处在树的旁支
root->right = node;
node->parent = root;
}
root = node;
} else if((str[i] == 'x') || (str[i] == '/')) {
//处理乘除运算符
struct string_node *temp_root = NULL, *temp_parent = NULL;
if (root->parent &&(root->parent->tag == '+' || root->parent->tag == '-')) {
temp_parent = root->parent;
temp_root = root;
} else if(root->parent) {
temp_parent =root->parent->parent;
temp_root = root->parent;
} else {
temp_root = root;
}
node->parent = temp_parent;
if (temp_parent)
temp_parent->right = node;
node->left = temp_root;
temp_root->parent = node;
root = node;
} else if (str[i] == '+' || str[i] == '-') {
//处理加减运算符
struct string_node *temp_root =NULL, *temp_parent = NULL;
if (root->parent &&root->parent->parent &&(root->parent->tag == 'x' || root->parent->tag == '/')) {
temp_root =root->parent->parent;
} else if (root->parent&& !root->parent->parent){
temp_root = root->parent;
} else {
temp_root = root;
}
node->left = temp_root;
temp_root->parent = node;
root = node;
}
}
//找到树根，返回调用者
while (root->parent) {
root = root->parent;
}
return root;
}
int main(int argc, char **argv)
{
struct string_node *root;
char str[40] ={'1','+','0','+','2','x','5','+','3','x','4','x','2', '-', '7'};
root = NULL;
root = gen_sub_tree(str, 100);
print_result(root);
return 0;
}
//输出结果
void print_result(struct string_node*p)
{
if(p != NULL) {
//此为后缀表达式，根据printf的位置不同可以得到不同的X缀表达式
print_result(p->left);
print_result(p->right);
printf("%c\n", p->tag);
}
}

【】下面考虑加上括号时的情况，由于号优先级最高，而且还不是像运算符那样结合操作数的字符，因此把括号括住的成分单独作为一个操作数比较好，这样就可以递归的实现了。，只需要加入对’(‘和’)’的解析即可喽，递归调用gen_sub_tree即可。以下为加入括号处理的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct string_node {
char tag; //定义字符
struct string_node *left;
struct string_node *right;
struct string_node *parent;
};
struct string_node *gen_sub_tree(char*str, int len)
{
struct string_node *root;
int i = 0;
for (i = 0; i < len; i++) {
struct string_node *node = (struct string_node*)calloc(1, sizeof(structstring_node));
node->tag =str[i];
if(isdigit(str[i])) {
if (i != 0) {//运算由左至右，除了第一个操作数，其它全部为右操作数，高优先级的会处在树的旁支
root->right = node;
node->parent = root;
}
root = node;
} else if((str[i] == 'x') || (str[i] == '/')) {
//处理乘除运算符
struct string_node *temp_root = NULL, *temp_parent = NULL;
if (root->parent &&(root->parent->tag == '+' || root->parent->tag == '-')) {
temp_parent = root->parent;
temp_root = root;
} else if(root->parent) {
temp_parent =root->parent->parent;
temp_root = root->parent;
} else {
temp_root = root;
}
node->parent = temp_parent;
if (temp_parent)
temp_parent->right = node;
node->left = temp_root;
temp_root->parent = node;
root = node;
} else if (str[i] == '+' || str[i] == '-') {
//处理加减运算符
struct string_node *temp_root =NULL, *temp_parent = NULL;
if (root->parent &&root->parent->parent &&(root->parent->tag == 'x' || root->parent->tag == '/')) {
temp_root =root->parent->parent;
} else if (root->parent&& !root->parent->parent){
temp_root = root->parent;
} else {
temp_root = root;
}
node->left = temp_root;
temp_root->parent = node;
root = node;
}
}
//找到树根，返回调用者
while (root->parent) {
root = root->parent;
}
return root;
}
int main(int argc, char **argv)
{
struct string_node *root;
char str[40] ={'1','+','0','+','2','x','5','+','3','x','4','x','2', '-', '7'};
root = NULL;
root = gen_sub_tree(str, 100);
print_result(root);
return 0;
}
//输出结果
void print_result(struct string_node*p)
{
if(p != NULL) {
//此为后缀表达式，根据printf的位置不同可以得到不同的X缀表达式
print_result(p->left);
print_result(p->right);
printf("%c\n", p->tag);
}
}

‘伍’ 有关树的编程，用C语言描述

看数据结构的书去，书上都有具体的算法，稍微修改一下就可以了，我给你看一个我现在正在做的一个二分查找代码填空习题：核心代码如下

intinsert_key(BSTree*root,intkey)
{
BiTnode*father=NULL,*p=root,*s;
while(p!=NULL&&key!=p->key_value)
{
father=p;
if(key<p->key_value)p=p->left;
elsep=p->right;
}
/*这个是二分查找的代码，至于怎么输出这个范围内的，不用我教你了吧？
做个循环就可以了
*/
……
}

‘陆’ 编程关于树的问题

这个是c++程序，呵呵
显示的是后续遍历
#include<iostream.h>
typedef struct TreeNode
{
int key;
struct TreeNode *left;
struct TreeNode *right;

}treeNode;

class BiSortTree
{
public:
BiSortTree(void);
void desplayTree(void);//显示这个树
void insertTree(int key);//在树中插入一个值
deleteTree(int key);//在树中删除一个值
treeNode* searchTree(int key);//在树中查找一个值

~BiSortTree();

private:
treeNode* buildTree(treeNode* head,int number);//建立一个树
treeNode* search(treeNode* head ,int key);//查找
treeNode* BiSortTree::searchParent(treeNode* head,treeNode* p);//查找出p的父亲节点的指针
treeNode* BiSortTree::searchMinRight(treeNode* head);//找到右子树中最小的节点

void showTree(treeNode* head);//显示
void destroyTree(treeNode* head);//删除

treeNode *Head;

};

/**************以下是建立一个二叉排序树****************/
BiSortTree::BiSortTree()
{
cout<<"建立一棵二叉排序树,请输入你要建树的所有数(以-1 作为结束标志!): "<<endl;
Head=NULL;
int number;
cin>>number;
while(number!=-1)
{
Head=buildTree(Head,number);
cin>>number;

}

}
treeNode* BiSortTree::buildTree(treeNode* head,int number)
{

treeNode *p;
p=new treeNode;
p->key=number;
p->left =p->right=NULL;

if(head==NULL)
{

return p;
}
else
{

if(p->key <head->key)
head->left=buildTree(head->left,number);
else
head->right=buildTree(head->right,number);

return head;
}

}
/*****************以下是在一棵二叉排序树插入一个数***********************************/
void BiSortTree::insertTree(int key)
{

Head=buildTree(Head,key);

}
/*****************以下是在一个二叉排序树查找一个数是否存在*************************/
treeNode* BiSortTree::searchTree(int key)
{
return search(Head,key);
}
treeNode* BiSortTree::search(treeNode* head ,int key)
{
if(head==NULL)
return NULL;
if(head->key==key)
return head;
else
{
if(key<head->key )
return search( head->left,key);

else
return search(head->right,key);

}

}

/************以下是在一个二叉排序树删除一个给定的值*********************************/
BiSortTree::deleteTree(int key)
{

treeNode *p;
p=NULL;
p=search(Head,key);
if(p==NULL)
{
cout<<"Don't find the key";

}
if(p==Head)
{
Head=NULL;

}
else
{
treeNode* parent;
parent=searchParent(Head,p);
if(p->left==NULL&&p->right==NULL)//叶子节点
{
if(parent->left==p)
{
parent->left=NULL;
}
else
{
parent->right=NULL;

}
}
else//非叶子节点
{
if(p->right==NULL)//该节点没有右孩子
{
if(parent->left==p)
{
parent->left=p->left ;
}
else
{
parent->right=p->left;

}
}

else//该点有左右孩子
{
treeNode * rightMinSon,* secondParent;//secondParent为右子树中的最小节点的父亲
rightMinSon=searchMinRight(p->right);
secondParent=searchParent(p->right ,rightMinSon);

secondParent->left=rightMinSon->right;

if(p->right==rightMinSon)//右子树中的最小节点的父亲为p
{

p->right=rightMinSon->right ;

}

p->key=rightMinSon->key ;

}
}
}
}

treeNode* BiSortTree::searchParent(treeNode* head,treeNode* p)
{

if(head->left==p||head->right==p||head==p||head==NULL)
return head;
else
{
if(p->key<head->key)
return searchParent(head->left ,p);
else
return searchParent(head->right ,p);

}

}

treeNode* BiSortTree::searchMinRight(treeNode* head)//找到右子树中最小的节点
{

if(head->left ==NULL||head==NULL)
{
return head;

}
else
{
return searchMinRight(head->left);

}

}

/*****************以下是显示一个二叉排序树****************************************/
void BiSortTree::desplayTree(void)
{

showTree(Head);
cout<<endl;
}
void BiSortTree::showTree(treeNode* Head)
{

if(Head!=NULL)
{
showTree(Head->left ) ;

cout<<Head->key<<' ' ;

showTree(Head->right) ;

}

}

/*****************以下是删除一棵整二叉排序树************************************/
BiSortTree::~BiSortTree()
{
cout<<"已经消除了一棵树!!!!"<<endl;
destroyTree(Head);
}
void BiSortTree::destroyTree(treeNode* head )
{

if(head!=NULL)
{
destroyTree(head->left );
destroyTree(head->right );
delete head;

}

}

/*********************/
void print()
{

cout<<endl<<endl<<"以下是对二叉排序树的基本操作:"<<endl
<<"1.显示树的中序遍历"<<endl
<<"2.插入一个节点"<<endl
<<"3.寻找一个节点"<<endl
<<"4.删除一个节点"<<endl;
}

void main()
{
BiSortTree tree;
int number;
int choiceNumber;
char flag;
while(1)
{
print() ;

cout<<"请选择你要进行的操作(1~4)"<<endl;
cin>>choiceNumber;
switch(choiceNumber)
{
case 1:
tree.desplayTree();break;
case 2:
cout<<"请插入一个数: "<<endl;
cin>>number;
tree.insertTree(number);
tree.desplayTree();
break;

case 3:
cout<<"请插入你要找数: "<<endl;
cin>>number;
if(tree.searchTree(number)==NULL)
{
cout<<"没有发现"<<endl;
}
else
{

cout<<"发现"<<endl;

}
break;

case 4:
cout<<"请输入你要删除的数: "<<endl;
cin>>number;
tree.deleteTree(number);
tree.desplayTree();
break;

default: break;
}
cout<<"你是否要继续(Y/N)?"<<endl;
cin>>flag;
if(flag=='N'||flag=='n')
break;

}

}

‘柒’ 用processing编程如何实现毕达哥拉斯树 求具体代码

void setup()
{
size(600,600);
background(0);
noFill();
stroke(255,200);
frameRate(1);
}

boolean zmianaK = true;

int ii = 1;

void draw()
{
if(ii < 18)
{ background(1);
dPitagorejskie(100,height/2-50, 55, 0.25, 0.4, ii);
ii++;
}
}

void dPitagorejskie(float X, float Y, float D, float wspP, float wspH, int ilRek)
{
pushMatrix();
translate(X,Y);
rectMode(CENTER);
dPitagorejskieR(D, wspP, wspH, ilRek);
rectMode(CORNER);
popMatrix();
}

void dPitagorejskieR(float D, float wspP, float wspH, int ilRek)
{
if(ilRek > 0 && (wspP <= 1))
{
ilRek--;
rect(0,0,D,D);

pushMatrix();
translate(D/2,0);
float H = wspH*D;
float rA = wspP*D;
float rB = (1-wspP)*D;
float A = dist(0, -D/2, H, rA-D/2); //przeciwprostokatna A
float B = dist(0, D/2, H, D/2-rB); //przeciwprostokatna A
float alfa = atan(H/rA);
float beta = atan(H/rB);

translate(H/2, rA/2-D/2);
rotate(-alfa);
translate(A/2, 0);
dPitagorejskieR(A, zmianaK ? 1-wspP : wspP, wspH, ilRek);
popMatrix();

translate(D/2,D/2);
translate(H/2, -rB/2);
rotate(beta);
translate(B/2, 0);

dPitagorejskieR(B, zmianaK ? 1-wspP : wspP, wspH, ilRek);

}
}

‘捌’ C++编程实现二叉树的构建及其相关应用，求代码

#include<stdio.h>
#include<malloc.h>
typedefchardatatype;
typedefstructBinNode{
datatypedata;
structBinNode*lchild;
structBinNode*rchild;
}BinNode;

typedefBinNode*bintree;//bintree本身是个指向结点的指针

//前序遍历生成二叉树
voidcreatetree(bintree*t){
datatypec;
c=getchar();
if(c=='#')
*t=NULL;
else{
*t=(bintree)malloc(sizeof(BinNode));
(*t)->data=c;
createtree(&(*t)->lchild);
createtree(&(*t)->rchild);
}
}
//中序遍历
voidmidorder(bintreet){
if(t){
midorder(t->lchild);
printf("%c",t->data);
midorder(t->rchild);
}
}
//查找
boolsearch_tree(bintreet,datatypex){
if(!t){
returnfalse;
}
if(t->data==x){
returnt;
}else{
if(!search_tree(t->lchild,x)){
returnsearch_tree(t->rchild,x);
}
returntrue;
}
}
//求深度
intheight_tree(bintreet){
inth,left,right;
if(!t){
return0;
}
left=height_tree(t->lchild);
right=height_tree(t->rchild);
h=(left>right?left:right)+1;
returnh;
}
voidmain()
{
bintreeTree;
printf("Createtreeinpreorder:
");
createtree(&Tree);
printf("Displaytreeinmidorder:
");
midorder(Tree);
printf("
");
intheight=height_tree(Tree);
printf("height:%d
",height);
search_tree(Tree,'e')?printf("Found!
"):printf("NotFound!
");
return;
}

运行结果：

‘玖’ 各种编程语言抽象语法树分别是什么样子的

e），是源代码的抽象语法结构的树状表现形式，这里特指编程语言的源代码。树上的每个节点都表

‘拾’ 各种编程语言抽象语法树分别是什么样子的

LISP的AST极像代码是有原因的，LISP用的S-expression本身就是一个中间语言，相当于抽象语法树生成的中间代码，用来生成目标代码的。

本来McCarthy是想用和我们现在使用的语言比较像的M-expression的，但是当时LISP程序员更喜欢用那个中间形式的S-expression，于是就保留下来了。