Example #1
0
int main(int argc, char *argv[])
{

	extern struct tree_node head;

    printf("head.num = %d\n", head.num);
    
    insert_tree_node(create_tree_node(10));
    insert_tree_node(create_tree_node(18));
    insert_tree_node(create_tree_node(12));
    insert_tree_node(create_tree_node(1));
    insert_tree_node(create_tree_node(9));
    insert_tree_node(create_tree_node(3));
    insert_tree_node(create_tree_node(50));
    insert_tree_node(create_tree_node(70));
    insert_tree_node(create_tree_node(100));
    insert_tree_node(create_tree_node(10000));

    print_tree_num(&head);

    tree_transfer_list(&head);

    return 0;

}
Example #2
0
static int parser_insert_node(Parser *parser, char *key, char *value)
{
	if(!key || !value)
	{
		PRINTF("invalid parameter!\n");
		return -1;
	}
	
	PRINTF("start!\n");
	char *widget_name = NULL;	
	TagType type = TAG_CONTENT;
	int is_ddl = 0;
	int ddl_id = 0;
	TagNode *node = NULL;
	char tmp_key_buf[32] = {0};
	
	memcpy(tmp_key_buf, key, strlen(key));
	parse_key(key, &widget_name, &type, &is_ddl, &ddl_id);
	PRINTF("\nafter parse key\n");
	printf("widget_name(%s) type(%d), is_ddl(%d), ddl_id(%d)\n", widget_name, type, is_ddl, ddl_id);
	node = create_tree_node(type, widget_name, is_ddl, ddl_id, tmp_key_buf);
	printf("after create_tree_node  type(%d), widget_name(%s), is_ddl(%d), ddl_id(%d)\n", node->tag_type, \
			node->tag_name, node->is_ddl, node->ddl_id);

	parser_tree_insert_node(parser, node);

	return 0;
}
Example #3
0
struct tree_node *create_node()
{
	struct node *node;
	struct tree_node *tmp;
	int num,i;
	static int count = 0;

	count++;

	node = malloc(sizeof(*node));
	printf("Enter number of children for %d:\n",count);
	scanf("%d",&num);
	node->data = NULL;
	if (num) {
		node->data = malloc(sizeof(int)*num);
	}
	node->myval = count;

	tmp = create_tree_node(node, num);

	for(i=0;i<num;i++) {
		node->data[i] = count+i+1;
		add_child(tmp,create_node());
	}
	return tmp;
}
Example #4
0
parse_tree create_leaf_node ( char *leafdata ) {
/*
 * create a leaf node - which will always be a relation or a command.
 * - it must be a tree node in itself, which simply references the leaf.
 */

	parse_leaf leaf;
	parse_tree tree;
	
	printf("Request to create a leaf node\n");
	
	tree=create_tree_node(NODE_TYPE_NAME, NODE_POS_LEAF, NULL, 0);
	
	leaf=(parse_leaf_struct *) malloc(sizeof(parse_leaf_struct));
	
	/* Allocate space to hold the item */
	leaf->item=malloc(sizeof(leafdata));
	
	/* Copy data into the item */
	strcpy(leaf->item,leafdata);
	
	tree->no_leaf_nodes++;
	tree->no_sub_nodes++;
	
	tree->leaf[0]=leaf;
	
	return(tree);
	
}
Example #5
0
int main()
{
	struct tree_node *root;
	struct tree_node *left, *right;
	int i = 1,j=2,k=3;

	root = create_tree_node(&i);
	left = create_tree_node(&j);
	right = create_tree_node(&k);

	TREE_ADD(root, left, left);
	TREE_ADD(root, right, right);

	traverse_path(root,traverse);
	destroy_tree(root,NULL);
}
/**
 * ntree_insert - Following the parent path, adds new node
 * @tree: Points to root of NTree node
 * @parents: An array of strings, shows path to new node
 * @data: New string to be stored
 * Description: The func adds a new node to ntree
 */
int ntree_insert(NTree **tree, char **parents, char *data)
{
	List *list_node;
	if (*tree == NULL)
	{
		*tree = create_tree_node(data);
		return 0;
	}
	list_node = traverse_nodes(*tree, parents);
	if ( create_new_list(list_node, data, *tree) == NULL )
	{
		return 1;
	}
	return 0;
}
/**
 * create_new_list - created a new list
 * @head: pointer to head of a list
 * @str: string to be added
 * @root: root of Ntree
 * Description: Creates a new list node
 */
List* create_new_list(List *head, char *str, NTree *root)
{
	List *list;
	list = malloc(sizeof(List));
	if (list == NULL)
	{
		return NULL;
	}
	list->next = NULL;
	list->node = create_tree_node(str);
	if (head == NULL)
	{
		list->next = root->children;
		root->children = list;
		return list;
	}
	list->next = head->node->children;
	head->node->children = list;
	return list;
}
Example #8
0
/**
 * @brief Inserts a new node to the binary search tree.
   @param root: The root pointer of the binary search tree.
   @param name: The name (aka key) of the tree node.
   @param data_ptr: A pointer to the data that will be copied to the new node.
   @param found: A tree node, in case of not NULL the value of it points
   to the new allocated node.
   @return: The new binary search tree.
 */ 
tree_node * tree_insert_node(tree_node * root,const char * name, void * data_ptr, tree_node ** found){
	tree_node * new_node = create_tree_node(name,data_ptr);
	tree_node * visitor = root;
	tree_node * previous = NULL;
	char is_left_child = 0;
	short int comparison;

	if(!new_node)
		return root;

	while(visitor){
		previous = visitor;
		comparison = strcmp(name,visitor->name);
		if(comparison==0){
			if(found)
				*found = visitor;
			return root;
		}
		else if(comparison>0){
			visitor = visitor->rc;
			is_left_child = 0;
		}
		else{
			visitor = visitor->lc;
			is_left_child = 1;
		}
	}

	if(root==NULL)
		root = new_node;
	else {
		if(is_left_child)
			previous->lc = new_node;
		else
			previous->rc = new_node;
	}

	return root;
}
Example #9
0
//remember to NULL god damn siblings.......
int transform(struct tree *here){
	struct tree *temp, *temp1, *temp2, *temp3, *temp4, *temp5, *temp6;

	
	switch (here->type){
		case LET:{
		if(here->child->type != EQUAL) break;

		here->type = GAMMA;
		strcpy(here->content,"gamma");

		here->child->type = LAMBDA;
		strcpy(here->child->content, "lambda");

		temp = here->child->child->sibling;
		here->child->child->sibling = here->child->sibling;
		here->child->sibling = temp;

		if (debug) printf("Finished LET\n");
		return 1;	
		}

		case WHERE:{
		if(here->child->sibling->type != EQUAL)	 break;

		/*whenever you copy the child, remeber its sibling may get 
		into your way, many bugs and segmentation fault come from here
		but you can't NULL it's sibling too soon. == damn

		you better copy the addresss which will be NULLize later first*/

		temp = here->child->sibling; // record here
		temp1 = here->child;
		temp1->sibling = NULL; // cut here, if the sequence is wrong, sementation fault may come

		here->child= temp;
		here->child->sibling = temp1;

		here->type = GAMMA;
		strcpy(here->content,"gamma");

		here->child->type = LAMBDA;
		strcpy(here->child->content, "lambda");

		temp = here->child->child->sibling;
		here->child->child->sibling = here->child->sibling;
		here->child->sibling = temp;

		if (debug) printf("Finished WHERE\n");
		return 1;
		}

		case REC:{
			if(here->child->type != EQUAL) break;

			temp = here->child->child->sibling;
			temp1 = here->child->child;
			temp1->sibling = NULL;
			temp2=malloc(sizeof(struct tree));
			copy_tree_node(temp1,temp2);

			here->type = EQUAL;
			strcpy(here->content,"=");

			here->child = temp1;
			here->child->sibling = create_tree_node(GAMMA);
			here->child->sibling->child = create_tree_node(YSTAR);
			here->child->sibling->child->sibling = create_tree_node(LAMBDA);
			here->child->sibling->child->sibling->child = temp2;
			here->child->sibling->child->sibling->child->sibling =temp;


			if (debug) printf("Finished REC\n");
			return 1;
		}

		case ATX:{
			temp = here->child->sibling->sibling;
			temp1= here->child->sibling;
			temp1->sibling=NULL;
			temp2 = here->child;
			temp2->sibling = NULL;

			here->type = GAMMA;
			strcpy(here->content,"gamma");

			here->child = create_tree_node(GAMMA);
			here->child->sibling = temp;

			here->child->child=temp1;
			here->child->child->sibling = temp2;

			return 1;
		}

		case WITHIN:{
			if(here->child->type != EQUAL || here->child->sibling->type !=EQUAL)
				break;
			temp = here->child->sibling->child->sibling; //E2
			temp1 = here->child->child->sibling; //E1
			temp2 = here->child->sibling->child; //X2
			temp2->sibling =NULL;
			temp3 = here->child->child; //X1
			temp3->sibling = NULL;

			here->type = EQUAL;
			strcpy(here->content,"=");

			here->child = temp2;
			here->child->sibling = create_tree_node(GAMMA);
			here->child->sibling->child = create_tree_node(LAMBDA);
			here->child->sibling->child->sibling = temp1;
			here->child->sibling->child->child = temp3;
			here->child->sibling->child->child->sibling = temp;

			if (debug) printf("Finished WITHING\n");
			return 1;
		}

		case AND2:{

			// temp = here->child;
			// while(temp !=NULL){
			// 	if(temp->type != EQUAL)
			// 		break;
			// 	else
			// 		temp = temp->sibling;
			// }

			temp1 = create_tree_node(COMMA);
			temp3=temp1;
			temp2 = create_tree_node(TAU);
			temp4= temp2;
			temp = here->child;

			if(temp != NULL){
				temp2->child = temp->child->sibling;
				temp1->child = temp->child;
				temp1->child->sibling = NULL;

				temp = temp->sibling;
				temp1 = temp1->child;
				temp2 = temp2->child; 
			}

			while(temp != NULL){
				temp2->sibling = temp->child->sibling;
				temp1->sibling = temp->child;
				temp1->sibling->sibling =NULL;

				temp1 = temp1->sibling;
				temp2 = temp2->sibling;
				temp= temp->sibling;
			}

			here->type = EQUAL;
			strcpy(here->content,"=");

			here->child = temp3;
			here->child->sibling = temp4;

			here->child->sibling->sibling = NULL; //cut off other siblings

			if (debug) printf("Finished AND\n");
		
			return 1;
		}

		case FCN_FORM:{
			temp = here->child->sibling; // point to first var
			while(temp->sibling != NULL){ //after this, temp will be fn's body
				temp = temp->sibling;
			}

			temp1 = here->child->sibling;

			temp2 = create_tree_node(LAMBDA);
			temp2->child = temp1;

			temp1= temp1->sibling;
			temp3= temp2->child; //

			while(temp1 != temp){
				temp3->sibling= create_tree_node(LAMBDA);
				temp3->sibling->child = temp1;

				temp3=temp3->sibling->child;
				temp1=temp1->sibling;
			}

			temp3->sibling=temp;

			here->type = EQUAL;
			strcpy(here->content,"=");

			here->child->sibling = temp2;
			here->child->sibling->sibling=NULL;

			if (debug) printf("Finished FCN_FORM\n");
			return 1;
		}
	}// end of switch 

	return 0;
}