Node* shuffleMerge(Node* a, Node* b) { Node dummy; Node* tail=&dummy; dummy.next=NULL; while (1) { if (a==NULL) { tail->next=b; break; } else if (b==NULL) { tail->next=a; break; } else { moveNode(&a, &(tail->next)); tail=tail->next; moveNode(&b, &(tail->next)); tail=tail->next; } } return dummy.next; }
/////////////////////////////////////////////////////////////////////// // set method /////////////////////////////////////////////////////////////////////// void set(int key, int value) { if (mp.find(key)!=mp.end()){ moveNode(mp[key]); mp[key]->value = value; }else{ if (mp.size()==cp){ mp.erase(head->key); rmNode(head); } Node * node = new Node(key,value); mp[key] = node; insertNode(node); } }
bool KisNodeFacade::lowerNode(KisNodeSP node) { if (!node) return false; if (!node->parent()) return false; KisNodeSP parent = node->parent(); KisNodeSP prevSibling = node->prevSibling(); if (node->prevSibling()) { int prevIndex = parent->index(prevSibling); return moveNode(node, parent, prevIndex); } else { return true; // We're already at bottom, but there's no sense // in complaining } }
typename SortedList<T, Pred>::Node* SortedList<T, Pred>::merge_lists(typename SortedList<T, Pred>::Node* list1, unsigned length1, typename SortedList<T, Pred>::Node* list2, unsigned length2, const Sorter &sorter) { unsigned i = 0, j = 0; SortedList<T, Pred>::Node* front = sorter(list1->Data, list2->Data) ? list1 : list2; // I will arbitrarily decide to just shove everything into list1. while (i < length1 && j < length2 && list2 != tail_) { if (sorter(list1->Data, list2->Data)) { list1 = list1->Next; ++i; } else { SortedList<T, Pred>::Node* temp = list2; list2 = list2->Next; ++j; moveNode(temp, list1->Prev); } } // If there's any left over, append the rest. // If list1 is longer it's already in order and junk, so we // don't worry about it at all. /* while (j < length2 && list2 != tail_) { SortedList<T, Pred>::Node* temp = list2; list2 = list2->Next; ++j; moveNode(temp, list1->Prev); list1 = list1->Next; } */ // Aaaaaactually, all that is unnecessary. // In mergesort, the right block is always adjacent to the left block. // So, there's no point worrying about it, it's already appended for // your convenience. // The two should be stuck together now. // This should work because lists we're comparing should all be // adjacent to each other. return(front); }
void KOrthogonalMap::removeTileLayer(U32 TileID, U16 LayerIndex) { // check range if (TileID >= _krootList.size()) { KD_PRINT("tile id is out of range or tile map is not created yet"); return; } // empty tile (there is no layer) if (_krootList[TileID].layerSize == 0) return; // iterate over layers SIZE nodeIndex = _krootList[TileID].firstNode; SIZE prevNode = nodeIndex; for (U16 i = 0; i < _krootList[TileID].layerSize; ++i) { // layer not found if (_knodeList[nodeIndex].layerIndex > LayerIndex) break; // layer found if (_knodeList[nodeIndex].layerIndex == LayerIndex) { // first node if (i == 0) { _krootList[TileID].firstNode = _knodeList[nodeIndex].nextNode; } else { _knodeList[prevNode].nextNode = _knodeList[nodeIndex].nextNode; } --_krootList[TileID].layerSize; // swap and remove methode moveNode(_knodeList.back(), nodeIndex); _knodeList.pop_back(); break; } // store current node prevNode = nodeIndex; // move to next node nodeIndex = _knodeList[nodeIndex].nextNode; } }
void KOrthogonalMap::removeTileLayers(U32 TileID) { // check range if (TileID >= _krootList.size()) { KD_PRINT("tile id is out of range or tile map is not created yet"); return; } // iterate over nodes and remove them auto tempSize = _krootList[TileID].layerSize; for (SIZE i = 0; i < tempSize; ++i) { --_krootList[TileID].layerSize; // swap and remove methode // swap removed node with last node in the list moveNode(_knodeList.back(), _krootList[TileID].firstNode); _knodeList.pop_back(); // move first pointer to next node _krootList[TileID].firstNode = _knodeList[_krootList[TileID].firstNode].nextNode; } // cleanup root _krootList[TileID].firstNode = 0; }
node9->setPos(50, 50);*/ newNodeAct=new QAction(tr("&New Node"),this); newNodeAct->setShortcuts(QKeySequence::New); newNodeAct->setStatusTip(tr("Create a new node")); connect(newNodeAct,SIGNAL(triggered()),this,SLOT(newNode())); newEdgeAct=new QAction(tr("N&ew Edge"),this); //newEdgeAct->setShortcuts(QKeySequence::New); newEdgeAct->setStatusTip(tr("Create a new edge")); connect(newEdgeAct,SIGNAL(triggered()),this,SLOT(newEdge())); moveNodeAct=new QAction(tr("&Move Nodes"),this); moveNodeAct->setStatusTip(tr("Move nodes")); connect(moveNodeAct,SIGNAL(triggered()),this,SLOT(moveNode())); scale(qreal(0.8), qreal(0.8)); setMinimumSize(400, 400); setWindowTitle(tr("Elastic Nodes")); } GraphWidget::~GraphWidget() { foreach(PyObject* module,moduleList) { Py_DECREF(module); }
void SceneGraph::initialize(void (*callbackFn)(int nNode, void *info), void *callbackFnInfo) { Node *node; int nNode = 0; for (node = Parser::getNodes(); node; node = node->nextTraversal()) { node->setSceneGraph(this); if (node->isInstanceNode() == false) node->initialize(); nNode++; if (callbackFn) callbackFn(nNode, callbackFnInfo); } // Convert from InstanceNode into DEFNode node = Parser::getNodes(); while(node != NULL) { Node *nextNode = node->nextTraversal(); if (node->isInstanceNode() == true && node->isDEFNode() == false) { Node *referenceNode = node->getReferenceNode(); Node *parentNode = node->getParentNode(); Node *defNode; defNode = referenceNode->createDEFNode(); if (parentNode != NULL) parentNode->addChildNode(defNode, false); else addNode(defNode, false); node->remove(); delete node; nextNode = defNode->nextTraversal(); } node = nextNode; } // Convert from DEFNode into InstanceNode node = Parser::getNodes(); while(node != NULL) { Node *nextNode = node->nextTraversal(); if (node->isDEFNode() == true) { Node *defNode = findNode(node->getName()); assert(defNode); if (defNode) { Node *instanceNode = defNode->createInstanceNode(); Node *parentNode = node->getParentNode(); if (parentNode != NULL) parentNode->moveChildNode(instanceNode); else moveNode(instanceNode); node->remove(); delete node; } } node = nextNode; } recomputeBoundingBox(); for (Route *route = Parser::getRoutes(); route; route = route->next()) route->initialize(); }