void PlanRep::removeDeg1Nodes(Stack<Deg1RestoreInfo> &S, const NodeArray<bool> &mark)
{
for(node v = firstNode(); v != nullptr; v = v->succ())
{
if(mark[v] || v->degree() == 0)
continue;
adjEntry adjRef;
for(adjRef = v->firstAdj();
adjRef != nullptr && mark[adjRef->twinNode()];
adjRef = adjRef->succ()) ;
if(adjRef == nullptr) {
// only marked nodes adjacent with v (need no reference entry)
for(adjEntry adj : v->adjEdges) {
node x = adj->twinNode();
S.push(Deg1RestoreInfo(m_eOrig[adj->theEdge()],m_vOrig[x],nullptr));
delNode(x);
}
} else {
adjEntry adj, adjNext, adjStart = adjRef;
for(adj = adjRef->cyclicSucc(); adj != adjStart; adj = adjNext)
{
adjNext = adj->cyclicSucc();
node x = adj->twinNode();
if(mark[x]) {
S.push(Deg1RestoreInfo(m_eOrig[adj->theEdge()],m_vOrig[x],adjRef));
delNode(x);
} else
adjRef = adj;
}
}
}
}
void delNode(Node* n)
{
if (!n) return;
delNode(n->child[2]);
delNode(n->child[0]);
delNode(n->child[1]);
free(n);
}
void BTree::delSubTree(Node* subTree){ /*deletes a sub tree*/
if ( subTree != NULL)
{
delNode(subTree->left);
delNode(subTree->right);
delNode(subTree);
}
}
// embeds constraint graph such that all sources and sinks lie in a common
// face
void CompactionConstraintGraphBase::embed()
{
NodeArray<bool> onExternal(*this,false);
const CombinatorialEmbedding &E = *m_pOR;
face fExternal = E.externalFace();
for(adjEntry adj : fExternal->entries)
onExternal[m_pathNode[adj->theNode()]] = true;
// compute lists of sources and sinks
SList<node> sources, sinks;
for(node v : nodes) {
if (onExternal[v]) {
if (v->indeg() == 0)
sources.pushBack(v);
if (v->outdeg() == 0)
sinks.pushBack(v);
}
}
// determine super source and super sink
node s,t;
if (sources.size() > 1)
{
s = newNode();
for (node v : sources)
newEdge(s,v);
}
else
s = sources.front();
if (sinks.size() > 1)
{
t = newNode();
for (node v : sinks)
newEdge(v,t);
}
else
t = sinks.front();
edge st = newEdge(s,t);
bool isPlanar = planarEmbed(*this);
if (!isPlanar) OGDF_THROW(AlgorithmFailureException);
delEdge(st);
if (sources.size() > 1)
delNode(s);
if (sinks.size() > 1)
delNode(t);
}
void delNode(TreeItem *node)
{
if (node == NULL) return;
if (node->left != NULL)
delNode(node->left);
if (node->right != NULL)
delNode(node->right);
free(node);
}
void GRA_DelNode (Graph *g)
{
Node *n;
#ifdef _DEBUG
int nOfNodesAntigo = g->nOfNodes;
AssertGraph(g);
#endif /* _DEBUG */
CNT_CONTAR("GRA_delNode - Inicializao");
assert(g->currentNode);
n = (Node *) LIS_ObterValor(g->currentNode);
assert( n!=NULL );
#ifdef _DEBUG
AssertNode(n,g);
#endif /* _DEBUG */
CNT_CONTAR("GRA_delNode - Deletando no");
delNode(g,n);
LIS_ExcluirElemento(g->nodes);
g->currentNode = LIS_ObterValor(g->nodes);
#ifdef _DEBUG
g->nOfNodes--;
assert ( g->nOfNodes == (nOfNodesAntigo - 1) );
AssertGraph(g);
#endif /* _DEBUG */
}
int main() {
list_t *root, *a, *b;
int i;
root=NULL;
printList(root);
for(i=0;i<10;i++) {
a = new_node(i);
add(&root, a);
if(i==5)
b=a;
}
printList(root);
printNode(b);
del(&root, b);
printList(root);
b=getNode(&root, 8);
printNode(b);
delNode(&root, 8);
printList(root);
return 0;
}
circList<T>::~circList(){
while (listSize != 0){
delNode(0);
}
}
void ParallelCoordinatesGraphProxy::deleteData(const unsigned int dataId) {
if (getDataLocation() == NODE) {
delNode(node(dataId));
} else {
delEdge(edge(dataId));
}
}
void filterNBV(GLMmodel *obj, GLMnode **NBVStruct)
{
for(unsigned int index = STARTFROM; index <= (*obj).numvertices; index++)
{
GLMnode *currCol;
GLMnode *nextCol;
GLMnode *preNode;
nextCol = NBVStruct[index];
while (nextCol->next != NULL)
{
currCol = nextCol;
preNode = currCol;
while (preNode->next != NULL)
{
currCol = preNode;
currCol = currCol->next;
if (nextCol->index == currCol->index)
delNode(preNode, currCol->next);
if(preNode->next != NULL)
preNode = preNode->next;
} //end while
if(nextCol->next != NULL)
nextCol = nextCol->next;
} //end while
} //end for
} //end filterNBV
void *reader(void *info) {
int i = 0;
clientNode *thisClient = (clientNode*) info;
char recvLine[MAXLINE + 1];
char **lines = NULL;
ssize_t n;
printf("[Uma conexao aberta]\n");
//Loop de leitura de mensagens
while ((n=read(thisClient->socket, recvLine, MAXLINE)) > 0) {
recvLine[n] = '\0';
printf("[Cliente %d enviou:] ", thisClient->socket);
if ((fputs(recvLine, stdout)) == EOF) {
perror("fputs :( \n");
exit(6);
}
lines = getLines(recvLine); //Quebra a mensagem em linhas
for(i = 0; lines[i] != NULL; i++) {
parseMessage(lines[i], thisClient);
}
free(lines);
}
delNode(thisClient);
printf("[Uma conexao fechada]\n");
return NULL;
}
void delNode(Node **node, const char *name)
{
if (*node != NULL)
{
if (strcmp((*node)->name, name) == 0)
{
Node *temp_node = *node;
*node = (*node)->next;
freeNode(&temp_node);
delEmptyNames(node);
delNode(node, name);
}
else
{
delNode(&(*node)->next, name);
}
}
}
bool DListNode::insertNode(int ID_insert,bool f1,bool f2,int succ_id)//插入结点ID_insert，且f1=true说明此结点为hull的表层结点
{ //在f1=true的情况下，f2=true说明插入的结点为顺时针方向hull表层的下一结点。
DListNode* newnode=new DListNode(ID_insert); //succ_id为要插入的结点的后一结点标识,且保证这种succ_id存在,否则不做事
DListNode* next=m_ptrNext;
DListNode* pre=m_ptrPre; //此双向链表从前到后组织按顺时针方向的结点
DListNode* p;
if(ID_insert == this->getData()){//如果插入节点为头节点，返回false
cout << "Waring: inserting head node: " << this->getData() << endl;
return false;
}
else if(searchNode(ID_insert)){
// cout << "Warning: Node " << ID_insert << " already exit in Point:" << this->getData() << endl;
//方案一：如果节点存在则不插入。
// return false;
//方案二：先删除原节点再插入——效果较方案一好。
delNode(ID_insert);
}
if(f1)
{
if(f2)//将结点插在this指向的结点的后面一个位子
{
// cout << "Into true true! newId = " << newnode->getData() << endl;
newnode->m_ptrNext=m_ptrNext;
m_ptrNext=newnode;
newnode->m_ptrPre=this;
next->m_ptrPre=newnode;
}
else//将结点插在this指向的结点的前面一个位子
{
// cout << "Into true false! newId = " << newnode->getData() << endl;
newnode->m_ptrNext=this;
newnode->m_ptrPre=pre;
m_ptrPre=newnode;
pre->m_ptrNext=newnode;
}
}
else
{
p=this;//绝对不在this节点的前一或后一位置？？
do
{
if(p->getData()==succ_id)
{
newnode->m_ptrNext=p;
newnode->m_ptrPre=p->getPre();
p->getPre()->m_ptrNext=newnode;
p->m_ptrPre=newnode;
return true;
}
p=p->getNext();
} while(p!=this);
cout << "Warning: inserting " << ID_insert << " to " << this->getData() << " before " << succ_id << " failed!" << endl;
return false;
}
return true;
}
int main()
{
Graph g;
readG(g);
printG(g);
delNode(g, 3);
printf("Graful dupa stergerea nodului 3\n");
printG(g);
return 0;
}
void linearFree(void* mem)
{
auto node = getNode(mem);
if (!node) return;
// Free the chunk
sLinearPool.Deallocate(node->chunk);
// Free the node
delNode(node);
}
ListT* delList(ListT* l) {
if (l) {
NodeT* aux;
while(l->head) {
aux = l->head->next;
l->head = delNode(l->head);
l->head = aux;
}
}
free(l);
return NULL;
}
int main() {
LinkList l;
l = init(5);
printLink(l);
insertEle(l, 6, 10);
printLink(l);
delNode(l, 2);
printLink(l);
updateNode(l, 5, 22);
printLink(l);
return 0;
}
void deleteLevel(nodeTree *root, int level, int rLevel)
{
if (root == NULL) return;
if (level == rLevel)
{
delNode(root->key);
}
else
{
deleteLevel(root->pLeft, level + 1, rLevel);
deleteLevel(root->pRight, level + 1, rLevel);
}
}
/* remove duplicated exp nodes */
void removeDup( Poly l ){
Position n, p;
p = first( l ) ;
while ( NULL != p ){
n = p->next;
if ( NULL != n && p->exp == n->exp )
{
p->coeff += n->coeff;
delNode( p->exp, l);
}
p = n;
}
}
int delTree(Tree *tree)
{
if (tree == NULL) return TREE_NULL;
if (tree->root != NULL) {
delNode(tree->root);
}
tree->root = NULL;
tree->compare = NULL;
return 0;
}
void delEventTable(EventTable *et, const char *name, void (*callback)(void *)) {
Node *head = (Node *)g_hash_table_lookup(et, name);
Event *event;
Node *curr;
Node *p;
forEachNodes(head, curr, p) {
event = containerOf(curr, Event, node);
if (event->callback == callback) {
delNode(curr);
xfree(event);
break;
}
}
int main(void){
List *p=NULL;
p=addHead(p,"def");
p=addHead(p,"abc");
p=addTail(p,"xyz");
p=sortedaddNode(p,"opq");
p=sortedaddNode(p,"lmn");
p=sortedaddNode(p,"uvm");
disp(p);
printf("\n");
p=delNode(p,"opq");
dispReverse(p);
return 0;
}
int main()
{
struct NODE *header;
header = NULL;
int i;
for(i=0; i<MAX_NODE; i++)
addNode(&header,((rand()%25)+(rand()%25)));
displayList(header);
delNode(&header,19);
displayList(header);
delNode(&header,0);
displayList(header);
delNode(&header,28);
displayList(header);
delNode(&header,16);
displayList(header);
return(1);
}
int main(){
node* head = NULL;
push(&head, 7);
push(&head, 1);
push(&head, 3);
push(&head, 2);
puts("Created Linked List: ");
printList(head);
delNode(&head, 1);
puts("\nLinked List after Deletion of 1: ");
printList(head);
return 0;
}
int main(void) {
puts("!!!Hello World!!!"); /* prints !!!Hello World!!! */
LinkList l;
l = init(5);
printLink(l);
insertEle(l, 6, 10);
printLink(l);
delNode(l, 2);
printLink(l);
updateNode(l, 6, 22);
printLink(l);
printf("this is a test for list by c./n");
return EXIT_SUCCESS;
}
//Driver function
int main(void){
int ch;
/*
start = (struct node *)malloc(sizeof(struct node)); //initializing the linked list
if(start == NULL){
printf("Memory full");
exit(1);
}
printf("Enter data:\t");
scanf("%d",&data);
start->data = data;
start->ptr = NULL;
*/
while(1){
menu();
printf("\nEnter choice:\t");
scanf("%d",&ch);
switch(ch){
case 1:
addNode();
break;
case 2:
delNode();
break;
case 3:
search();
break;
case 4:
display(0);
break;
default:
ch = 0;
break;
}
if(ch == 0)
break;
}
printf("\nThanks for using...");
clear();
getchar();
system("clear");
return 0;
}
void monsterAttack2(int code)
{
int levelO = code % 10;
int keyO = code / 10 % 1000;
nodeTree *attackShip = myTree->root;
int cnt = 3;
while (cnt)
{
findNearestKey(myTree->root, attackShip, 1000, keyO);
int absKey = keyO - attackShip->key;
if (absKey < 0) absKey *= -1;
if (attackShip->level <= levelO)
{
keyO += 3*absKey;
while (keyO > 999) keyO -= 1000;
delNode(attackShip->key);
}
else
{
int delta = 1000 / (((attackShip->level - levelO) + 1) * (attackShip->level + 1));
if (attackShip->level == 7)
{
attackShip->exp = (100 < (attackShip->exp + delta))? 100 : (attackShip->exp + delta);
}
else
{
attackShip->exp += delta;
while (attackShip->exp >= 100)
{
attackShip->level += 1;
attackShip->exp -= 100;
}
}
cnt--;
keyO -= 3*absKey;
while (keyO < 0) keyO += 1000;
//cout << attackShip->exp << "\n";
}
if (myTree->root == NULL) return;
}
}
/*
test add node and delete node
*/
void main()
{
linklist *str =malloc(sizeof(linklist)*10) ;
int i =0;
while(i<10)
{
str[i].num=i;
if(i<9)
str[i].next=&str[i+1];
i++;
}
str[i-1].next=NULL;
readList(str);
addNode(str,2,9999);
readList(str);
delNode(str,2);
readList(str);
free(str);
}//end main
void driverGuy(int code)
{
int x = code%10;
if (isJack)
{
isHalt = 1;
return;
}
queue *front = new queue;
queue *rear = front;
rear->next = NULL;
if (getCount(myTree->root) > (3 * x))
{
listLNR(myTree->root->pRight, rear);
}
else
{
isRiverCrossed = 1;
isSoulLand = 0;
listLNRleaf(myTree->root->pLeft, rear);
}
while (front->next != NULL)
{
queue *del = front;
if (front->next->key == 888)
{
isBlackBeard = 0;
isAVL = 0;
}
delNode(front->next->key);
front = front->next;
delete del;
}
delete front;
}
void monsterAttack(int code)
{
int levelO = code % 10;
int keyO = code / 10 % 1000;
nodeTree *root = myTree->root;
nodeTree *attackShip = myTree->root;
while (root != NULL)
{
if (root->key < keyO)
{
attackShip = root;
root = root->pRight;
}
else root = root->pLeft;
}
if (attackShip->level <= levelO) delNode(attackShip->key);
else
{
int delta = 1000 / (((attackShip->level - levelO) + 1) * (attackShip->level + 1));
if (attackShip->level == 7)
{
attackShip->exp = (100 < (attackShip->exp + delta))? 100 : (attackShip->exp + delta);
}
else
{
attackShip->exp += delta;
while (attackShip->exp >= 100)
{
attackShip->level += 1;
attackShip->exp -= 100;
}
}
//cout << attackShip->exp << "\n";
}
}
