单叶片编程
A. 编程求二叉树的叶子节点的个数，要求输入二叉树的二叉链表，输出二叉树的叶子节点个数。
void countleaf(bitnode *t,int *c)
{
if(t!=NULL)
{
if (t->lchild==NULL && t->rchild==NULL)
{*c=*c+1;
}
countleaf(t->lchild,c);
countleaf(t->rchild,c);
}
return;
}
typedef struct bitnode
{
char data;
struct bitnode *lchild, *rchild;
}bitnode, *bitree;
B. 数控电脑编程软件
数控编程软件这块，建议理论和实际操作相结合。多了解一些软件的特性。CAM这类数控编程软件很多，UG，catia，edgecam，hypermill，powermill，mastercam，cimtron，......等等hypermill和powermill偏向叶轮叶片，catia航空航天用的多，车铣复合的edgecam比较智能，cimtron模具的多，你可以上他们的网站了解了解。
C. 汽轮机叶片的数控编程是用什么编的
我们一般是用PROE
3.0编程，叶可以用UG。以及楼上说的思
美创
。
其实还有其他很多软件都能编程。比如
powermill
hypermill
等等。都能用于叶片加工。
D. 数控编程以后前景如何
首先，数控编程这个行业很有前途，但要精，现在这个行业现在普通人也很多，有好多从技校出来的
学生，都说是会，其实到了现场只是会操作和简单的编程，这样的人很多。不需要。
现在市场上缺的是高级编程工艺人员，缺少那种能综合运用现在数控加工技术并熟悉加工工艺，正确选用加工参数的综合性人才，这样的人才市场上非常吃香，国内好多数控机床尽管性能非常先进，但编程工艺人员不能完全发挥出其先进性能。
现在普通操作人员工资不高，但综合性高级编程工艺员很缺，工资很高，很有前途，希望你好好学。
总之，这个学好了绝对有工作，而且是技术活，缺点的话就是整天在车间里，噪音、油腻。凡事有利也有弊，个人建议，学这个是个不错的选择。
E. 大学想为以后的编程做学习准备，应该怎么准备呢
曾几何时，在大多数人的认知中，编程是成年人可以获取和应用的知识和技术。它似乎非常模糊，远离儿童的世界。然而，在互联网时代，编程已经面向所有人，孩子们不必等到大学才能获得相关知识。相反，他们有机会在小学或学前早期系统地学习编程。
Mabot收到按压信号，可以触发事件。当我们设计程序并按下红色按钮时，电风扇会以更快的速度运行，这相当于额外选择了一个风档。不难发现，在机器人搭建和编程的过程中，我们总是引导孩子不断地提问和思考，然后通过与生活接轨，反复试错，得到最佳方案。
F. 学习数控编程该学什么
看你做什么机器了，如果是国产的小型机器，以上就可以了，能对刀就可以了，程序一般机器里都有，只要您能看懂就好了，没有可以让领班的给你编，做一段时间你自己就会编了，进口的一般就让你按一下开关就ok了，你会做普车，可以到厂里学，最多一个多月就搞定了，如果你年龄不是很大的话，不需要考证，在厂里能把产品做出来就OK了，我要最佳
G. 求二叉树的遍历编程 要求： 1、建立二叉树 2、先序、中序、后序遍历输出 3、输出二叉树的深度和叶子节数目
创建 并 中序遍历输出
#include <stdio.h>
#include <malloc.h>
typedef enum PointerTag; //指针标志
typedef int DataType;
typedef struct BiThreTree{ //定义结点元素
PointerTag LTag,RTag;
DataType data;
struct BiThreTree *lchild,*rchild;
}BiThreTree;
BiThreTree *pre; //全局变量，用于二叉树的线索化
BiThreTree *CreateTree() //按前序输入建立二叉树
{
BiThreTree *T;
DataType e;
scanf("%d",&e);
if(e==0)
T=NULL;
else
{T=(BiThreTree *)malloc(sizeof(BiThreTree));
T->data=e;
T->LTag=Link; //初始化时指针标志均为Link
T->RTag=Link;
T->lchild=CreateTree();
T->rchild=CreateTree();
}
return T;
}
void InThread(BiThreTree *T)
{
BiThreTree *p;
p=T;
if(p)
{
InThread(p->lchild);
if(!p->lchild)
{ p->LTag=Thread;
p->lchild=pre;
}
if(!pre->rchild)
{ pre->RTag=Thread;
pre->rchild=p;
}
pre=p;
InThread(p->rchild);
}
}
BiThreTree *InOrderThrTree(BiThreTree *T) //中序线索化二叉树
{
BiThreTree *Thre; //Thre为头结点的指针
Thre=(BiThreTree *)malloc(sizeof(BiThreTree));
Thre->lchild=T;
Thre->rchild=Thre;
pre=Thre;
InThread(T);
pre->RTag=Thread;
pre->rchild=Thre;
Thre->rchild=pre;
return Thre;
}
void InThrTravel(BiThreTree *Thre) //中序遍历二叉树
{
BiThreTree *p;
p=Thre->lchild;
while(p!=Thre) //指针回指向头结点时结束
{
while(p->LTag==Link)
p=p->lchild;
printf("%4d",p->data);
while(p->RTag==Thread&&p->rchild!=Thre)
{p=p->rchild;
printf("%4d",p->data);
}
p=p->rchild;
}
}
int main()
{
BiThreTree *T,*Thre;
T=CreateTree();
Thre=InOrderThrTree(T);
InThrTravel(Thre);
system("pause");
}
第二个问题我看不懂。。。什么叫先中后序？
H. powermill2016 什么时候可以用
应当是有了，下面是介绍
新版 Delcam PowerMILL 2016 支持镜像完整加工项目
新版5轴和高速加工软件 Delcam PowerMILL 2016 日前发布，其最大亮点是支持镜像完整的加工项目。
现在只需一个操作即可镜像全部加工项目并自动保持加工特性，比如可自动选取每段刀具路径是做顺铣还是做逆铣，此前版本 Delcam PowerMILL 只支持独立刀具路径的镜像。
自动镜像整个加工项目可节省具有对称形状零件或工模具的加工编程时间，也可极大加快对称形状形体的加工编程速度，因为您只需对其中的一半进行加工编程，然后镜像全部刀具路径，完成整个零件的加工编程。
这个新的功能结合 Delcam PowerMILL 2015 R2
版本新增的完整机床检查功能，可保证项目镜像结果是期待的结果，比如，无碰撞出现。项目的完整机床检查功能可确保机床能运行镜像的刀具路径，同时还可检查
镜像刀具路径是否存在机床碰撞和刀具碰撞。
PowerMILL 2015 R2 新添了仿真机床运动中换刀的功能，而这项功能在2016版本中得到进一步增强，现在可仿真更复杂的换刀动作，尤其是转盘换刀机构的仿真。
Delcam PowerMILL 2016
版本还有其它的一些功能完善，比如现在可在仿真过程中显示刀尖位置，提供了一新的自动透明选项，可在任何时候看到工作台固定点的情况，可透明显示快进移动
中的安全区域。
Delcam PowerMILL 2016
除主模块各项功能得到增强外，其它一些选项模块的功能也得到提高，尤其是叶轮、叶片和螺旋桨模块，新开发了一效率更高的单叶片加工策略，同时还增加了一新
的等高加工选项，用于筋加工编程。
I. 航空发动机叶片加工工艺与多轴自动编程
一般都用专业软件编程，TS，hypermill等，机床也是专机的。
J. 数据结构编程： 统计二叉树中叶子结点的个数。
叶子节点：没有孩子节点的节点
也就是说，当我们明白了叶子节点的定义后，只需要遍历一遍二叉树，把符合这种条件（左孩子节点和右孩子节点都为NULL的节点）的节点统计出来就可以了。
于是，实际上这个问题也就转化成了如何遍历二叉树？很显然，遍历二叉树是可以有多种方式的，如：前序遍历（递归/非递归）、中序遍历（递归/非递归）、后序遍历（递归/非递归）、层次遍历等等。
下面我将给出使用递归前序遍历以及层次遍历两种思路实现的求解叶子节点的示例代码吧，仅供参考。其他几种实现方式思路类似，可自行尝试。示例代码如下：
java">packagecn.zifangsky.tree.questions;
importorg.junit.Test;
importcn.zifangsky.queue.LinkQueue;
importcn.zifangsky.tree.BinaryTreeNode;
/**
*求二叉树中叶子节点的个数
*@authorAdministrator
*
*/
publicclassQuestion2{
/**
*通过递归前序遍历获取叶子节点个数
*@paramroot
*@return
*/
(BinaryTreeNoderoot){
if(root==null){
return0;
}else{
if(root.getLeft()==null&&root.getRight()==null){//叶子节点
return1;
}else{
(root.getLeft())+getNumberOfLeavesByPreOrder(root.getRight());
}
}
}
/**
*使用层次遍历获取二叉树叶子节点个数
*
*@时间复杂度O(n)
*@paramroot
*/
(BinaryTreeNoderoot){
intcount=0;//叶子节点总数
LinkQueue<BinaryTreeNode>queue=newLinkQueue<>();
if(root!=null){
queue.enQueue(root);
}
while(!queue.isEmpty()){
BinaryTreeNodetemp=(BinaryTreeNode)queue.deQueue();
//叶子节点：左孩子节点和右孩子节点都为NULL的节点
if(temp.getLeft()==null&&temp.getRight()==null){
count++;
}else{
if(temp.getLeft()!=null){
queue.enQueue(temp.getLeft());
}
if(temp.getRight()!=null){
queue.enQueue(temp.getRight());
}
}
}
returncount;
}
/**
*测试用例
*/
@Test
publicvoidtestMethods(){
/**
*使用队列构造一个供测试使用的二叉树
*1
*23
*4567
*89
*/
LinkQueue<BinaryTreeNode>queue=newLinkQueue<BinaryTreeNode>();
BinaryTreeNoderoot=newBinaryTreeNode(1);//根节点
queue.enQueue(root);
BinaryTreeNodetemp=null;
for(inti=2;i<10;i=i+2){
BinaryTreeNodetmpNode1=newBinaryTreeNode(i);
BinaryTreeNodetmpNode2=newBinaryTreeNode(i+1);
temp=(BinaryTreeNode)queue.deQueue();
temp.setLeft(tmpNode1);
temp.setRight(tmpNode2);
if(i!=4)
queue.enQueue(tmpNode1);
queue.enQueue(tmpNode2);
}
System.out.println("叶子节点个数是："+getNumberOfLeavesByPreOrder(root));
System.out.println("叶子节点个数是："+getNumberOfLeavesByQueue(root));
}
}
测试代码输出如下：
叶子节点个数是：5
叶子节点个数是：5
附：
二叉树节点BinaryTreeNode的定义：
packagecn.zifangsky.tree;
publicclassBinaryTreeNode{
privateintdata;//数据
privateBinaryTreeNodeleft;//左孩子节点
privateBinaryTreeNoderight;//右孩子节点
publicBinaryTreeNode(intdata){
this.data=data;
}
publicBinaryTreeNode(intdata,BinaryTreeNodeleft,BinaryTreeNoderight){
this.data=data;
this.left=left;
this.right=right;
}
publicintgetData(){
returndata;
}
publicvoidsetData(intdata){
this.data=data;
}
publicBinaryTreeNodegetLeft(){
returnleft;
}
publicvoidsetLeft(BinaryTreeNodeleft){
this.left=left;
}
publicBinaryTreeNodegetRight(){
returnright;
}
publicvoidsetRight(BinaryTreeNoderight){
this.right=right;
}
}
队列LinkQueue的定义：
packagecn.zifangsky.queue;
importcn.zifangsky.linkedlist.SinglyNode;
/**
*基于单链表实现的队列
*@authorzifangsky
*@param<K>
*/
publicclassLinkQueue<KextendsObject>{
privateSinglyNode<?>frontNode;//队首节点
privateSinglyNode<?>rearNode;//队尾节点
publicLinkQueue(){
frontNode=null;
rearNode=null;
}
/**
*返回队列是否为空
*@时间复杂度O(1)
*@return
*/
publicbooleanisEmpty(){
return(frontNode==null);
}
/**
*返回存储在队列的元素个数
*@时间复杂度O(n)
*@return
*/
publicintsize(){
intlength=0;
SinglyNode<?>currentNode=frontNode;
while(currentNode!=null){
length++;
currentNode=currentNode.getNext();
}
returnlength;
}
/**
*入队：在链表表尾插入数据
*@时间复杂度O(1)
*@paramdata
*/
publicvoidenQueue(Kdata){
SinglyNode<K>newNode=newSinglyNode<K>(data);
if(rearNode!=null){
rearNode.setNext(newNode);
}
rearNode=newNode;
if(frontNode==null){
frontNode=rearNode;
}
}
/**
*出队：删除表头节点
*@时间复杂度O(1)
*@return
*/
publicObjectdeQueue(){
if(isEmpty()){
thrownewRuntimeException("QueueEmpty!");
}else{
Objectresult=frontNode.getData();
if(frontNode==rearNode){
frontNode=null;
rearNode=null;
}else{
frontNode=frontNode.getNext();
}
returnresult;
}
}
}
单链表节点SinglyNode的定义：
packagecn.zifangsky.linkedlist;
/**
*单链表的定义
*@authorzifangsky
*@param<K>
*/
publicclassSinglyNode<KextendsObject>{
privateKdata;//数据
privateSinglyNode<?>next;//该节点的下个节点
publicSinglyNode(Kdata){
this.data=data;
}
publicSinglyNode(Kdata,SinglyNode<?>next){
this.data=data;
this.next=next;
}
publicKgetData(){
returndata;
}
publicvoidsetData(Kdata){
this.data=data;
}
publicSinglyNode<?>getNext(){
returnnext;
}
publicvoidsetNext(SinglyNode<?>next){
this.next=next;
}
@Override
publicStringtoString(){
return"SinglyNode[data="+data+"]";
}
}