1、升级你的到最新的653版本。 2、在的第一个页面顶端，有一个搜索条，在搜索条里输入：小程序示例然后搜索。点最下面的：搜一搜 小程序示例 朋友圈、公众号、文章等。 3、选择第一个结果，图标是黑色斜写的英文字母“S”，点开它 4、看如何制作微信小程序的遍历数组的单选
#include "stdioh"
#include "malloch"
#define ELEMTYPE char
BiTNode bulid() /建树/
{ BiTNode q;
BiTNode s[20];
int i,j;
char x;
printf("请按顺序输入二叉树的结点以输入0和号结束\n");
printf("请输入要输入的为第几个结点i=\n");
scanf("%d",&i);
printf("请输入你要输入该结点的数为x=");
getchar();
scanf("%c",&x);
while(i!=0&&x!='')
{q=(BiTNode)malloc(sizeof(BiTNode));
q->data=x;
q->rchild=NULL;
q->lchild=NULL;
case(1): preoder(bt); goto k1;
case(2): InOrder(bt); goto k1;
case(3): postOrder(bt); goto k1;
case(0): break;
root=(struct lbtree )malloc(sizeof(struct lbtree));
root->data=ch;
root->lchild=createbtree();
root->rchild=createbtree();
return(root);
}
dl=treedepth(root->lchild);
dr=treedepth(root->rchild);
if(dl>dr)depth=dl+1;
else depth=dr+1;
扩展资料：
(1)完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。
(2)满二叉树——除了叶结点外每一个结点都有左右子叶且叶子结点都处在最底层的二叉树。
(3)平衡二叉树——平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉排序树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
参考资料来源：百度百科-二叉树
数据结构实验------二叉树 *** 作2008-12-04 19:07按层次输入，这样可以根据实际需要建立树型，更为实用。但我的程序仍存在一个问题，就是遍历（2）：输出为空的孩子时都会多输出两个空孩子。不知道怎么改。
//二叉树结点类型为字符型的情况
#include <stdioh>
#include <stdlibh>
#include <stringh>
#define null 0
#define MaxSize 1024
typedef struct tree
{ /声明树的结构/
struct tree left; /存放左子树的指针/
struct tree right; /存放又子树的指针/
char data; /存放节点的内容/
} treenode, b_tree; /声明二叉树的链表/
b_tree Q[MaxSize];
/建立二叉树，按完全二叉树的层次遍历序列输入/
b_tree createbtree()
{
char ch;
int front,rear;
b_tree root,s;
root=NULL;
front=1;rear=0;
ch=getchar();
getchar();
while(ch!='')
{
s=NULL;
if(ch!='')
{
s=(b_tree)malloc(sizeof(treenode));
s->data=ch;
s->left=NULL;
s->right=NULL;
}
rear++;
Q[rear]=s;
if(rear==1)
root=s;
else
{
if(s&&Q[front])
if(rear%2==0)
Q[front]->left=s;
else
Q[front]->right=s;
if(rear%2==1)
front++;
}
ch=getchar();
getchar();
}
return root;
}
/先序遍历打印二叉排序树/
void preorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null)
{
printf("%3c",p->data);
preorder_btree(p->left);
preorder_btree(p->right);
}
}
/ 中序遍历打印二叉排序树/
void inorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null){
inorder_btree(p->left );
printf("%3c",p->data );
inorder_btree(p->right );
}
}
/后序遍历打印二叉排序树/
void postorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null)
{
postorder_btree(p->left );
postorder_btree(p->right );
printf("%3c",p->data );
}
}
/求树的高度/
int treedepth(b_tree bt)
{
int hl,hr,max;
if(bt!=null)
{
hl=treedepth(bt->left);
hr=treedepth(bt->right);
max=(hl>hr)hl:hr;
return (max+1);
}
else
return 0;
}
int count=0;
/求叶子结点总数/
int leafcount(b_tree bt)
{
if(bt!=null)
{
leafcount(bt->left);
leafcount(bt->right);
if(bt->left==null&&bt->right==null)
count++;
}
return count;
}
void paintleaf(b_tree bt)
{
if(bt!=null)
{
if(bt->left==null&&bt->right==null)
printf("%3c",bt->data);
paintleaf(bt->left);
paintleaf(bt->right);
}
}
typedef b_tree ElemType ;
/定义队列结点类型/
typedef struct QueueNode
{
ElemType data;
struct QueueNode next;
} QueueNode;
/定义队列/
typedef struct linkQueue
{
QueueNode front;
QueueNode rear;
}linkQueue;
/初始化队列/
void initQueue(linkQueue q)
{
q->front=q->rear =null; //----无头结点
}
/判断队列是否为空/
int QueueEmpty(linkQueue Q)
{
return (Q->front==null)&&(Q->rear==null);
/实际上只须判断队头指针是否为空即可/
}
/入队 *** 作/
void EnQueue(linkQueue Q,ElemType x)
{ /将元素x插入链队列尾部/
QueueNode p=(QueueNode )malloc(sizeof(QueueNode)); /申请新结点/
p->data=x; p->next=null;
if(QueueEmpty(Q)) /将x插入空队列/ //----无头结点
Q->front=Q->rear=p;
else
{ /x插入非空队列的尾/
Q->rear->next=p; /p链到原队尾结点后/
Q->rear=p; /队尾指针指向新的尾/
}
}
/出队 *** 作/
ElemType DeQueue (linkQueue Q)
{
ElemType x;
QueueNode p;
if(QueueEmpty(Q))
{
printf("Queue underflow");/下溢/
exit(1) ;
}
p=Q->front; /指向对头结点/
x=p->data; /保存对头结点的数据/
Q->front=p->next; /将对头结点从链上摘下/
if(Q->rear==p)/原队中只有一个结点，删去后队列变空，此时队头指针已为空/
Q->rear=NULL;
free(p); /释放被删队头结点/
return x; /返回原队头数据/
}
void visit(b_tree p)
{
printf("%3c",p->data);
}
void breadthFirst2(b_tree root)
{
b_tree p,tmp;
linkQueue q;
tmp=(treenode )malloc(sizeof(treenode));
q=(linkQueue )malloc(sizeof(linkQueue));
tmp->data='';
initQueue(q);
p=root;
if(p!=null)
{
EnQueue(q,p);
while(!QueueEmpty(q))
{
p=DeQueue(q);
visit(p);
if(p->data!='')
{
if(p->left!=null)
EnQueue(q,p->left);
else
EnQueue(q,tmp);
if(p->right!=null)
EnQueue(q,p->right);
else
EnQueue(q,tmp);
}
}
}
}
void breadthFirst(b_tree root)
{
b_tree p;
linkQueue q;
q=(linkQueue )malloc(sizeof(linkQueue));
initQueue(q);
p=root;
if(p!=null)
{
EnQueue(q,p);
while(!QueueEmpty(q))
{
p=DeQueue(q);
visit(p);
if(p->left!=null)
EnQueue(q,p->left);
if(p->right!=null)
EnQueue(q,p->right);
}
}
}
int main()
{
char nodelist[MaxSize];
int len,flag;
char cmd;
b_tree root;
printf("\n\n----------------------------------------------------\n");
printf("\n欢迎测试和修正本程序！本程序用以研究二叉树。\n");
printf("\n----------------------------------------------------\n\n");
do
{
printf("\n\n 请选择你要执行的 *** 作:\n\n");
printf(" c,C创建一棵二叉排序树\n");
printf(" a,A结束本程序\n\n");
flag=0;
do
{
if(flag!=0)
printf("选择 *** 作错误！请重新选择！\n");
fflush(stdin);
scanf("%c",&cmd);
flag++;
}while(cmd!='c'&&cmd!='C'&&cmd!='a'&&cmd!='A');
if(cmd=='c'||cmd=='C')
{
printf("请输入那你所要创建的二叉树的结点的值,以‘？’结束）：\n");
getchar();
root=createbtree();
do
{
flag=0;
printf("\n\n 请选择你要对这棵二叉树所做的 *** 作:\n\n");
printf(" x,X先序遍历这棵二叉树\n");
printf(" z,Z中序遍历这棵二叉树\n");
printf(" h,H后序遍历这棵二叉树\n");
printf(" b,B层次遍历这棵二叉树\n");
printf(" d,D求这棵二叉树的高度\n");
printf(" y,Y求这棵二叉树的叶子总数\n");
printf(" j,J输出这棵二叉树的叶子结点\n");
printf(" q,Q结束对这棵二叉树的 *** 作\n\n");
do
{
if(flag!=0)
printf("选择 *** 作错误！请重新选择！\n");
fflush(stdin);
scanf("%c",&cmd);
flag++;
}while(cmd!='x'&&cmd!='X'&&cmd!='z'&&cmd!='Z'&&cmd!='h'&&cmd!='H'&&cmd!='b'&&cmd!='B'&&cmd!='d'&&cmd!='D'&&cmd!='y'&&cmd!='Y'&&cmd!='j'&&cmd!='J'&&cmd!='q'&&cmd!='Q');
switch(cmd)
{
case 'x':
case 'X':
printf("\n先序遍历开始:\n");
preorder_btree(root);
printf("\n先序遍历结束\n\n");
break;
case 'z':
case 'Z':
printf("\n中序遍历开始:\n");
inorder_btree(root);
printf("\n中序遍历结束\n\n");
break;
case 'h':
case 'H':
printf("\n后序遍历开始:\n");
postorder_btree(root);
printf("\n后序遍历结束\n\n");
break;
case 'b':
case 'B':
printf("\n层次遍历开始:\n");
printf("遍历（1）：不输出为空的孩子\n");
breadthFirst(root);
printf("\n");
printf("遍历（2）：输出为空的孩子\n");
breadthFirst2(root);
printf("\n层次遍历结束\n\n");
break;
case 'd':
case 'D':
printf("\n这棵二叉树的高度：\n%d\n\n",treedepth(root));
break;
case 'y':
case 'Y':
count=0;
count=leafcount(root);
printf("\n这棵二叉树的叶子总数为:\n%d\n\n",count);
count=0;
break;
case 'j':
case 'J':
printf("\n这棵二叉树的叶子结点为：\n");
paintleaf(root);
printf("\n");
break;
}
}while(cmd!='q'&&cmd!='Q');
}
}while(cmd!='a'&&cmd!='A');
printf("\n\n----------------------------\n\n");
printf("谢谢使用！欢迎指正！\n\n");
printf("----------------------------\n\n");
printf("作者：Remainder 学号：07082107 时间：20081123\n\n\n\n");
return 0;
}
/（10
（8 5 3 34 23 73 15 34 56 32）。。。。。。结点数据整型时
6
1 2 3 4 5 6
4
a b c d
/
上面是我写的程序，希望对你有用！
>
import javaio;
import javautilArrayList;
import javautilIterator;
import javautilList;
/
读取目录及子目录下指定文件名的路径 并放到一个数组里面返回遍历
@author zdz8207
/
public class FileViewer {
public static void main(String[] args) {
//List arrayList = FileViewergetListFiles("d:/com","html",true);
//读取d:/com下的以java 结尾的文件 如有子目录，包含之（后缀名为null则为所有文件）
//List arrayList = FileViewergetListFiles("d:/com","java",true);
//经试验，后缀不能不填写，否则编译不通过，提示“FileViewerjava:17: 非法的表达式开始”。
//另外后缀为""时的情况需要 增加到IF 里去，否则 后缀为""时，不会显示所有文件
List arrayList = FileViewergetListFiles("d:/com","",true);
if(arrayListisEmpty())
{
Systemoutprintln("没有符号要求的文件");
}
else
{
String message = "";
message += "符号要求的文件数：" + arrayListsize() + "\r\n";
Systemoutprintln(message);
for (Iterator i = arrayListiterator(); ihasNext();)
{
String temp = (String) inext();
Systemoutprintln(temp);
message += temp + "\r\n";
}
//将显示的文件路径写到指定的文件里，若文件不存在，则提示IO异常
//javaioFileNotFoundException: d:\ajax\menutxt (系统找不到指定的路径。)
//如果 加个文件是否存在的判断，如不存在就在当前目录新建一个，则更好。
appendMethod("d:/menutxt",message);
}
}
public static List<String> fileList = new ArrayList<String>();
/
@param path 文件路径
@param suffix 后缀名
@param isdepth 是否遍历子目录
@return
/
public static List getListFiles(String path, String suffix, boolean isdepth)
{
File file = new File(path);
return FileViewerlistFile(file ,suffix, isdepth);
}
public static List listFile(File f, String suffix, boolean isdepth)
{
//是目录，同时需要遍历子目录
if (fisDirectory() && isdepth == true)
{
File[] t = flistFiles();
for (int i = 0; i < tlength; i++)
{
listFile(t[i], suffix, isdepth);
}
}
else
{
String filePath = fgetAbsolutePath();
Systemoutprintln("suffix = "+suffix);
if(suffix =="" || suffix == null)
{
//后缀名为null则为所有文件
Systemoutprintln("----------------");
fileListadd(filePath);
}
else
{
int begIndex = filePathlastIndexOf("");//最后一个(即后缀名前面的)的索引
String tempsuffix = "";
if(begIndex != -1)//防止是文件但却没有后缀名结束的文件
{
tempsuffix = filePathsubstring(begIndex + 1, filePathlength());
}
if(tempsuffixequals(suffix))
{
fileListadd(filePath);
}
Systemoutprintln("|||||||||||||||||||");
}
}
return fileList;
}
/
方法追加文件：使用FileWriter
@param fileName
@param content
/
public static void appendMethod(String fileName, String content)
{
try
{
//打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
FileWriter writer = new FileWriter(fileName, true);
writerwrite(content + "\r\n");
writerclose();
}
catch (IOException e)
{
eprintStackTrace();
}
}
}
//这是一个计算指定目录所包含文件的总大小的函数
//当然涉及了遍历文件及文件夹
void getLength(File file)
{
if(fileisDirectory())
{
File fileArray[]=filelistFiles();
for(int i=0;i<fileArraylength;i++){
getLength(fileArray[i]); //Systemoutprintln(fileArray[i]getPath());
}
}
else if(fileisFile()){
try
{
RandomAccessFile raf=new RandomAccessFile(file,"r");
fileLength=fileLength+raflength();
rafclose();
}catch(IOException ioe){ioeprintStackTrace();}
}
}
自己写的，运行通过，MFC的有点难弄，将就着用吧。
queueh//链式队列用于层序遍历树
// queueh: interface for the queue class
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_)
#define AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <iostreamh>
#include <asserth>
template<class T>
struct LinkNode
{
T data;
LinkNode<T> link;
LinkNode(LinkNode<T> ptr = NULL){link = ptr;}//仅初始化指针成员的初始函数
LinkNode(const T& item,LinkNode<T> ptr = NULL)
{data = item;link = ptr;} //初始化数据与指针成员的构造函数
};
template <class T>
class queue
{
private:
LinkNode<T> front,rear;//
public:
queue():rear(NULL),front(NULL){};//
~queue(){makeempty();};//
bool EnQueue(T &x);//
bool DeQueue(T &x);//
bool getFront(T &x);//
void makeempty();//
bool Isempty()const{return front==NULL;}//
int getSize()const;//
friend ostream &operator<<(ostream &os,queue<T> &q);//
};
template<class T>
void queue<T>::makeempty()
{
LinkNode<T> p;
while(front!=NULL)
{
p=front;
front=front->link;
delete p;
}
}
template <class T>
bool queue<T>::EnQueue(T &x)
{
if(front==NULL)
{
front=rear=new LinkNode<T>(x);
if(front==NULL)
return false;
}
else
{
rear->link=new LinkNode<T>(x);
if(rear==NULL)
return false;
rear=rear->link;
}
return true;
}
template <class T>
bool queue<T>::DeQueue(T &x)
{
if(Isempty())return false;
LinkNode<T> p=front;
x=front->data;
front=front->link;
delete p;
return true;
}
template<class T>
bool queue<T>::getFront(T &x)
{
if(Isempty())return false;
x=front->data;
return true;
}
template <class T>
int queue<T>::getSize() const
{
LinkNode<T> p=front;
int k=0;
while(p)
{
k++;
p=p->link;
}
return k;
}
#endif // !defined(AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_)
BinaryTreeh
// BinaryTreeh: interface for the BinaryTree class
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_)
#define AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <iostreamh>
typedef int T;
struct BinTreeNode
{
T data;
BinTreeNode leftChild,rightChild;
BinTreeNode():leftChild(NULL),rightChild(NULL){}
BinTreeNode(T x,BinTreeNode l=NULL,BinTreeNode r=NULL):data(x),leftChild(l),rightChild(r){}
};
class BinaryTree {
public:
BinaryTree():root(NULL){} //
BinaryTree(T value):RefValue(value) ,root(NULL){} //
~BinaryTree(){destroy(root);}/////////
void CreateBinTree(){CreateBinTree(root);}
bool IsEmpty(){return(root==NULL)true:false;}////////
BinTreeNode Parent(BinTreeNode current)/////////
{return(root==NULL||root==current)NULL:Parent(root,current);}//////
BinTreeNode LeftChild(BinTreeNode current)////
{return(current!=NULL)current->leftChild:NULL;}
BinTreeNode RightChild(BinTreeNode current)///////
{return(current!=NULL)current->rightChild:NULL;}
int Height(){return Height(root);}///////
int Size(){return Size(root);}///////
BinTreeNode getRoot()const{return root;}///////
void preOrder()///////
{preOrder(root);}
void inOrder()///////
{inOrder(root);}
void postOrder()///
{postOrder(root);}
void levelOrder()/////
{levelOrder(root);}
void destroy(){destroy(root);};
int Leaves (){return leaves(root);}
protected:
BinTreeNode root;
T RefValue;
void CreateBinTree(BinTreeNode &subTree);
bool Insert(BinTreeNode &subTree,const T &x);////////
void destroy(BinTreeNode &subTree);/////
bool Find(BinTreeNode &subTree,const T &x);///////
BinTreeNode Copy(BinTreeNode orignode);///////
int Height(BinTreeNode subTree);////////
int Size(BinTreeNode subTree);///////
BinTreeNode Parent(BinTreeNode Parent,BinTreeNode current);//////
BinTreeNode Find(BinTreeNode &subTree,const T &x)const;////////
void Traverse(BinTreeNode &subTree,ostream &out);///////
void preOrder(BinTreeNode &subTree);///////
void inOrder(BinTreeNode &subTree);///////
void postOrder(BinTreeNode &subTree);///////
void levelOrder(BinTreeNode &subtree);
int leaves(BinTreeNode &subTree);
};
#endif // !defined(AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_)
BinaryTreecpp
// BinaryTreecpp: implementation of the BinaryTree class
//
//////////////////////////////////////////////////////////////////////
#include "BinaryTreeh"
#include<stdlibh>
#include "queueh"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
void BinaryTree::CreateBinTree(BinTreeNode &subTree) /////////建立二叉树
{
T item;
cin>>item;
if(item!=RefValue)
{
subTree=new BinTreeNode(item);
if(subTree==NULL)
{
cerr<<"存储分配错误！"<<endl;
exit(1);
}
CreateBinTree(subTree->leftChild);
CreateBinTree(subTree->rightChild);
}
else subTree=NULL;
}
void BinaryTree::destroy(BinTreeNode & subTree) ////删除二叉树
{
if(subTree!=NULL)
{
destroy(subTree->leftChild);
destroy(subTree->rightChild);
delete subTree;
}
}
BinTreeNode BinaryTree::Parent(BinTreeNode subTree, BinTreeNode current) //找父母结点
{
if(subTree==NULL) return NULL;
if(subTree->leftChild==current||subTree->rightChild==current)
return subTree;
BinTreeNode p;
if((p=Parent(subTree->leftChild,current))!=NULL) return p;
else return Parent(subTree->rightChild,current);
}
void BinaryTree::preOrder( BinTreeNode &subTree) //前序遍历
{
if(subTree!=NULL)
{
cout<<subTree->data<<" ";
preOrder(subTree->leftChild);
preOrder(subTree->rightChild);
}
}
void BinaryTree::inOrder( BinTreeNode &subTree) //中序遍历
{
if(subTree!=NULL)
{
inOrder(subTree->leftChild);
cout<<subTree->data<<" ";
inOrder(subTree->rightChild);
}
}
void BinaryTree::postOrder( BinTreeNode &subTree ) // 后序遍历
{
if(subTree!=NULL)
{
postOrder(subTree->leftChild);
postOrder(subTree->rightChild);
cout<<subTree->data<<" ";
}
}
void BinaryTree::levelOrder(BinTreeNode &subtree) //层序遍历
{
if(root==NULL)return;
queue<BinTreeNode> Q;
BinTreeNode p=root;
QEnQueue(p);
while(!QIsempty())
{
QDeQueue(p);
cout<<p->data<<" ";
if(p->leftChild)
QEnQueue(p->leftChild);
if(p->rightChild)
QEnQueue(p->rightChild);
}
}
int BinaryTree::Size(BinTreeNode subTree) //求结点个数
{
if(subTree==NULL) return 0;
else return 1+Size(subTree->leftChild)+Size(subTree->rightChild);
}
int BinaryTree::Height(BinTreeNode subTree) //求数的深度
{
if(subTree==NULL) return 0;
else
{
int i=Height(subTree->leftChild);
int j=Height(subTree->rightChild);
return (i>j)i+1:j+1;
}
}
int BinaryTree::leaves(BinTreeNode &subTree) //求叶子节点个数
{
if(subTree==NULL) return 0;
else if(subTree->leftChild==NULL&&subTree->rightChild==NULL)return 1;
else
{
int i=leaves(subTree->leftChild);
int j=leaves(subTree->rightChild);
return i+j;
}
}
主函数：
#include "BinaryTreeh"
int main_menu()
{
char option;
while(1)
{
cout<<" 主菜单"<<endl;
cout<<endl;
cout<<" 请选择 *** 作:"<<endl;
cout<<" 1 建立树:"<<endl;
cout<<" 2 清空树"<<endl;
cout<<" 3 退出"<<endl;
cin>>option;
switch(option)
{
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
default:
cout<<"输入错误，请检查输入!"<<endl;
break;
}
}
}
int tree_menu(BinaryTree &btn)
{
char option;
while(1)
{
cout<<" 树的相关 *** 作:"<<endl;
cout<<" 请选择 *** 作:"<<endl;
//cout<<" 1 输入节点"<<endl;
cout<<" 2 按前序输出"<<endl;
cout<<" 3 按中序输出"<<endl;
cout<<" 4 按后序输出"<<endl;
cout<<" 5 按层序输出"<<endl;
cout<<" 6 求节点个数"<<endl;
cout<<" 7 求树的深度"<<endl;
cout<<" 8 求树的高度"<<endl;
cout<<" 9 返回主菜单"<<endl;
cin>>option;
switch(option)
{
// case '1':
// {
// cout<<"输入节点,-1为结束标志"<<endl;
// btnCreateBinTree();
// break;
// }
case '2':
{
cout<<"按前序输出为:"<<endl;
btnpreOrder();
break;
}
case '3':
{
cout<<"按中序输出为:"<<endl;
btninOrder();
break;
}
case '4':
{
cout<<"按后序输出为:"<<endl;
btnpostOrder();
break;
}
case '5':
{
cout<<"按层序输出为:"<<endl;
btnlevelOrder();
break;
}
case '6':
{
cout<<"节点个数为:"<<btnSize()<<endl;
break;
}
case '7':
{
cout<<"求树的深度为:"<<btnHeight()<<endl;
break;
}
case '8':
{
cout<<"求树的高度为:"<<btnHeight()<<endl;
break;
}
case '9':
return 9;
default:
cout<<"输入有误，请检查输入!"<<endl;
break;
}
}
}
int main()
{
bool bCreated=false;
int op;
BinaryTree btn(-1);
while(1)
{
op=main_menu();
switch(op)
{
case 1:
{
if(!bCreated)
{
cout<<"1 输入节点,-1为结束标志"<<endl;
btnCreateBinTree();
}
bCreated=true;
tree_menu(btn);
break;
}
case 2:
{
btndestroy();
bCreated=false;
break;
}
case 3:
return 0;
}
}
return 0;
}
以上就是关于怎么制作微信小程序的遍历数组的单选功能全部的内容，包括:怎么制作微信小程序的遍历数组的单选功能、编写程序，用先序递归遍历法建立二叉树的二叉链表存储结构，输出其先序、中序、后序遍历第k个访问结点、求高手编写一用层次遍历求二叉树深度的程序,谢谢等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）