/*
*创建家族关系
*先把数据存入文件里面，然后再把通过数据在内存建立族谱树
*/
void createZuPuTree(ZuPu *zuPu) {
int i =0;
FILE *f;
char fileName[20];
/*输入成员的信息
*这里有个要求：最后的一条数据的第一个字段是-1(作为结束标志)
*/
int flag=1;
while(flag != -1)
{
scanfZuPuMember(&flag);
printf("the flag is %d\n",flag);
}
/*将成员的信息写入文件里面*/
strcpy(fileName,zuPu->name);
strcat(fileName,".txt");
f = fopen(fileName,"wb");
writeInfoToFile(f);
createTree(&zuPu->tree,0);//在内存里面构造关系树
}
//! Reads attributes of the scene node.
void COctreeSceneNode::deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options)
{
const s32 oldMinimal = MinimalPolysPerNode;
MinimalPolysPerNode = in->getAttributeAsInt("MinimalPolysPerNode");
io::path newMeshStr = in->getAttributeAsString("Mesh");
IMesh* newMesh = 0;
if (newMeshStr == "")
newMeshStr = MeshName;
IAnimatedMesh* newAnimatedMesh = SceneManager->getMesh(newMeshStr.c_str());
if (newAnimatedMesh)
newMesh = newAnimatedMesh->getMesh(0);
if (newMesh && ((MeshName != newMeshStr) || (MinimalPolysPerNode != oldMinimal)))
{
// recalculate tree
createTree(newMesh);
}
ISceneNode::deserializeAttributes(in, options);
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
if (nums.empty())
return NULL;
//if (nums)
TreeNode * root = createTree(nums, 0, nums.size()-1);
return root;
}
void test_searching_root_node(){
Tree tree = createTree(cmpInt);
int element1 =10;
ASSERT(1 == insertTreeNode(&tree,NULL,&element1));
ASSERT(1 == search(&tree,&element1));
disposeTree(&tree);
};
void test_deletes_the_root_from_the_tree(){
Tree tree = createTree(areNodesEqual);
int number = 12;
insertTreeNode(&tree, NULL, &number);
ASSERT(searchInTree(tree, &number));
ASSERT(1 == deleteFromTree(&tree, &number));
}
void test_removing_root_node_when_it_has_no_childs(){
Tree tree = createTree(cmpInt);
int element1 = 10;
insertTreeNode(&tree,NULL,&element1);
ASSERT(1 == removeTreeNode(&tree,&element1));
ASSERT(0 == search(&tree,&element1));
};
//TODO 保留关键字
void insertVar(Tree rootTree, char *varName, DataType dataType, double data){
Tree tmpTree, parentTree;
Node newNode = malloc(sizeof(struct _Node));
tmpTree = parentTree = rootTree;
Tree newTree = createTree();
while(tmpTree != NULL){
parentTree = tmpTree;
if(parentTree->node == NULL){
break;
}
tmpTree = strcmp(parentTree->node->varName, varName) >= 0 ? parentTree->lchild : parentTree->rchild;
}
if(tmpTree == NULL){
if(strcmp(parentTree->node->varName, varName) >= 0){
parentTree->lchild = newTree;
}else{
parentTree->rchild = newTree;
}
newTree->node = newNode;
}else if(parentTree->node == NULL){
parentTree->node = newNode;
}
if(dataType == INT){
newNode->data.iData = (int)data;
newNode->dataType = INT;
}else{
newNode->data.dData = data;
newNode->dataType = DOUBLE;
}
strcpy(newNode->varName, varName);
}
QgsSvgGroupsModel( QObject* parent ) : QStandardItemModel( parent )
{
QStringList svgPaths = QgsApplication::svgPaths();
QStandardItem *parentItem = invisibleRootItem();
for ( int i = 0; i < svgPaths.size(); i++ )
{
QDir dir( svgPaths[i] );
QStandardItem *baseGroup;
if ( dir.path().contains( QgsApplication::pkgDataPath() ) )
{
baseGroup = new QStandardItem( QString( "App Symbols" ) );
}
else if ( dir.path().contains( QgsApplication::qgisSettingsDirPath() ) )
{
baseGroup = new QStandardItem( QString( "User Symbols" ) );
}
else
{
baseGroup = new QStandardItem( dir.dirName() );
}
baseGroup->setData( QVariant( svgPaths[i] ) );
baseGroup->setEditable( false );
baseGroup->setCheckable( false );
baseGroup->setIcon( QgsApplication::style()->standardIcon( QStyle::SP_DirIcon ) );
baseGroup->setToolTip( dir.path() );
parentItem->appendRow( baseGroup );
createTree( baseGroup );
QgsDebugMsg( QString( "SVG base path %1: %2" ).arg( i ).arg( baseGroup->data().toString() ) );
}
}
void test_must_insert_root_node(){
Tree tree = createTree(compareInts);
int data = 2;
int result = insertIntoTree(&tree, NULL, &data);
ASSERT(SUCCESS == result);
disposeTree(&tree);
}
int main()
{
int i;
int times;
//NodeType dynamicNum[] = {1, 3, 0, 3, 5, 3, 8, 1, 6, 9, 4};
// NodeType callNum[][CALL_NUM_LENGHT] =
// {
// {1, 3, 3, 3, 5, 3, 8, 1, 6, 9, 4},
// {1, 3, 3, 3, 5, 3, 8, 1, 6, 9, 7},
// {1, 3, 3, 3, 5, 3, 8, 1, 6, 8, 4},
// {1, 3, 3, 3, 5, 3, 8, 1, 6, 8, 5},
// {1, 3, 3, 3, 5, 3, 8, 1, 5, 3, 5},
// {1, 3, 3, 3, 5, 3, 8, 1, 5, 2, 5},
//
// {1, 2, 3, 3, 5, 3, 8, 1, 6, 9, 4},
// {1, 2, 4, 3, 5, 3, 8, 1, 6, 9, 7},
// {1, 5, 3, 3, 5, 3, 8, 1, 6, 8, 4},
// {1, 4, 3, 3, 5, 3, 8, 1, 6, 8, 5},
// {1, 8, 3, 3, 5, 3, 8, 1, 5, 3, 5},
// {1, 9, 3, 3, 5, 3, 8, 1, 5, 2, 5},
// };
NodeType dynamicNum[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
NodeType dynamicNumC[] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
//times = GetTickCount();
Tree *pTree;
pTree = createTree();
for (i=0; i<TIMES_COUNT; i++)
{
BOOL ret;
incCallNum(dynamicNum, sizeof(dynamicNum));
//printfCallNumber(dynamicNum, sizeof(dynamicNum));
ret = addCallNumber(pTree, dynamicNum, sizeof(dynamicNum));
if (ret == FALSE)
printf("add node failed.\n");
}
printf("del...\n");
//getchar();
for (i=0; i<TIMES_COUNT; i++)
{
delCallNumber(pTree, dynamicNum, sizeof(dynamicNum));
//printfCallNumber(dynamicNum, sizeof(dynamicNum));
decCallNum(dynamicNum, sizeof(dynamicNum));
}
releaseTree(pTree);
pTree = NULL;
displayTree(pTree);
printf("\n");
printf("ok\n");
getchar();
return 0;
}
void test_removing_node_that_has_childs_should_fail(){
Tree tree = createTree(cmpInt);
int element1 = 10,element2 = 20,element3 = 30,element4 = 40;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
ASSERT(0 == removeTreeNode(&tree,&element1));
disposeTree(&tree);
};
void test_insert_should_not_insert_if_child_parents_is_not_availble(){
Tree tree = createTree(compareInt );
int result;
result = insertNode(&tree, NULL, &data[0]);
result = insertNode(&tree, &data[0] , &data[1]);
result = insertNode(&tree, &data[4] , &data[2]);
ASSERT(result == 0);
};
void test_5_insert_should_insert_a_child_to_root_node(){
Iterator* iterator;
Tree tree = createTree(compareInt);
insertNode(&tree, NULL, &data[0]);
insertNode(&tree, &data[0] , &data[1]);
iterator = getChildren(&tree, &data[0]);
ASSERT(&data[1] == iterator->next(iterator));
};
//------------------------------search---------------------------------------------------
void test_searchs_the_given_data_in_list(){
Tree tree = createTree(areNodesEqual);
int num1 = 1,num2=2;
insertTreeNode(&tree, NULL, &num1);
insertTreeNode(&tree, &num1, &num2);
ASSERT(searchInTree(tree, &num1));
ASSERT(searchInTree(tree, &num2));
}
void Exporter::postConstructor()
{
createTree();
applyConfig();
}
void createTree(int x, int l, int r)
{
node[x].l = l;
node[x].r = r;
node[x].update = 0;
if(l == r)
{
node[x].sum = num[l];
}
else
{
int mid = midium(l, r);
createTree(left(x), l, mid);
createTree(right(x), mid + 1, r);
node[x].sum = node[left(x)].sum + node[right(x)].sum;
}
}
/********************
this function creates a queue.
*********************/
queueNode *createQueue(int (*compare) (void *, void *), void (* copy) (void *), void (* destroy) (void *)) {
queueNode * myQueue;
myQueue = malloc(sizeof(queueNode));
myQueue->myTree = createTree(compare, copy, destroy);
return myQueue;
}
int main(){
struct TreeNode* root = createTree() ;
int length = minDepth(root) ;
printf("%d\n",length) ;
// printT(root) ;
return 0 ;
}
Tree createTree(Tree t)
{
Tree t1 = NULL;
int k;
scanf("%d", &k);
if(0 == k)
t = NULL;
else
{
t = (Tree)malloc(sizeof(struct node));
t->data = k;
t->left = t->right = NULL;
t->left = createTree(t1);
t->right = createTree(t1);
}
return t;
}
void test_insert_node_at_different_levels(){
Tree tree = createTree(compareInteger);
int arr[] = {1,2,3};
Iterator result;
insertTree(&tree, NULL, &arr[0]);
insertTree(&tree, &arr[0], &arr[1]);
insertTree(&tree, &arr[0], &arr[2]);
}
void test_search_element_when_not_found(){
Tree tree = createTree(compareInteger);
Iterator result;
int data[5] = {1,2};
ASSERT(insertTree(&tree, NULL, &data[0]));
ASSERT(insertTree(&tree, &data[0], &data[1]));
ASSERT(0 == searchTreeNode(&tree,&data[4]));
}
KD_tree (int dimensions_, Points& points) : dimensions(dimensions_), root(NULL)
{
if ( points.begin() != points.end() )
createTree(root, 0, points.begin(), points.end());
//std::cout << "\nPre-Order printing" << std::endl;
//print(root);
}
// Building Segment Tree - Begin
// node = 1
// b = first position of our array A[]
// e = last position of our array A[]
// M = tree[] array
// A = a[] array
void createTree(int node, int b, int e, long long SumTree[], int A[])
{
if (b == e)
{
SumTree[node] = A[b];
}
else
{
//compute the values in the left and right subtrees
createTree(2 * node, b, (b + e) / 2, SumTree, A);
createTree(2 * node + 1, (b + e) / 2 + 1, e, SumTree, A);
//doing stuff with children nodes
//In this case, we are storing sum of both the children nodes in parent node
SumTree[node] = SumTree[2*node] + SumTree[2*node + 1];
}
}
void createTree(Node*& currentRoot, int level, PointsIter begin, PointsIter end)
{
// Order points based on the coordinate indicated by level
DimensionOrder orderer(level);
sort(begin, end, orderer);
// Find the median in order to perform the split
int size = end - begin - 1;
PointsIter median = begin + size / 2;
currentRoot = new Node(*median, level);
// Create subtrees
if ( begin != median )
createTree(currentRoot->less, (level+1) % dimensions, begin, median);
if ( median + 1 != end )
createTree(currentRoot->greater, (level+1) % dimensions, median + 1, end);
}
void main_function()
{
int ret = 0;
xml_Text xml;
xml_Token token;
int multiExp = 0; //0--single line explanation 1-- multiline explanation
int multiCDATA = 0; //0--single line CDATA 1-- multiline CDATA
int i=0;
int j;
if(i==0)
{
createTree_first(1);
}
else {
createTree(i);
}
finish_root[i]->state=-1;
start_root[i]->state=-1;
printf("The initial stack tree for the thread %d is shown as follows.\n",i);
printf("For the start tree\n");
print_tree(start_root[i],0);
printf("For the finish tree\n");
print_tree(finish_root[i],0);
printf("The results are listed as follows:\n");
char seps[] = "\r\n";
char *token_line = strtok(buffFiles[i], seps);
while(token_line!= NULL)
{
xml_initText(&xml,token_line);
xml_initToken(&token, &xml);
ret = xml_process(&xml, &token, multiExp, multiCDATA, i);
if(ret == -1)
{
printf("WARNING: There is something wrong with your xml file, please check its format! \n");
break;
}
else if(ret == 1)
{
multiExp = 1;
}
else if(ret == 2)
{
multiCDATA = 1;
}
else{
multiExp = 0;
multiCDATA = 0;
}
token_line=strtok(NULL,seps);
}
free(buffFiles[i]);
printf("The final stack tree for the thread %d is shown as follows.\n",i);
printf("For the start tree\n");
print_tree(start_root[i],0);
printf("For the finish tree\n");
print_tree(finish_root[i],0);
finish_args[i]=1;
}
NodeT *createTree()
{
int val=atoi(first->elem);
char *aux=first->elem;
NodeT *p = createNodeT(aux);
dequeue(first);
if(val!=0 || strcmp(aux, "0")==0)
{
return p;
}
else
{
p->left=createTree();
p->right=createTree();
}
return p;
}
static ::libmaus::util::shared_ptr<HuffmanTreeNode>::type createTree( iterator a, iterator e )
{
::std::map<int64_t,uint64_t> probs;
for ( ; a != e; ++a )
probs[*a]++;
return createTree ( probs );
}
//按照先序遍历的方式创建二叉树
treeNode *createTree(treeNode *parent)
{
int key;
treeNode *p=NULL;
scanf("%d",&key);
if(key!=-1)
{
p=(treeNode *)malloc(sizeof(treeNode));
p->data=key;
p->parent=parent;
parent=p;
p->lchild=createTree(parent);
p->rchild=createTree(parent);
}
else
return NULL;
return p;
}
void test_removing_node_that_is_absent(){
Tree tree = createTree(cmpInt);
int element1 = 10,element2 = 20,element3 = 30;
Iterator it;
insertTreeNode(&tree,NULL,&element1);
insertTreeNode(&tree,&element1,&element2);
ASSERT(0 == removeTreeNode(&tree,&element3));
disposeTree(&tree);
};
void test_must_not_delete_any_Parent_node(){
Tree tree = createTree(compareInts);
Iterator result;
int data[2] = {10,23};
ASSERT(insertIntoTree(&tree, NULL, &data));
ASSERT(insertIntoTree(&tree, &data, &data[1]));
ASSERT(0 == deleteFromTree(&tree,&data[0]));
disposeTree(&tree);
}
