Little Valentine liked playing with binary trees very much. Her favorite game was constructing randomly looking binary trees with capital letters in the nodes.
This is an example of one of her creations:


                                          / \

                                         /   \

                                        B     E

                                       / \     \

                                      /   \     \

                                     A     C     G




To record her trees for future generations, she wrote down two strings for each tree: a preorder traversal (root, left subtree, right subtree) and an inorder traversal (left subtree, root, right subtree). For the tree drawn above the preorder traversal is DBACEGF and the inorder traversal is ABCDEFG.
She thought that such a pair of strings would give enough information to reconstruct the tree later (but she never tried it).

Now, years later, looking again at the strings, she realized that reconstructing the trees was indeed possible, but only because she never had used the same letter twice in the same tree.
However, doing the reconstruction by hand, soon turned out to be tedious.
So now she asks you to write a program that does the job for her!


The input will contain one or more test cases.
Each test case consists of one line containing two strings preord and inord, representing the preorder traversal and inorder traversal of a binary tree. Both strings consist of unique capital letters. (Thus they are not longer than 26 characters.)
Input is terminated by end of file.


For each test case, recover Valentine's binary tree and print one line containing the tree's postorder traversal (left subtree, right subtree, root).
Sample Input

Sample Output




typedef struct node
char value;
struct node* left;
struct node* right;
tree* binarytree(char* preord,char* inord,int length)
if (length < 1)
return NULL;
tree* tmp=(tree*)malloc(sizeof(tree));
tmp->value = preord;
tmp->left = NULL;
tmp->right = NULL;
if (length != 1)
point = strchr(inord, preord);
int l = point - inord;
tmp->left = binarytree(preord + 1, inord, l);
tmp->right = binarytree(preord + l+1, point+1, length - l - 1);
return tmp;
void postorder(tree
if (postord->left != NULL)
printf("%c", postord->value);
void main()
char line[100][100];
int i = 0;
char *preord;
char *inord;
while (strlen(gets(line[i])) != 0)
for (int j = 0; j < i; j++) {
preord = strtok(line[j], " ");
inord = strtok(NULL, " ");
postorder(binarytree(preord, inord, strlen(preord)));

编程介的小学生 不行
一年多之前 回复
Csdn user default icon



#include <stdio.h> #include <stdlib.h> #include <string.h>//head file typedef struct BiNode{ char data; struct BiNode *lchild,*rchild; }BiTNode,*BiTree;//data and stucture void InitBiTree(BiTree T){ T=NULL;//input } void Create(BiTree &T) { char ch[2]; scanf("%s",&ch[0]); if(strcmp(ch,"@")==0) { T=NULL; }else{ T=(BiTree)malloc(sizeof(BiNode)); T->data=ch[0]; Create(T->lchild); Create(T->rchild); } } void visit(char c){ printf("%c",c); } void PreOrderTraverse(BiTree T){ if(T){ visit(T->data); PreOrderTraverse(T->lchild); PreOrderTraverse(T->rchild); } } void InOrderTraverse(BiTree T){ if(T){ InOrderTraverse(T->lchild); visit(T->data); InOrderTraverse(T->rchild); } } void PostOrderTraverse(BiTree T){ if(T){ PostOrderTraverse(T->lchild); PostOrderTraverse(T->rchild); visit(T->data); } } int depth(BiTree T){ int ldeep,rdeep; if(!T) return 0; else{ ldeep=depth(T->lchild); rdeep=depth(T->rchild); return ldeep>rdeep?ldeep:rdeep+1; } } int main(){ BiTree T; int deep; InitBiTree(T); printf("请输入序列\n"); Create(T); deep=depth(T); printf("\n深度:%d\n二叉树构建完毕",deep); printf("\n先序遍历二叉树:"); PreOrderTraverse(T); printf("\n中序遍历二叉树:"); InOrderTraverse(T); printf("\n后序遍历二叉树:"); PostOrderTraverse(T); return 0; } 这个建立二叉树的输入语句哪里不对嘛?输入的内容是12@@3@@。 输入之后并没有什么反应,并非机子的问题。 除了输入的问题,是不是还有其他的问题在呢?比如说其他版块是不是出错了呢? 烦请指教。



c语言 判断二叉树是否为完全二叉树

新手渣渣 请教各位大神 问题出在哪 谢谢 #include <stdio.h> #include <stdlib.h> #define TRUE  1 #define FALSE 0 #define OK 1 #define ERROR 0 typedef char TElemType; typedef int Status; typedef struct BiTNode{ TElemType data2; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; typedef struct QNode { BiTree data1;           struct QNode *next; }QNode,*QueuePtr; typedef struct  { QueuePtr front;   //队头指针 QueuePtr rear;    //队尾指针  }LinkQueue; Status InitQueue(LinkQueue *Q);             //关于队列的函数声明  Status EnQueue(LinkQueue *Q,BiTree e); Status DeQueue(LinkQueue *Q,BiTree *e); Status QueueEmpty(LinkQueue Q); Status InitBiTree(BiTree *T);               //关于二叉树的函数声明  Status CreateBiTree(BiTree *T);   //啥意思啊 那个defination  Status InOrderTraverse(BiTree T); int Check(BiTree T); Status InitQueue(LinkQueue *Q)    { Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode)); if(!Q->front) exit(OVERFLOW); Q->front->next=NULL; return OK;  }  Status EnQueue(LinkQueue *Q,BiTree e)    { QNode *p; p=(QueuePtr)malloc(sizeof(QNode));    if(!p) exit(OVERFLOW); p->data1->data2=e->data2; p->data1->lchild=e->lchild; p->data1->rchild=e->rchild; p->next=NULL; Q->rear->next=p;     Q->rear=p;          return OK;  }  Status DeQueue(LinkQueue *Q,BiTree *e)   { if(Q->front==Q->rear) return ERROR; QNode *p; p=Q->front->next; (*e)->data2=p->data1->data2; (*e)->lchild=p->data1->lchild; (*e)->rchild=p->data1->rchild; Q->front->next=p->next; if(Q->rear==p)           Q->rear=Q->front;   free(p); return OK; }  Status QueueEmpty(LinkQueue Q)    { if(Q.front==Q.rear) return TRUE; else return FALSE; }  Status InitBiTree(BiTree *T)      { *T=NULL; return OK; }   Status CreateBiTree(BiTree *T)      { char ch; scanf("%c",&ch); if(ch=='*') { *T=NULL; } else { *T=(BiTree)malloc(sizeof(BiTNode)); (*T)->data2=ch; CreateBiTree(&(*T)->lchild); CreateBiTree(&(*T)->rchild); } return OK; } Status InOrderTraverse(BiTree T)    { if(T==NULL) return 0; else { InOrderTraverse(T->lchild); printf("%c",T->data2); InOrderTraverse(T->rchild); } return OK; } int Check(BiTree T)     { BiTree S; LinkQueue Q; int flag=0; if(T) { InitQueue(&Q); EnQueue(&Q,T);             while(!(QueueEmpty(Q)))    { DeQueue(&Q,&S);       if(!S) {       flag=1; } else  { if(flag) return 0; else { EnQueue(&Q,(S->lchild)); EnQueue(&Q,(S->rchild)); } } } } printf("\n"); return 1; } int main() { BiTree T; int n; InitBiTree(&T); CreateBiTree(&T); printf("\n中序遍历二叉树:"); InOrderTraverse(T); n=Check(T); printf("判断是否为完全二叉树 1-是 0-否:%d\n",n); return 0; }


#include <stdio.h> #include <stdlib.h> typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild; } BiTNode,*BiTree;//定义结点类型 BiTree CreateBiTree()//创建树 { char p;BiTree T; scanf("%c",&p); if(p == '$') T=NULL; else { T=(BiTNode *)malloc(sizeof(BiTNode));//为结点开辟空间 T->data=p; T->lchild=CreateBiTree(); T->rchild=CreateBiTree(); } return (T); } void PostOrder(BiTree T)//后序 { if(T!=NULL) { PostOrder(T->lchild); PostOrder(T->rchild); printf("%c",T->data); } } void main()//主函数 { BiTree Ta; Ta=CreateBiTree(); PostOrder(Ta); }


![图片说明](https://img-ask.csdn.net/upload/201908/29/1567008482_442997.jpg) 黑笔部分代码不是用来求二叉树的高度吗,怎么又能算二叉树的结点个数了,求解答

C语言求二叉树上的节点路径 求源程序,不胜感激


数据结构 C语言版 二叉树



Problem Description There are some queries on a tree which has n nodes. Every query is described as two integers (X, Y).For each query, you should find the maximum weight of the edges in set E, which satisfies the following two conditions. 1) The edge must on the path from node X to node 1. 2) The edge’s weight should be lower or equal to Y. Now give you the tree and queries. Can you find out the answer for each query? Input The first line of the input is an integer T, indicating the number of test cases. For each case, the first line contains an integer n indicates the number of nodes in the tree. Then n-1 lines follows, each line contains three integers X, Y, W indicate an edge between node X and node Y whose value is W. Then one line has one integer Q indicates the number of queries. In the next Q lines, each line contains two integers X and Y as said above. Output For each test case, you should output Q lines. If no edge satisfy the conditions described above,just output “-1” for this query. Otherwise output the answer for this query. Sample Input 1 3 1 2 7 2 3 5 4 3 10 3 7 3 6 3 4 Sample Output 7 7 5 -1


Problem Description Today CodeFamer is going to cut trees.There are N trees standing in a line. They are numbered from 1 to N. The tree numbered i has height hi. We say that two uncutted trees whose numbers are x and y are in the same block if and only if they are fitting in one of blow rules: 1)x+1=y or y+1=x; 2)there exists an uncutted tree which is numbered z, and x is in the same block with z, while y is also in the same block with z. Now CodeFamer want to cut some trees whose height is not larger than some value, after those trees are cut, how many tree blocks are there? Input Multi test cases (about 15). For each case, first line contains two integers N and&#160;Q separated by exactly one space, N indicates there are N trees, Q indicates there are Q queries. In the following N lines, there will appear h[1],h[2],h[3],…,h[N] which indicates the height of the trees. In the following Q lines, there will appear q[1],q[2],q[3],…,q[Q] which indicates CodeFamer’s queries. Please process to the end of file. [Technical Specification] 1≤N,Q≤50000 0≤h[i]≤1000000000(109) 0≤q[i]≤1000000000(109) Output For each q[i], output the number of tree block after CodeFamer cut the trees whose height are not larger than q[i]. Sample Input 3 2 5 2 3 6 2 Sample Output 0 2

为什么根据前序输入可以构造二叉树, 但是知道前序遍历不能确定二叉树? 二者有什么区别?

为什么根据前序输入可以构造二叉树, 但是知道前序遍历不能确定二叉树? 二者有什么区别?


用的递归的方法查找元素 有点类似于二叉树建立 代码如下 ``` struct node *search(struct node *n,int v){//查找 struct node *p; p=n; if(p->value==v){//找到 return p; } else if(v<p->value){//左边部分查找 if(p->left==NULL) return NULL;//未找到 else{ p=p->left; search(p,v); } } else{//v>p->value,右边部分查找 if(p->right==NULL) return NULL;//未找到 else{ p=p->right; search(p,v); } } } ``` main方法中:point=search(root,20); 用这种方法 总是返回根节点的值 而不是要查找的值或者null


#include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX 100 typedef struct node {char name[10] ; struct node *lchild, *rchild; }BTree; BTree *q[MAX]; /*存储队列元素的数组*/ BTree *CreatBtree(); /* 创建二叉家族树 */ void ScanLevel(BTree *bt); /* 按层次顺序遍历二叉家族树 */ int FindAncestry(BTree *bt,char *ch,int flag); void Precreat(BTree *bt); void InorderTraverse(BTree *bt); int main() { BTree *head; int ch; char cname[10]; while(1) { printf("请选择以下操作:\n"); printf ("一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一\n"); printf("1……创建一个二叉家族树\n"); printf("2……按层次输出二叉家族树\n"); printf("3……输出某个成员的所有祖先成员\n"); printf("4……结束程序\n"); printf ("一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一一\n"); printf("请选择(1--4):"); scanf("%d",&ch); getchar(); switch(ch) { case 1: /* 创建二叉家族树 */ Precreat(head); printf("\n二叉家族树创建成功!\n"); printf("\n请按任意键返回主菜单..."); getchar(); break; case 2:printf("按层次输出二叉家族树:\n");/* 按层次输出家族树 */ ScanLevel(head); printf("\n中序遍历输出二叉树\n"); InorderTraverse(head);//中序遍历整个数组 printf("\n请按任意键返回主菜单..."); break; case 3:printf("\n请输入要查找哪个成员的祖先:\n"); scanf("%s",cname); getchar(); FindAncestry(head,cname,0); printf("\n请按任意键返回主菜单..."); break; case 4: exit(0); } getchar(); } } void ScanLevel(BTree *bt) /*按层次顺序遍历二叉家族树 */ { int front=0,rear=0; /* 初始化队列的头、尾指针 */ if(bt!=NULL) { rear++; q[rear]=bt; /* 将bt所指向的结点入队 */ } while(front!=rear) /* 队列非空 */ { front++; bt=q[front]; /* 队头结点出队 */ printf (" %s",bt->name); /* 输出该结点的数据 */ if(bt->lchild!=NULL) { rear++; q[rear]=bt->lchild; /* 将左孩子结点入队 */ } if(bt->rchild!=NULL) {rear++; q[rear]=bt->rchild; /* 将右孩子结点入队 */ } } } int FindAncestry(BTree *bt,char *ch,int flag) { int flag1=0,flag2=0; int cond; if(flag==0&&strcmp(bt->name,ch)==0) { printf("这个人是最大的祖先!!!\n"); return 0; } flag=1; if(bt==NULL||(bt->lchild==NULL&&bt->rchild==NULL)) return 0; cond=(bt->lchild!=NULL)&&(strcmp(bt->lchild->name,ch)==0); cond=cond||((bt->rchild!=NULL)&&(strcmp(bt->rchild->name,ch)==0)); if(cond) { printf("%s,",bt->name); return 1; } else { flag1=FindAncestry(bt->lchild,ch,flag); flag2=FindAncestry(bt->rchild,ch,flag); if(flag1||flag2) { printf("%s,",bt->name); return 1; } else return 0; } } void Precreat(BTree *bt) { char ch1[10]; scanf("%s",ch1); if(strcmp(ch1,"$")) { bt=NULL; } else { bt=(BTree*)malloc(sizeof(BTree)); strcpy(bt->name,ch1); Precreat(bt->lchild); Precreat(bt->rchild); } printf("建立完成"); return; } void InorderTraverse(BTree *bt) //中序遍历整个数组 { if(bt) { InorderTraverse(bt->lchild); printf(" %s",bt->name); InorderTraverse(bt->rchild); } } 写precreat函数,要求$为结束符@为空


#include"stdio.h" #include"stdlib.h" #define OK 1 #define ERROR 0 #define OVERFLOW -1 typedef char TElemType; typedef struct BiTNode{ TElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; typedef int Status; typedef struct LNode{ BiTree data; struct LNode *next; }LNode; typedef struct{ LNode *top; }LStack; int main(){ Status CreateBiTree(BiTree &T); Status Pop(LStack &S); Status Init_Stack(LStack &S); Status Push(LStack &S,BiTree T); Status StackEmpty(LStack S); Status PreOrderTraverse(BiTree T); void visit(TElemType data); BiTree T; printf("创建树中..."); if(CreateBiTree(T)) printf("创建成功\n"); PreOrderTraverse(T); return 0; } Status CreateBiTree(BiTree &T){ TElemType ch; scanf("%c",&ch); if(ch==' ') T=NULL; else{ T=(BiTNode *)malloc(sizeof(BiTNode)); if(!T) exit(OVERFLOW); T->data = ch; CreateBiTree(T->lchild); CreateBiTree(T->rchild); } return OK; } Status Init_Stack(LStack &S){ LNode *p; p=(LNode *)malloc(sizeof(LNode)); if(!p) exit(OVERFLOW); p->next=NULL; S.top=p; return OK; } Status Push(LStack &S,BiTree T){ LNode *p; p=(LNode *)malloc(sizeof(LNode)); if(!p) exit(OVERFLOW); S.top->data = T; p->next = S.top; S.top = p; return OK; } Status StackEmpty(LStack S){ if(S.top==NULL) return 1; else return 0; } void visit(TElemType data){ printf("%c\n",data); } BiTree Pop(LStack &S){ BiTree tran; LNode *t; tran=S.top->data; t=S.top; S.top=S.top->next; free(t); return tran; } Status PreOrderTraverse(BiTree T){ LStack S; Init_Stack(S); BiTree p; p=T; while(p||!(StackEmpty(S))){ if(p){ Push(S,p); p=p->lchild; } else{ p=Pop(S); visit(p->data); p=p->rchild; } } return OK; } //源代码如上,程序运行,我输入ABC DE G F 建立二叉树那一段可以运行,到了二叉树遍历的时候程序无法运行自动关闭,麻烦各位了!


``` #include<stdio.h> #include<stdlib.h> typedef struct node { int num; struct node *l; struct node *r; }LN; void Creat(LN *L); void Change(LN *L); int Print(int n); void main() { LN *L; int n; ii: printf("Press 0 to end: \n"); printf("Press 1 to Creat a Linklist: \n"); printf("Press 2 to Change the child: \n"); scanf("%d",&n); switch(n) { case 0: system("CLS"); goto cc; case 1: system("CLS"); printf("Input the root number: \n"); Creat(L); system("CLS"); break; case 2: Change(L); break; } goto ii; cc:; } void Creat(LN *L) { int n; scanf("%d",&n); if(n==0) { L=NULL; } else { L=(LN*)malloc(sizeof(LN)); L->num=n; printf("Creat %d's leftchlid: \n",n); Creat(L->l); printf("Creat %d's rightchild: \n",n); Creat(L->r); } } void Change(LN *L) { if (L!=NULL) { printf("%d",L->num); Change(L->l); Change(L->r); } } ``` 我的Change函数是先序遍历,小弟刚学实在不知道错在哪里。怎么从先序遍历算法中交换左右孩子,谢谢大神门!!!!! 还有怎么按层次遍历,感觉按层次没有办法用递归算法 如果我要想从大到小的顺序输出二叉排序树的各结点的算法,怎么实现,跪求大神门的指教,感谢!


自己编的c语言建立二叉树的代码,运行时出错了,自己找不到错误,求大神帮忙,指点,急. #include<stdio.h> #include<stdlib.h> typedef struct tnode Tnode; struct tnode { Tnode *left; Tnode *right; int data; }; Tnode *new_tnode(int data) { Tnode *new = malloc(sizeof(Tnode)); new->left=NULL; new->right=NULL; new->data=data; return new; } void insert(Tnode *root,Tnode *tree) { if(root==NULL) { tree=root; return; } if(root->data<tree->data) { tree->left=root; insert(root,tree->left); } else if(root->data>tree->data) { tree->right=root; insert(root,tree->right); } } void printout(Tnode *tree) { if(tree==NULL) { return; } printf("%d",tree->data); printout(tree->left); printout(tree->right); } int main() { Tnode *tree=NULL; int i; int data; for(i=0;i<10;i++) { scanf("%d",&data); insert(new_tnode(data),tree); } printout(tree); return 0; }


代码一运行就停止工作,求助大神,看看我的问题是什么 ``` #include<stdio.h> #include<stdlib.h> typedef struct treeNode//定义 { int data; struct treeNode *left; struct treeNode *right; }treenode,*TreeNode; void pre(TreeNode node)//前序遍历 { if(node==NULL) return ; printf("%d ", node->data); pre(node->left); pre(node->right); } void mid(TreeNode node)//中序遍历 { if(node==NULL) return ; mid(node->left); printf("%d ", node->data); mid(node->right); } void beh(TreeNode node)//后序遍历 { if(node==NULL) return ; beh(node->left); beh(node->right); printf("%d ", node->data); } void tree(TreeNode one)//定义一个现成的二叉树 { one=(TreeNode*)malloc(sizeof(treenode)); one->left=(TreeNode*)malloc(sizeof(treenode)); one->right=(TreeNode*)malloc(sizeof(treenode)); one->right->left=(TreeNode*)malloc(sizeof(treenode)); one->right->right=(TreeNode*)malloc(sizeof(treenode)); one->left->left=(TreeNode*)malloc(sizeof(treenode)); one->left->right=(TreeNode*)malloc(sizeof(treenode)); one->right->left->left=(TreeNode*)malloc(sizeof(treenode)); one->right->left->right=(TreeNode*)malloc(sizeof(treenode)); one->right->right->left=(TreeNode*)malloc(sizeof(treenode)); one->right->right->right=(TreeNode*)malloc(sizeof(treenode)); one->data=3; one->left->data=9; one->right->data=20; one->right->left->data=15; one->right->right->data=7; } void main()//主方法 { TreeNode one; tree(one); printf("该二叉树的前序遍历为:\n"); pre(one); printf("该二叉树的中序遍历为:\n"); mid(one); printf("该二叉树的后序遍历为:\n"); beh(one); } ```


#include<cstdio> #include<cstdlib> #include<cstring> using namespace std; typedef struct Btree { struct Btree *left; struct Btree *right; char data; }Node; void Create_Btree(Node *tree, char *pre, int pre_low, int pre_high, char *middle, int middle_low, int middle_high) { tree = (Node *)malloc(sizeof(Node)); tree->data = pre[pre_low]; tree->left = NULL; tree->right = NULL; printf("shuju:%c %d %d\n", tree->data, tree->left, tree->right); //计算树根在中序遍历中的下标 int root = middle_low; int i = root; while(pre[pre_low] != middle[i]) { i++; root++; } printf("root : %d\n", root); //中序左子树的长度 int left_length = root - middle_low; printf("%d--%d %d--%d\n", pre_low + 1, pre_low + left_length, middle_low, root - 1); printf("%d--%d %d--%d\n", pre_low + left_length + 1, pre_high, root + 1, middle_high); //遍历创建左子树 if(root > middle_low) { printf("left\n"); Create_Btree(tree->left, pre, pre_low + 1, pre_low + left_length, middle, middle_low, root - 1); } //遍历创建右子树 if(root < middle_high) { printf("right\n"); Create_Btree(tree->right, pre, pre_low + left_length + 1, pre_high, middle, root + 1, middle_high); } } void Post_order(Node *head) { printf("%d\n", head); if(head == NULL) return; else Post_order(head->left); Post_order(head->right); printf("%c", head->data); } int main() { char pre_order[27]; char middle_order[27]; while(~scanf("%s %s", pre_order, middle_order) && pre_order != "") { printf("%s\n%s\n", pre_order, middle_order); if(pre_order[1] == '\0') { printf("%c\n", pre_order[0]); continue; } else { Node *tree; int len = strlen(pre_order); Create_Btree(tree, pre_order, 0 , len - 1, middle_order, 0, len - 1); Post_order(tree); printf("\n"); } } } 哪位大神能运行一下 每次读地址就是post_order()函数里面 读取head-》left 就错误了。 printf("%c:::%d:::%d\n", head->data, head->left, head->right);


先序建立二叉树中查找孩子返回双亲那快函数怎么执行都是显示找不到双亲。大佬帮看看是我哪写错了呗。以下是完整代码: #include<cstdio> #include<cstdlib> #include<algorithm> using namespace std; typedef char DataType; typedef struct BitNode { DataType data; struct BitNode *lchild,*rchild; //创建左右节点 }*BitTree; /*初始化一个二叉树*/ void Init(BitTree &BT) { BT = (BitTree)malloc(sizeof(BitNode)); BT->data = NULL; return; } //先序建立二叉树 int BinTreeCreate(BitTree &BT) { char ch; scanf("%c", &ch); if(ch == '$') BT = NULL; else{ BT = (BitTree)malloc(sizeof(BitNode)); BT->data = ch; BinTreeCreate(BT->lchild); BinTreeCreate(BT->rchild); } return 0; } /*判断二叉树是否为空*/ bool BinTreeEmpty(BitTree BT) { if(BT == NULL) return true; return false; } /*先序遍历二叉树*/ void BinTraverse(BitTree BT) { if(BT == NULL) return; printf("%c",BT->data); if(BT->lchild != NULL) BinTraverse(BT->lchild); if(BT->rchild != NULL); BinTraverse(BT->rchild); } /*中序遍历二叉树*/ void MidTraverse(BitTree BT) { if(BT == NULL)return; MidTraverse(BT->lchild); printf("%c",BT->data); MidTraverse(BT->rchild); } /*后序遍历二叉树*/ void BhTraverse(BitTree BT) { if(BT == NULL)return; BhTraverse(BT->lchild); BhTraverse(BT->rchild); printf("%c",BT->data); } /*q求二叉树结点数*/ int BinTreeCount(BitTree BT) { int cnt; if(BT) { int cntLeft = BinTreeCount(BT->lchild); int cntRight = BinTreeCount(BT->rchild); cnt = cntLeft + cntRight + 1;//左子树的结点数加上右子树的结点数 } else cnt = 0; return cnt; } /*查找孩子返回双亲*/ BitTree back(BitTree T , char str){ if(T == NULL) return NULL ; if(T->lchild!= NULL&&T->lchild->data == str) { return T; } if(T->rchild!= NULL&&T->rchild->data == str){ return T; } else{ // back(T->lchild,str); // back(T->rchild,str); BitNode* P=NULL; if(P=back(T->lchild,str)) return P; if(P=back(T->rchild,str)) return P; } return NULL; } int main(){ BitTree BT; printf("<------欢迎使用二叉树系统------->\n"); printf("<------1.初始化二叉树----------->\n"); printf("<------2.先序建立二叉树--------->\n"); printf("<------3.判断二叉树是否为空----->\n"); printf("<------4.先序遍历二叉树--------->\n"); printf("<------5.中序遍历二叉树--------->\n"); printf("<------6.后序遍历二叉树--------->\n"); printf("<------7.求二叉树结点数--------->\n"); printf("<------8.查找孩子返回双亲------->\n"); printf("<------9.退出------------------->\n"); while(1){ int choose; char ch; BitTree T = NULL; BitTree p = NULL; printf("请输入选择:"); scanf("%d",&choose); if(choose == 9)break; switch(choose) { case 1: Init(BT); break; case 2: printf("请输入二叉树的元素:"); getchar(); BinTreeCreate(BT); break; case 3: if(BinTreeEmpty(BT)) printf("二叉树为空!\n"); else printf("二叉树不为空!\n"); break; case 4: printf("先序遍历二叉树序列如下:"); BinTraverse(BT); printf("\n"); break; case 5: printf("中序遍历二叉树序列如下;"); MidTraverse(BT); printf("\n"); break; case 6: printf("后序遍历二叉树序列如下:"); BhTraverse(BT); printf("\n"); break; case 7: printf("二叉树的结点数为 %d\n", BinTreeCount(BT)); break; case 8: printf("\n请输入要查找的值:"); getchar(); scanf("%c",&ch); back(T,ch); if(T==NULL){ printf("输入的值不存在双亲!!\n"); } else{ printf("输入结点的双亲为:%c",T); } break; } } return 0; }


软件测试2小时入门,让您快速了解软件测试基本知识,有系统的了解; SQL一小时,让您快速理解和掌握SQL基本语法 jmeter性能测试 ,让您快速了解主流来源性能测试工具jmeter 测试管理工具-禅道,让您快速学会禅道的使用,学会测试项目、用例、缺陷的管理、



Java 最常见的 200+ 面试题:面试必备

这份面试清单是从我 2015 年做了 TeamLeader 之后开始收集的,一方面是给公司招聘用,另一方面是想用它来挖掘在 Java 技术栈中,还有那些知识点是我不知道的,我想找到这些技术盲点,然后修复它,以此来提高自己的技术水平。虽然我是从 2009 年就开始参加编程工作了,但我依旧觉得自己现在要学的东西很多,并且学习这些知识,让我很有成就感和满足感,那所以何乐而不为呢? 说回面试的事,这份面试...




总课时80+,提供源码和相关资料 本课程从Python零基础到纯Python项目实战。内容详细,案例丰富,覆盖了Python知识的方方面面,学完后不仅对Python知识有个系统化的了解,让你从Python小白变编程大牛! 课程包含: 1.python安装 2.变量、数据类型和运算符 3.选择结构 4.循环结构 5.函数和模块 6.文件读写 7.了解面向对象 8.异常处理


获取讲师答疑方式: 在付费视频第一节(触摸命令_ALL)片头有二维码及加群流程介绍 限时福利 原价99元,今日仅需39元!购课添加小助手(微信号:csdn590)按提示还可领取价值800元的编程大礼包! 讲师介绍: 苏奕嘉&nbsp;前阿里UC项目工程师 脚本开发平台官方认证满级(六级)开发者。 我将如何教会你通过【定制脚本】赚到你人生的第一桶金? 零基础程序定制脚本开发课程,是完全针对零脚本开发经验的小白而设计,课程内容共分为3大阶段: ①前期将带你掌握Q开发语言和界面交互开发能力; ②中期通过实战来制作有具体需求的定制脚本; ③后期将解锁脚本的更高阶玩法,打通任督二脉; ④应用定制脚本合法赚取额外收入的完整经验分享,带你通过程序定制脚本开发这项副业,赚取到你的第一桶金!


本课程为HoloLens2开发入门教程,讲解部署开发环境,安装VS2019,Unity版本,Windows SDK,创建Unity项目,讲解如何使用MRTK,编辑器模拟手势交互,打包VS工程并编译部署应用到HoloLens上等。






设置复位开关。当按下复位开关时,秒表清零并做好计时准备。在任何情况下只要按下复位开关,秒表都要无条件地进行复位操作,即使是在计时过程中也要无条件地进行清零操作。 设置启/停开关。当按下启/停开关后,将




董付国系列教材《Python程序设计基础》、《Python程序设计(第2版)》、《Python可以这样学》配套视频,讲解Python 3.5.x和3.6.x语法、内置对象用法、选择与循环以及函数设计与使用、lambda表达式用法、字符串与正则表达式应用、面向对象编程、文本文件与二进制文件操作、目录操作与系统运维、异常处理结构。

计算机操作系统 第三版.pdf

计算机操作系统 第三版 本书全面介绍了计算机系统中的一个重要软件——操作系统(OS),本书是第三版,对2001年出版的修订版的各章内容均作了较多的修改,基本上能反映当前操作系统发展的现状,但章节名称基

技术大佬:我去,你写的 switch 语句也太老土了吧

昨天早上通过远程的方式 review 了两名新来同事的代码,大部分代码都写得很漂亮,严谨的同时注释也很到位,这令我非常满意。但当我看到他们当中有一个人写的 switch 语句时,还是忍不住破口大骂:“我擦,小王,你丫写的 switch 语句也太老土了吧!” 来看看小王写的代码吧,看完不要骂我装逼啊。 private static String createPlayer(PlayerTypes p...

Vue.js 2.0之全家桶系列视频课程

基于新的Vue.js 2.3版本, 目前新全的Vue.js教学视频,让你少走弯路,直达技术前沿! 1. 包含Vue.js全家桶(vue.js、vue-router、axios、vuex、vue-cli、webpack、ElementUI等) 2. 采用笔记+代码案例的形式讲解,通俗易懂


本套课程的设计完全是为初学者量身打造,课程内容由浅入深,课程讲解通俗易懂,代码实现简洁清晰。通过本课程的学习,学员能够入门微信公众平台开发,能够胜任企业级的订阅号、服务号、企业号的应用开发工作。 通过本课程的学习,学员能够对微信公众平台有一个清晰的、系统性的认识。例如,公众号是什么,它有什么特点,它能做什么,怎么开发公众号。 其次,通过本课程的学习,学员能够掌握微信公众平台开发的方法、技术和应用实现。例如,开发者文档怎么看,开发环境怎么搭建,基本的消息交互如何实现,常用的方法技巧有哪些,真实应用怎么开发。


【为什么学爬虫?】 &nbsp; &nbsp; &nbsp; &nbsp;1、爬虫入手容易,但是深入较难,如何写出高效率的爬虫,如何写出灵活性高可扩展的爬虫都是一项技术活。另外在爬虫过程中,经常容易遇到被反爬虫,比如字体反爬、IP识别、验证码等,如何层层攻克难点拿到想要的数据,这门课程,你都能学到! &nbsp; &nbsp; &nbsp; &nbsp;2、如果是作为一个其他行业的开发者,比如app开发,web开发,学习爬虫能让你加强对技术的认知,能够开发出更加安全的软件和网站 【课程设计】 一个完整的爬虫程序,无论大小,总体来说可以分成三个步骤,分别是: 网络请求:模拟浏览器的行为从网上抓取数据。 数据解析:将请求下来的数据进行过滤,提取我们想要的数据。 数据存储:将提取到的数据存储到硬盘或者内存中。比如用mysql数据库或者redis等。 那么本课程也是按照这几个步骤循序渐进的进行讲解,带领学生完整的掌握每个步骤的技术。另外,因为爬虫的多样性,在爬取的过程中可能会发生被反爬、效率低下等。因此我们又增加了两个章节用来提高爬虫程序的灵活性,分别是: 爬虫进阶:包括IP代理,多线程爬虫,图形验证码识别、JS加密解密、动态网页爬虫、字体反爬识别等。 Scrapy和分布式爬虫:Scrapy框架、Scrapy-redis组件、分布式爬虫等。 通过爬虫进阶的知识点我们能应付大量的反爬网站,而Scrapy框架作为一个专业的爬虫框架,使用他可以快速提高我们编写爬虫程序的效率和速度。另外如果一台机器不能满足你的需求,我们可以用分布式爬虫让多台机器帮助你快速爬取数据。 &nbsp; 从基础爬虫到商业化应用爬虫,本套课程满足您的所有需求! 【课程服务】 专属付费社群+每周三讨论会+1v1答疑




&nbsp; &nbsp; &nbsp; &nbsp; 本课程为Python数据挖掘方向的入门课程,课程主要以真实数据为基础,详细介绍数据挖掘入门的流程和使用Python实现pandas与numpy在数据挖掘方向的运用,并深入学习如何运用scikit-learn调用常用的数据挖掘算法解决数据挖掘问题,为进一步深入学习数据挖掘打下扎实的基础。

2019 AI开发者大会

2019 AI开发者大会(AI ProCon 2019)是由中国IT社区CSDN主办的AI技术与产业年度盛会。多年经验淬炼,如今蓄势待发:2019年9月6-7日,大会将有近百位中美顶尖AI专家、知名企业代表以及千余名AI开发者齐聚北京,进行技术解读和产业论证。我们不空谈口号,只谈技术,诚挚邀请AI业内人士一起共铸人工智能新篇章!


发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java Development Kit 的简称,java 开发工具包,提供了 java 的开发环境和运行环境。 JRE:Java Runtime Environ...

定量遥感中文版 梁顺林著 范闻捷译


GIS程序设计教程 基于ArcGIS Engine的C#开发实例

张丰,杜震洪,刘仁义编著.GIS程序设计教程 基于ArcGIS Engine的C#开发实例.浙江大学出版社,2012.05


系列课程主要分为3大阶段:(1)首先掌握计算机视觉必备算法原理,结合Opencv进行学习与练手,通过实际视项目进行案例应用展示。(2)进军当下最火的深度学习进行视觉任务实战,掌握深度学习中必备算法原理与网络模型架构。(3)结合经典深度学习框架与实战项目进行实战,基于真实数据集展开业务分析与建模实战。整体风格通俗易懂,项目驱动学习与就业面试。 建议同学们按照下列顺序来进行学习:1.Python入门视频课程 2.Opencv计算机视觉实战(Python版) 3.深度学习框架-PyTorch实战/人工智能框架实战精讲:Keras项目 4.Python-深度学习-物体检测实战 5.后续实战课程按照自己喜好选择就可以




微信小程序番茄时钟视频教程,本课程将带着各位学员开发一个小程序初级实战类项目,针对只看过官方文档而又无从下手的开发者来说,可以作为一个较好的练手项目,对于有小程序开发经验的开发者而言,可以更好加深对小程序各类组件和API 的理解,为更深层次高难度的项目做铺垫。

面试了一个 31 岁程序员,让我有所触动,30岁以上的程序员该何去何从?




用verilog HDL语言编写的秒表




相关热词 c# 开发接口 c# 中方法上面的限制 c# java 时间戳 c#单元测试入门 c# 数组转化成文本 c#实体类主外键关系设置 c# 子函数 局部 c#窗口位置设置 c# list 查询 c# 事件 执行顺序