/* recursively clone a tree */
static stTree *cloneTree(stTree *srcNode, stTree *destParent, struct malnCompCompMap *srcDestCompMap) {
stTree *destNode = cloneNode(srcNode, srcDestCompMap);
stTree_setParent(destNode, destParent);
for (int i = 0; i < stTree_getChildNumber(srcNode); i++) {
cloneTree(stTree_getChild(srcNode, i), destNode, srcDestCompMap);
}
return destNode;
}
UndirectedGraphNode *cloneNode(UndirectedGraphNode *node, unordered_map<UndirectedGraphNode*, UndirectedGraphNode*>& map) {
if (map.count(node)) return map[node];
UndirectedGraphNode* clone = new UndirectedGraphNode(node->label);
map[node] = clone;
for (auto n : node->neighbors)
clone->neighbors.push_back(cloneNode(n, map));
return clone;
}
PassRefPtr<Node> ShadowRoot::cloneNode(bool deep, ExceptionCode& ec)
{
RefPtr<Node> clone = cloneNode(deep);
if (!clone) {
ec = DATA_CLONE_ERR;
return 0;
}
return clone;
}
/**
* Clones simple linked list.
* @param node Pointer to the start node;
* @return Pointer to the start node of the cloned list.
*/
Node* cloneNode(Node* node) {
Node* newNode = (Node*) malloc(sizeof(Node));
newNode->vertex = node->vertex;
if (NULL != node->next) {
newNode->next = cloneNode(node->next);
} else {
newNode->next = NULL;
}
return newNode;
}
strNode* strNode::clone() const {
const strNode *nodePos = this;
strNode *newNodeRoot = cloneNode();
strNode *newNodePos = newNodeRoot;
while(nodePos->right){
newNodePos->right = nodePos->right->cloneNode();
newNodePos->right->left = newNodePos;
newNodePos = newNodePos->right;
nodePos = nodePos->right;
}
return newNodeRoot;
}
UndirectedGraphNode* cloneNode(UndirectedGraphNode* node, NodeMap& allNodes) {
if (!node)
return 0;
UndirectedGraphNode* newNode = new UndirectedGraphNode(node->label);
allNodes[node->label] = newNode;
for (size_t i = 0; i < node->neighbors.size(); ++i)
{
UndirectedGraphNode* neighbor = node->neighbors[i];
NodeMap::iterator nIter = allNodes.find(neighbor->label);
if (nIter != allNodes.end())
{
newNode->neighbors.push_back(nIter->second);
}
else
{
newNode->neighbors.push_back(cloneNode(neighbor, allNodes));
}
}
return newNode;
}
UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
if (NULL == node) {
return NULL;
}
unordered_set<UndirectedGraphNode *> cloned_set;
queue<UndirectedGraphNode *> q;
q.push(node);
UndirectedGraphNode *new_node = NULL;
while (q.size()) {
node = q.front();
q.pop();
// clone
UndirectedGraphNode* clone_node = cloneNode(node);
cout << long(&node) << " " << long(&clone_node) << endl;
// mark first cloned node for return
if (cloned_set.empty()) {
new_node = clone_node;
}
// add node to visited
cloned_set.insert(node);
// add not visited neighbors into queue
vector<UndirectedGraphNode *> neighbors = node->neighbors;
for (int i = 0; i < neighbors.size(); i++) {
if (cloned_set.find(neighbors[i]) == cloned_set.end()) {
q.push(neighbors[i]);
}
}
}
return new_node;
}
/**
* Clones a graph.
* @param graph The graph to clone.
* @return The cloned graph.
*/
Graph cloneGraph(const Graph graph) {
Graph clonedGraph;
Node** edges;
int* edgesCount;
int i;
edges = (Node**) malloc(sizeof(Node*) * graph.n);
edgesCount = (int*) malloc(sizeof(int) * graph.n);
for (i = 0; i < graph.n; i++) {
edgesCount[i] = graph.edgesCount[i];
edges[i] = NULL;
if (NULL != graph.edges[i]) {
edges[i] = cloneNode(graph.edges[i]);
}
}
clonedGraph.n = graph.n;
clonedGraph.m = graph.m;
clonedGraph.edges = edges;
clonedGraph.edgesCount = edgesCount;
return clonedGraph;
}
UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
if (!node) return nullptr;
unordered_map<UndirectedGraphNode*, UndirectedGraphNode*> map;
return cloneNode(node, map);
}
int main(void)
{
element *html = readDocument();
// createElement
element *t1 = createElement("t1", "Text node");
assert("createElement - empty pointers - parentNode", t1->parentNode == NULL);
assert("createElement - empty pointers - nextSibling", t1->nextSibling == NULL);
assert("createElement - empty pointers - previousSibling", t1->previousSibling == NULL);
assert("createElement - empty pointers - firstChild", t1->firstChild == NULL);
assert("createElement - empty pointers - lastChild", t1->lastChild == NULL);
// appendChild
appendChild(html->lastChild, t1);
assert("Append child test - parent pointer", t1->parentNode == html->lastChild);
assert("Append only child test - previousSibling pointer", t1->previousSibling == NULL);
assert("Append only child test - nextSibling pointer", t1->nextSibling == NULL);
element *t2 = createElement("t2", NULL);
appendChild(html->lastChild, t2);
assert("Append second child test - previousSibling pointer to the first child", t2->previousSibling == html->lastChild->firstChild);
assert("Append second child test - nextSibling pointer to NULL", t2->nextSibling == NULL);
element *t3 = createElement("t3", NULL);
appendChild(html->lastChild, t3);
assert("Append third child test - second child nextSibling pointer equals to the pointer to the last child", t2->nextSibling == html->lastChild->lastChild);
// replaceChild
element *r2 = createElement("r2", NULL);
replaceChild(html->lastChild, r2, html->lastChild->firstChild->nextSibling);
assert("Replace child in the middle - parent", r2->parentNode == html->lastChild);
assert("Replace child in the middle - prevSibling", r2->previousSibling == html->lastChild->firstChild);
assert("Replace child in the middle - nextSibling", r2->nextSibling == html->lastChild->lastChild);
element *r3 = createElement("r3", NULL);
replaceChild(html->lastChild, r3, html->lastChild->lastChild);
assert("Replace last child - prevSibling", (r3->previousSibling == html->lastChild->firstChild->nextSibling) && (r3->previousSibling == r2));
assert("Replace last child - nextSibling", r3->nextSibling == NULL);
element *r1 = createElement("r1", NULL);
replaceChild(html->lastChild, r1, html->lastChild->firstChild);
assert("Replace first child - prevSibling", r1->previousSibling == NULL);
assert("Replace first child - nextSibling", r1->nextSibling == r2);
// removeChild
removeChild(html->lastChild, r1);
assert("Remove child - first child removed", html->lastChild->firstChild == r2);
removeChild(html->lastChild, r3);
assert("Remove child - last (not least) child is removed", html->lastChild->lastChild == r2);
assert("Remove child - last (not least) child is removed - siblings check for the remaining child", r2->previousSibling == NULL && r2->nextSibling == NULL);
removeChild(r2->parentNode, r2);
assert("Remove child - body is empty", html->lastChild->firstChild == NULL && html->lastChild->lastChild == NULL);
appendChild(html->lastChild, r1);
appendChild(html->lastChild, r2);
appendChild(html->lastChild, r3);
removeChild(r2->parentNode, r2);
assert("Remove the middle child - relation between first and last",
html->lastChild->firstChild->nextSibling == html->lastChild->lastChild &&
html->lastChild->firstChild == html->lastChild->lastChild->previousSibling);
removeChild(html->lastChild, r1);
removeChild(html->lastChild, r3);
// insertBefore
appendChild(html->lastChild, r3);
insertBefore(html->lastChild, r2, r3);
assert("insertBefore - new firstChild", html->lastChild->firstChild == r2);
assert("insertBefore - lastChild kept", html->lastChild->lastChild == r3);
assert("insertBefore - parentNode set", html->lastChild == r2->parentNode);
insertBefore(html->lastChild, r1, r3);
assert("insertBefore - siblings", r1->previousSibling == r2 && r1->nextSibling == r3);
assert("insertBefore - previousSibling->nextSibling == added element", r2->nextSibling == r1);
removeChild(html->lastChild, r1);
removeChild(html->lastChild, r2);
removeChild(html->lastChild, r3);
// cloneNode
appendChild(r2, t1);
appendChild(t1, t2);
appendChild(r2, t3);
element *c0 = cloneNode(t2, false);
insertBefore(r2, c0, t3);
element *c1 = cloneNode(r2, true);
element *c2 = cloneNode(r2, false);
appendChild(html->lastChild, c1);
appendChild(html->lastChild, c2);
element *c3 = cloneNode(r3, true); // r3
insertBefore(html->lastChild, c3, c1);
// Now it should be in order: r3, r2 deep, r2
assert("Clone - first r2 is deep", html->lastChild->firstChild->nextSibling->firstChild->firstChild != NULL // html body r2 t1 t2
&& html->lastChild->firstChild->nextSibling->lastChild != NULL); // html body r2 t3
deleteElement(r1);
deleteElement(r2);
deleteElement(r3);
deleteElement(html);
return 0;
}
UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
// Note: The Solution object is instantiated only once and is reused by each test case.
NodeMap allNodes;
UndirectedGraphNode* result = cloneNode(node, allNodes);
return result;
}
/**
* Min cuts randomized contraction algorithm. It does not always return the
* correct value, should be repeated. For n^2 * log n the probaility to fail
* is < 1 / n
*
* @param graph The graph to calculate min cuts.
* @return Min cuts count.
*/
int randomizedContraction(const Graph graph) {
Graph g = cloneGraph(graph);
int randomVertex, randomLinkedVertexIndex, randomLinkedVertex,
graphNoOfNodes = graph.n, k, returnValue = -1;
Node *node, *node2, *node3, *node3Prev;
int* randomlyChoosed = (int*) malloc(sizeof(int) * graph.n);
int i;
for (i = 0; i < graph.n; i++) {
randomlyChoosed[i] = 0;
}
while (graphNoOfNodes > 2) {
/* pickup a random edge */
do {
srand(time(NULL));
randomVertex = rand() % graph.n;
} while (randomlyChoosed[randomVertex]);
randomlyChoosed[randomVertex] = 1;
srand(time(NULL));
randomLinkedVertexIndex = rand() % g.edgesCount[randomVertex];
node = g.edges[randomVertex];
k = 0;
while (NULL != node && k < randomLinkedVertexIndex) {
node = node->next;
k++;
}
/* contract randomVertex into randomLinkedVertex */
if (NULL != node) {
randomLinkedVertex = node->vertex;
/* modify globally edges to point to the new combined vertex */
for (i = 0; i < graph.n; i++) {
if (!randomlyChoosed[i]) {
node2 = g.edges[i];
while (NULL != node2) {
if (node2->vertex == randomVertex) {
node2->vertex = randomLinkedVertex;
}
node2 = node2->next;
}
}
}
/* add randomVertex 's edges to the randomLinkedVertex 's edges */
node2 = g.edges[randomVertex];
if (NULL != node2) {
node3 = g.edges[randomLinkedVertex];
if (NULL != node3) {
while (NULL != node3->next) {
node3 = node3->next;
}
node3->next = cloneNode(node2);
} else {
g.edges[randomLinkedVertex] = cloneNode(node2);
}
}
g.edgesCount[randomLinkedVertex] += g.edgesCount[randomVertex];
/* eliminate self pointing edges of randomLinkedVertex */
node3 = g.edges[randomLinkedVertex];
node3Prev = NULL;
while (NULL != node3) {
if (node3->vertex == randomLinkedVertex
|| node3->vertex == randomVertex) {
if (NULL != node3Prev) {
node3Prev->next = node3->next;
} else {
g.edges[randomLinkedVertex] = node3->next;
}
node3 = node3->next;
g.edgesCount[randomLinkedVertex]--;
} else {
node3Prev = node3;
node3 = node3->next;
}
}
}
graphNoOfNodes--;
}
/* 2 vertices left, return the number of edges of the first one found */
for (i = 0; i < graph.n; i++) {
if (!randomlyChoosed[i]) {
returnValue = g.edgesCount[i];
break;
}
}
freeGraph(&g);
free(randomlyChoosed);
return returnValue;
}
PassRefPtr<Node> ShadowRoot::cloneNode(ExceptionState& exceptionState)
{
return cloneNode(exceptionState);
}
PassRefPtr<Element> Element::cloneElement()
{
return static_pointer_cast<Element>(cloneNode(false));
}
/**
* Makes a copy of y's child x and automatically links it with y.
*/
void cloneSpec (PRBTreeNode * x, PRBTreeNode * y)
{
if (x == y->left) y->left = cloneNode(x);
else y->right = cloneNode(x);
}