C++ NewNode函数代码示例

//------------------------------------------------------------------------------
// Create a star tree with n leaves
void NTree::StarTree (int n)
{
	Leaves = n;
	Internals = 1;

	Root = NewNode();
	Root->SetWeight (n);
	Root->SetDegree (n);

	CurNode = NewNode();
	CurNode->SetLeaf(true);
	CurNode->SetLeafNumber(1);
	CurNode->SetLabelNumber(1);

	Root->SetChild (CurNode);
	CurNode->SetAnc (Root);

	// Remaining leaves
	for (int i = 1; i < n; i++)
	{
		NodePtr q = NewNode ();
		q->SetLeaf(true);
		q->SetLeafNumber(i+1);
		q->SetLabelNumber(i+1);
		q->SetAnc (Root);
		CurNode->SetSibling (q);;
		CurNode = q;
	}

    MakeNodeList();
    Update();
    BuildLeafClusters ();

}

bool StudentTree::Insert(unsigned int id, char* fullname, unsigned int flags, bool reorder)
{
    if ((int)id <= 0 || Exists(id))
        return false;

    if(!ValidFullname(fullname))
        return false;

    tempData = (TREE_NODE_DATA*)malloc(sizeof(TREE_NODE_DATA));
    tempData->id = id;
    tempData->fullname = fullname;
    tempData->flags = flags;
    tempData->bstId = tempData->bstName = 0;

    tempNode = NewNode(tempData);
    InsertSortedId(&(bstId->root), tempNode);

    tempNode = NewNode(tempData);
    InsertSortedName(&(bstName->root), tempNode);

    if (reorder)
        SetMode(treeMode);

    return true;
}

NODE * InsertIterative (NODE * root ,int data )
{
	if(root==NULL )
	{
	     return(NewNode(data)); 
	}
	NODE * ptr =root ;
	NODE * save =NULL;
	NODE * newInsert=NewNode(data);
	while(ptr!=NULL)
	{  
	 if(ptr->data > data )
	 {
		save =ptr;	
		 ptr=ptr->left;

	 }
	 else
	 {
		save =ptr;	
		 ptr=ptr->right;
	 }
	}
	if(save->data > data)
	{
	  save->left=newInsert;
	}
	else 
	{
	 save->right=newInsert;
	}
   return root ;
}

// b: by calling newNode() three times, and using only one pointer variable
struct node* build123b()
{
	struct node* root = NewNode(2);
	root->left = NewNode(1);
	root->right = NewNode(3);
	return root;
}

 void Init()
 {
     num[0]=0;
     val[0]=0;
     NewNode(size=0,rt,0);
     NewNode(rt,son[rt][1],0);
     makeTree(0,n-1,keyTree,son[rt][1]);
     Update(son[rt][1]);
     Update(rt);
 }

struct node* buildBSTree() {
    struct node* root = NewNode(4);
    root->left = NewNode(2);
    root->left->right = NewNode(3);
    root->left->left = NewNode(1);

    root->right = NewNode(5);

    return root; 
}

void Init()
{
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
    root = 0;
    rear = head = 0;
    f[root] = Node(0, 0, 0, 0, 0, 0, 0);
    NewNode(root, 0, -1);
    NewNode(f[root].ch[1], root, -1);
    Build(Key_value, 1, n, f[root].ch[1]);
}

struct node* build123_a() {
    struct node* node1 = NewNode(1);
    struct node* node2 = NewNode(2);
    struct node* node3 = NewNode(3);

    node2->left = node1;
    node2->right = node3;

    return node2;
}

// a: by calling newNode() three times, and using three pointer variables
struct node* build12345()
{
	struct node* root = NewNode(4);
	struct node* left = NewNode(2);
	struct node* right = NewNode(5);
	root->left = left;
	root->right = right;
	root->left->left = NewNode(1);
	root->left->right = NewNode(3);
	return root; // <<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>
}

List *InitList()
{
    List *L;
    L = (List *)malloc(sizeof(List));
    memset(L,0,sizeof(List));
    L->size = 0;

    L->header  = NewNode(0,NULL);
    L->trailer = NewNode(0,NULL);
    L->header->Next = L->trailer;
    return L;
}

int main()
{
        struct edges *Node=NULL;
        char ch;
        int i,j,weight;
        scanf("%d %d",&n,&m);
        if(n<=0||n>=200000)
            exit(EXIT_FAILURE);
        if(m<=0||m>=200000)
            exit(EXIT_FAILURE);
        struct node *start[n];
        struct edges *ptr[n];
        for(i=0;i<n;i++)
        {
            start[i]=NULL;
            ptr[i]=NULL;
        }
        int k;
        for(k=0;k<m;k++)
        {
                scanf("%d %d %d",&i,&j,&weight);
                if(i<=0||i>=200000)
                    exit(EXIT_FAILURE);
                if(j<=0||j>=200000)
                    exit(EXIT_FAILURE);
                Node=NewNode();
                if(start[i]==NULL)
                        start[i]=(struct node*)Node;
                else
                        ptr[i]->next=Node;

                Node->vertex=j;
                Node->weight=weight;
                ptr[i]=Node;

                Node=NewNode();
                if(start[j]==NULL)
                        start[j]=(struct node*)Node;
                else
                        ptr[j]->next=Node;

               Node->vertex=i;
               Node->weight=weight;
               ptr[j]=Node;
        }

    for(i=0;i<n;i++)
    {
        printf("%d ->",i);
        PrintList((struct edges*)start[i]);
    }
    return 0;
}

static void GetInstChain(RSTREE R,
                         typrect newrect,
                         int depth)

{
  int i;
  refcount c;
  
  i= 1;
  while (i < depth) {
    if ((*R).NInst[i+1] != NULL) {
      /* already in path */
      (*R).E[i]= (*R).EInst[i]; (*R).EInst[i]= -1;
      i++;
      if ((*R).N[i] != (*R).NInst[i]) {
        (*R).P[i]= (*(*R).N[i-1]).DIR.entries[(*R).E[i-1]].ptrtosub;
        free((*R).N[i]); (*R).N[i]= NULL;
        (*R).N[i]= (*R).NInst[i];
      }
      (*R).NInst[i]= NULL;
    }
    else if ((*R).EInst[i] != -1) {
      /* known ... */
      (*R).E[i]= (*R).EInst[i]; (*R).EInst[i]= -1;
      i++;
      if ((*(*R).N[i-1]).DIR.entries[(*R).E[i-1]].ptrtosub != (*R).P[i]) {
        /* but not in path */
        NewNode(R,i);
      }
    }
    else {
      /* not known */
      ChooseSubtree(R,newrect,i,&(*(*R).N[i]).DIR,&(*R).E[i]);
      i++;
      if ((*(*R).N[i-1]).DIR.entries[(*R).E[i-1]].ptrtosub != (*R).P[i]) {
        /* and not in path */
        NewNode(R,i);
      }
    }
  }
  
  c= &(*R).count;
  if ((*c).countflag) {
    if (depth == (*R).parameters._.height) {
      (*c).dirvisitcount+= depth - 1;
      (*c).datavisitcount++;
    }
    else {
      (*c).dirvisitcount+= depth;
    }
  }
}

RedBlackTree::RedBlackTree(int nRootKey /*= -1*/)
{
    m_pNull = NewNode(-2, black);

    if (nRootKey != -1)
    {
        m_pRoot = NewNode(nRootKey, black);
    }
    else
    {
        m_pRoot = nullptr;
    }
}

void Init()
{
  root = tot1 = tot2 = 0;
  ch[root][0] = ch[root][1] = size[root] = pre[root] = 0;
  same[root] = rev[root] = sum[root] = key[root] = 0;
  lx[root] = rx[root] = mx[root] = -INF;
  NewNode(root,0,-1);
  NewNode(ch[root][1],root,-1);
  for(int i = 0;i < n;i++)
    scanf("%d",&a[i]);
  Build(Key_value,0,n-1,ch[root][1]);
  push_up(ch[root][1]);
  push_up(root);
}

node_idx Forest::ProjectVals(level k, node_idx p, level cutoff)
{
    Node *nodeP;
    node_idx result;
    node_idx flag;

    //Check Base Cases
    if (p == 0)
	return 0;

    if (k == 0)
	return 1;

    //Check Cache
    result = ProjectCache[k]->hit(p);
    if (result >= 0) {
	return result;
    }

    nodeP = &FDDL_NODE(k, p);

    if (k < cutoff) {
	flag = 0;
	for (node_idx i = 0; i < nodeP->size; i++) {
	    flag = ProjectVals(k - 1, FDDL_ARC(k, nodeP, i), cutoff);
	    if (flag != 0)
		break;
	}
	if (flag != 0) {
	    result = NewNode(k);
	    for (node_idx i = 0; i <= maxVals[k]; i++) {
		SetArc(k, result, i, flag);
	    }
	    result = CheckIn(k, result);
	    ProjectCache[k]->add(result, p);
	    return result;
	}
    } else {
	result = NewNode(k);
	for (node_idx i = 0; i < nodeP->size; i++) {
	    SetArc(k, result, i,
		   ProjectVals(k - 1, FDDL_ARC(k, nodeP, i), cutoff));
	}
	result = CheckIn(k, result);
	ProjectCache[k]->add(result, p);
	return result;
    }
    return 0;
}