tree_node *create_tree(order_node *in,order_node *pre,int num)
{
tree_node *temp;
order_node *q;
int i,j;
if(num==0)
return NULL;
temp=(tree_node*)malloc(sizeof(tree_node));
temp->num=pre->num;
temp->lchild=NULL;
temp->rchild=NULL;
if(num==1)
return temp;
q=in;
for(i=0;q->num!=pre->num;++i)
{
q=q->next;
}
temp->lchild=create_tree(in,pre->next,i);
for(j=1;j<=i+1;++j)
{
pre=pre->next;
}
temp->rchild=create_tree(q->next,pre,num-i-1);
return temp;
}
void create_tree(node *root)
{
char c;
// if(root==NULL)
{
root->left=NULL;
root->right=NULL;
}
printf("Enter the node \n");
scanf("%d",&(root->data));
printf("Does %d have a left node ??",root->data);
fflush(stdin);
scanf("%c",&c);
if(c=='y')
{
root->left= (node*)malloc(sizeof(node));
create_tree(root->left);
}
fflush(stdin);
printf("Does %d have a right node ??",root->data);
scanf("%c",&c);
if(c=='y')
{
root->right= (node*)malloc(sizeof(node));
create_tree(root->right);
}
}
pnode_t create_tree(char * str, int len)
{
pnode_t p = NULL;
char *strl, *strr;
int numl, numr, i;
int item = 0;
if(len <= 2)
return NULL;
for (i = 0; i < len; i++)
{
printf("%c", str[i]);
}
printf("\n");
if(str[0] == '(' && str[len - 1] == ')'){
strl = str + 1;
while(*strl != '('){
item = item*10 + (*strl - '0');
strl++;
}
printf("item = %d\n", item);
p = create(item);
numl = find(strl);
p->l = create_tree(strl, numl);
strr = strl + numl;
numr = find(strr);
p->r = create_tree(strr, numr);
}
return p;
}
void build_tree(BiTreePtr pT){
SqQueue *Q = create_queue_seq(NULL, sizeof(BiTreePtr));
enqueue_seq(Q, &pT);
while (!queue_seq_empty(Q)) {
BiTreePtr T = NULL;
dequeue_seq(Q, &T);
if (!queue_seq_empty(T->pdata->unpickedQueue)) {
BiTreePtr lchildT = create_tree(NULL);
BiTreePtr rchildT = create_tree(NULL);
char chPick;
lchildT->pdata->unpickedQueue = copy_queue_seq(T->pdata->unpickedQueue);
lchildT->pdata->pickedQueue = copy_queue_seq(T->pdata->pickedQueue);
dequeue_seq(lchildT->pdata->unpickedQueue, &chPick);
enqueue_seq(lchildT->pdata->pickedQueue, &chPick);
rchildT->pdata->unpickedQueue = copy_queue_seq(lchildT->pdata->unpickedQueue);
rchildT->pdata->pickedQueue = copy_queue_seq(T->pdata->pickedQueue);
T->lchild = lchildT;
T->rchild = rchildT;
enqueue_seq(Q, &T->lchild);
enqueue_seq(Q, &T->rchild);
}
}
desotry_queue_seq(Q);
}
int create_tree(quad_tree tree[], char str[], int pos, int width, int *black_count)
{
int new_pos;
tree[pos].type = str[pos];
tree[pos].width = width;
if(str[pos] == 'p')
{
int bc;
tree[pos].rt = &tree[pos+1];
new_pos = create_tree(tree, str, pos+1, width/2, &bc);
tree[pos].black_count = bc;
tree[pos].lt = &tree[new_pos];
new_pos = create_tree(tree, str, new_pos, width/2, &bc);
tree[pos].black_count += bc;
tree[pos].lb = &tree[new_pos];
new_pos = create_tree(tree, str, new_pos, width/2, &bc);
tree[pos].black_count += bc;
tree[pos].rb = &tree[new_pos];
new_pos = create_tree(tree, str, new_pos, width/2, &bc);
tree[pos].black_count += bc;
*black_count = tree[pos].black_count;
return new_pos;
}
else
{
*black_count = tree[pos].black_count = str[pos] == 'f' ? width*width : 0;
return pos+1;
}
}
// assuming that values are unique
void insert(Tree *root, int val) {
// right
if (val > root->val) {
// recurse
if (root->right != NULL) {
insert(root->right, val);
}
// leaf
else {
root->right = create_tree(val);
root->right->parent = root;
}
}
// left
else {
// recurse
if (root->left != NULL) {
insert(root->left, val);
}
// leaf
else {
root->left = create_tree(val);
root->left->parent = root;
}
}
}
//Create a new btree.
BTREE create_tree(DATA a[], int i, int size)
{
if (i >= size)
return NULL;
else
return (init_node(a[i],
create_tree(a, 2 * i + 1, size),
create_tree(a, 2 * i + 2, size)));
}
void create_tree(ptree *root)
{
char c = getchar();
if (c == '#') {
*root = NULL;
} else {
init_node(root, sizeof(stree));
(*root)->data = c;
create_tree(&(*root)->lc);
create_tree(&(*root)->rc);
}
}
void create_tree(struct tnode **node, char **ch)
{
char temp = **ch;
(*ch)++;
if (temp == 'X')
*node = NULL;
else {
*node = (struct tnode *) malloc(sizeof(struct tnode));
(*node)->data = temp;
create_tree(&((*node)->left), ch);
create_tree(&((*node)->right), ch);
}
}
/* creat a tree */
BTree * create_tree(BTree *T)
{
int data;
scanf("%d", &data);
if(data == 0){
T = NULL;
}else{
T = (BTree *)malloc(sizeof(struct TreeNode));
T->data = data;
T->left = create_tree(T->left);
T->right = create_tree(T->right);
}
return T;
}
int main()
{ tree_node_t *st1, *st2;
int success;
long i, k;
int *m;
int o[3] = {0,2,4};
st1 = create_tree();
st2 = create_tree();
printf("Made two Trees\n");
for( i=0; i < 400000; i++)
{ k = 3*i;
success = insert( st1, k, &(o[1]) );
if( success != 0 )
{ printf(" insert %d failed in st1, return value %d\n", k, success);
exit(-1);
}
success = insert( st2, k, &(o[2]) );
if( success != 0 )
{ printf(" insert %d failed in st2, return value %d\n", k, success);
exit(-1);
}
}
printf("Passed 800000 inserts.\n");
for( i=0; i< 400000; i++)
{ if( i%2 == 0 )
{ m = delete(st1, 3*i );
}
else
{ m = delete(st2, 3*i );
}
if( m == NULL )
printf(" delete failed for %d, returned NULL\n", 3*i);
else if ( (i%2==0 && *m !=2) || (i%2==1 && *m != 4))
printf(" delete failed for %d, returned %d\n", 3*i, *m);
}
printf("Passed 400000 deletes.\n");
for( i=0; i< 1200000; i++)
{ m = find(st1,i);
if( i%3 == 0 && (i/3)%2 == 1 )
{ if (m== NULL)
printf(" find failed on st1 for %d, returned NULL\n", i);
else if (*m != 2 )
printf(" find failed on st1 for %d, returned %d instead of 2\n", i,*m );
}
else if (m != NULL)
printf(" find failed on st1 for %d, returned non-NULL pointer\n", i);
}
printf("Passed 1200000 finds. End of test.\n");
return(0);
}
int main()
{
int tc, bc;
char str1[1500], str2[1500];
scanf("%d", &tc);
while(tc--)
{
scanf("%s%s", str1, str2);
create_tree(tree1, str1, 0, 32, &bc);
create_tree(tree2, str2, 0, 32, &bc);
printf("There are %d black pixels.\n", count_black(tree1, tree2));
}
return 0;
}
TreeNode* create_tree()
{
int iTemp;
TreeNode *pRoot = NULL;
scanf("%d",&iTemp);
if(iTemp == -1)
{
return NULL;
}
pRoot = (TreeNode*)malloc(sizeof(TreeNode));
pRoot->iVal = iTemp;
pRoot->pLeft = create_tree();
pRoot->pRight = create_tree();
return pRoot;
}
/*********************
return RET_NOK on error
*********************/
static ret_code_t __write_list_index(const char * table, const char * file, const char * data, int index, va_list ap)
{
config_setting_t * setting = NULL;
const config_t * config;
int list_size;
SDL_LockMutex(entry_mutex);
config = get_config(table,file);
if(config==NULL) {
SDL_UnlockMutex(entry_mutex);
return RET_NOK;
}
setting = create_tree(config,NULL,NULL,NULL,CONFIG_TYPE_ARRAY,ap);
// Create empty entry before index
list_size = config_setting_length (setting);
while( list_size <= index ) {
if(config_setting_set_string_elem(setting,-1,"")==NULL) {
SDL_UnlockMutex(entry_mutex);
return RET_NOK;
}
list_size++;
}
if(config_setting_set_string_elem(setting,index,data)==NULL) {
SDL_UnlockMutex(entry_mutex);
return RET_NOK;
}
write_config(config,table,file);
SDL_UnlockMutex(entry_mutex);
return RET_OK;
}
int main()
{
std::vector<int> arr = {10, 5, 16, 12, 20};
Node *pRoot = create_tree(arr);
std::copy(arr.begin(), arr.end(), std::ostream_iterator<int>(std::cout, " "));
return 1;
}
void main()
{
TREE *tree=create_tree();
start_gem();
parse(tree);
stop_gem();
}
int main ()
{
short flag = 11; /// flag for menu
leaf *root; /// root of tree
root = new leaf;
root->parent = NULL; /// totaly null root of tree
root->son_l = NULL;
root->son_r = NULL;
root->val = NULL;
while(1)
{
switch (give_mFlag()) /// give flag
{
case 1:
create_tree(root); /// create tree
printf("\n....tree was created");
break;
case 2:
print_tree(root); /// print tree
break;
case 0:
delete_tree(root); /// destroy tree
printf("\n....tree was destroied");
flag = EXIT_WHILE; /// and exit from programm
break;
}
if (flag == EXIT_WHILE) break;
}
getchar();
getchar();
}
void test_avl_tree_lookup(void)
{
AVLTree *tree;
int i;
int *value;
/* Create a tree and look up all values */
tree = create_tree();
for (i=0; i<NUM_TEST_VALUES; ++i) {
value = avl_tree_lookup(tree, &i);
assert(value != NULL);
assert(*value == i);
}
/* Test invalid values */
i = -1;
assert(avl_tree_lookup(tree, &i) == NULL);
i = NUM_TEST_VALUES + 1;
assert(avl_tree_lookup(tree, &i) == NULL);
i = 8724897;
assert(avl_tree_lookup(tree, &i) == NULL);
avl_tree_free(tree);
}
text_t *create_text()
{
text_t *text;
text = (text_t *) malloc(sizeof(text_t));
text->searchtree = create_tree();
return text;
}
int main() {
int retval;
test_batch_runner *runner = test_batch_runner_new();
version(runner);
constructor(runner);
accessors(runner);
node_check(runner);
iterator(runner);
iterator_delete(runner);
create_tree(runner);
hierarchy(runner);
parser(runner);
render_html(runner);
utf8(runner);
line_endings(runner);
numeric_entities(runner);
test_cplusplus(runner);
test_print_summary(runner);
retval = test_ok(runner) ? 0 : 1;
free(runner);
return retval;
}
void main()
{
int size=0;
order_node *pre,*in;
pre=(order_node*)malloc(sizeof(order_node));
in=(order_node*)malloc(sizeof(order_node));
tree_node *root;
printf("Enter data in pre order(-999 to end)\n");
create_order(pre);
printf("Enter data in in-order(-999 to end)\n");
create_order(in);
size = get_size(in);
root=create_tree(in,pre,size);
printf("\nData in tree in preorder rec\n");
rec_pre(root);
printf("\nData in tree in inorder rec\n");
rec_in(root);
printf("\nData in tree in posorder rec\n");
rec_pos(root);
printf("\nData in tree in preorder nrec\n");
nrec_pre(root);
printf("\nData in tree in inorder nrec\n");
nrec_in(root);
printf("\nData in tree in posorder nrec\n");
nrec_pos(root);
printf("\n\nPress Enter to exit...");
getch();
}
/*********************
return RET_NOK on error
*********************/
static ret_code_t __write_list(const char * table, const char * file, char ** data, va_list ap)
{
config_setting_t * setting;
const config_t * config;
int i=0;
SDL_LockMutex(entry_mutex);
config = get_config(table,file);
if(config==NULL) {
SDL_UnlockMutex(entry_mutex);
return RET_NOK;
}
setting = create_tree(config,NULL,NULL,NULL,CONFIG_TYPE_ARRAY,ap);
while(data[i] != NULL) {
// First try to update existing setting
if(config_setting_set_string_elem(setting,i,data[i])==NULL) {
// If it down not exist, add a new setting at the end of the list
if(config_setting_set_string_elem(setting,-1,data[i])==NULL) {
SDL_UnlockMutex(entry_mutex);
return RET_NOK;
}
}
i++;
}
write_config(config,table,file);
SDL_UnlockMutex(entry_mutex);
return RET_OK;
}
// Creates canonical codewords
vector<string> create_codewords(double *freqs, int n_freqs)
{
typedef pair<Node<int>*, string> NodeCode;
vector<string> codewords(n_freqs);
queue<NodeCode> q;
Node<int>* root = create_tree(freqs, n_freqs);
q.push(NodeCode(root, ""));
while(!q.empty())
{
NodeCode nc = q.front();
q.pop();
if(nc.first->is_leaf())
{
codewords[nc.first->data] = nc.second;
}
else
{
q.push(NodeCode(nc.first->left, nc.second + "0"));
q.push(NodeCode(nc.first->right, nc.second + "1"));
}
}
auto cws = new pair<int, string>[n_freqs]; // max n_freqs
for(int i = 0; i < n_freqs; ++i)
{
cws[i] = pair<int, string>(i, codewords[i]);
}
vector<string> canonical = canonicalize(cws, n_freqs);
delete[] cws;
return canonical;
}
int main(int argc, const char * argv[]) {
AVLTree b= create_tree();
Insert(&b, 20, "jordan");
Insert(&b, 42, "james");
Delete(&b, 20);
Insert(&b, 32, "jack");
Insert(&b, 50, (void*)9);
Insert(&b, 6, (void*)12);
Insert(&b, 7, (void*)'j');
Insert(&b, 4, (void*)'x');
Insert(&b, 1, (void*)'v');
Insert(&b, 100, "abby");
Insert(&b, 90, "gabby");
Insert(&b, 80, "grace");
Insert(&b, 70, "david");
Insert(&b, 39, "Chris");
printf("pre-order\n");
PrintPreOrder(&b);
printf("in-order\n");
PrintInOrder(&b);
printf("post-order\n");
PrintPostOrder(&b);
printf("Distance from root %d\n",DistanceFromRoot(&b, 70));
printf("tree height %d\n",TreeHeight(&b));
printf("item: %s\n",Find(&b, 42));
Delete(&b, 42);
printf("item: %s\n",Find(&b, 39));
printf("tree height %d\n",TreeHeight(&b));
return 0;
}
void create_tree(struct tree *node, int depth)
{
if (node->level < depth) {
node->left = spawn_child(node, node->left);
create_tree(node->left, depth);
node->right = spawn_child(node, node->right);
create_tree(node->right, depth);
#ifndef TWO_DIMENSION
node->up = spawn_child(node, node->up);
create_tree(node->up, depth);
node->down = spawn_child(node, node->down);
create_tree(node->down, depth);
#endif
}
}
BOOL CMissionGoalsDlg::OnInitDialog()
{
int i, adjust = 0;
CDialog::OnInitDialog(); // let the base class do the default work
if (!Show_sexp_help)
adjust = -SEXP_HELP_BOX_SIZE;
theApp.init_window(&Mission_goals_wnd_data, this, adjust);
m_goals_tree.setup((CEdit *) GetDlgItem(IDC_HELP_BOX));
load_tree();
create_tree();
if (m_num_goals >= MAX_GOALS)
GetDlgItem(IDC_BUTTON_NEW_GOAL)->EnableWindow(FALSE);
Goal_editor_dlg = this;
i = m_goals_tree.select_sexp_node;
if (i != -1) {
GetDlgItem(IDC_GOALS_TREE) -> SetFocus();
m_goals_tree.hilite_item(i);
return FALSE;
}
return TRUE;
}
int main()
{
FILE * out;
out = fopen("errors.txt","w");
int i = 1;
Lex * test = create_Lex("count(1,1);");
Node * past = get_first(test);
Branch * tree;
while (past != NULL)
{
printf("%d token is %d with value %s\n", i, get_token(past), get_value(past));
past = get_next(past);
i++;
}
tree = create_tree(test, out);
fclose(out);
if (tree == NULL)
{
printf("Unable to create tree.\n");
}
destroy_Lex(test);
tree_print(tree);
translate(tree, "out.c");
tree_free(tree);
_CrtDumpMemoryLeaks();
return 0;
}
int main(int argc, char **argv)
{
tree *first_elem;
char *str;
int n;
str = (char *) calloc(10, sizeof(char));
first_elem = NULL;
if (argc == 2) {
if ((strcmp(argv[1], "-h")) == 0) {
puts("Instructions for use:");
puts("1.Launch file:");
puts(" gcc-Wall-Wextra-o lab4.exe lab4.c");
puts(" ./lab4.exe");
puts("2.In the screen prompts you to enter the first element of a tree (root).");
puts(" Enter it. Next, you are prompted to enter ocheredenoy the tree.");
puts(" Enter it. Proposals will be displayed as long as you do not enter '0'.");
puts(" Next, you are prompted to enter the level for which you want to calculate the number of nodes.");
puts(" Enter it.");
puts("3.The displayed the number of nodes at a given level or '0' if the current level");
puts(" does not exist or at no nodes.");
return 0;
}
}
first_elem = create_tree(first_elem);
add_elem(first_elem);
puts("Enter level");
enter_number(str,&n);
printf("number of nod on level %d: %d", n,
calculate_number_of_nod(first_elem, n));
return 0;
}
int main()
{
ptree root = NULL;
create_tree(&root);
show_tree(root);
return 0;
}
int main()
{
char _[] = "deadbeef";
tree_t t = create_tree(_, strlen(_));
inorder_traversal(t, print_node);
sep;
printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)),
retrieve(find('a', t)));
sep;
t = insert_tree('z', t);
printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)),
retrieve(find('a', t)));
sep;
inorder_traversal(t, print_node);
sep;
delete_tree('z', t);
printf("%c %c %c", retrieve(find_min(t)), retrieve(find_max(t)),
retrieve(find('a', t)));
sep;
inorder_traversal(t, print_node);
dispose_tree(t);
return 0;
}
