struct BT *buildBT(int i[],int p[],int st,int en)
{
if(st>en)
return NULL;
static int pin=0;
struct BT *root=nn(p[pin]);
++pin;
if(st==en)
return root;
int inin=search(i,st,en,root->data);
root->l=buildBT(i,p,st,inin-1);
root->r=buildBT(i,p,inin+1,en);
return root;
}
struct BT *build(int in[],int p[],int start,int end)
{
if(start>end)
return NULL;
static int pin=0;
struct BT *root=nn(p[pin]);
pin;
if(start==end)
return root;
int inin=(in,start,end,root->data);
root->l=buildBT(in,p,start,inin-1);
root->r=buildBT(in,p,inin+1,end);
return root;
}
BTNode *buildBT(int pre[], int in[], int l1, int r1, int l2, int r2) {
int i;
if ( l1 > r1 || l2 > r2) return NULL;
BTNode *p = (BTNode*)malloc(sizeof(BTNode));
p->key = pre[l1];
p->left = NULL;
p->right = NULL;
for (i = l2; i <= r2; i ++)
if (in[i] == pre[l1])
break;
p->left = buildBT(pre, in, l1 + 1, l1 + i - l2, l2, i - 1);
p->right = buildBT(pre, in, l1 + i - l2 + 1, r1, i + 1, r2);
return p;
}
int main() {
BTNode *bt, *p;
int n;
scanf("%d", &n);
initBT(&bt, n);
printf("************preorder***********\n");
preorder(bt);
printf("\n");
printf("************inorder************\n");
inorder(bt);
printf("\n");
printf("*************postorder*********\n");
postorder(bt);
printf("\n");
printf("*************level*************\n");
level(bt);
printf("\n");
printf("maxNode: %d\n", maxNode(bt));
printf("countNodes: %d\n", countNodes(bt));
printf("getDepth: %d\n", getDepth(bt));
p = buildBT(pre, in, 0, pre_index - 1, 0, in_index - 1);
printf("*********************************\n");
level(p);
printf("\n");
return 0;
}
Message* Parser::parseMessage(uint64_t& reference, uint64_t& match) {
char test = '\0';
if (!binaryData.get(test)) return NULL;
binaryData.get(test);
uint32_t size = test - '\0';
binaryData.read(buffer, size);
printProgress(size + 2);
switch (*buffer) {
case 'R':
return buildSD(buffer);
break;
case 'A':
case 'F':
return buildAO(buffer, reference);
break;
case 'E':
return buildOE(buffer, reference, match);
break;
case 'C':
return buildOEWP(buffer, reference, match);
break;
case 'D':
return buildOD(buffer, reference);
break;
case 'U':
return buildOR(buffer, reference);
break;
case 'P':
case 'Q':
return buildT(buffer, match);
break;
case 'B':
return buildBT(buffer, match);
break;
default: {
//cout << "skipping non-relevant message, type: " << *buffer << endl;
return new Message('\0');
}
}
}
