int BST::recursiveInsert(const int &val, BSTNode * node){
// if(node == nullptr){
// node->data = val;
// return val;
// }
if(node->data == val){
return 0;
}
if(node->data > val){
if(node->left == nullptr){
node->left = new BSTNode();
node->left->data = val;
node->left->parent = node;
++ size;
return val;
}else{
return recursiveInsert(val, node->left);
}
}else{
if(node->right == nullptr){
node->right = new BSTNode();
node->right->data = val;
node->right->parent = node;
++ size;
return val;
}else{
return recursiveInsert(val, node->right);
}
}
}
int BST::insert(int val){
if(root == nullptr){
root = new BSTNode();
root->data = val;
return val;
}
recursiveInsert(val, root);
}
/* Recursive function to insert node into list */
int recursiveInsert (Node * traversalNode, int dataToInsert){
if(traversalNode == 0){
traversalNode = malloc(sizeof(Node));
traversalNode->data = dataToInsert;
traversalNode->leftNode = 0;
traversalNode->rightNode = 0;
return 1;
}
if(traversalNode->data > dataToInsert){
return recursiveInsert(traversalNode->rightNode,dataToInsert);
}else if(traversalNode->data < dataToInsert) {
return recursiveInsert(traversalNode->leftNode,dataToInsert);
}
else {
return 0;
}
}
void C_galgas_type_descriptor::recursiveInsert (C_galgas_type_descriptor * & ioRootPtr,
C_galgas_type_descriptor * inDescriptor,
bool & ioExtension) {
if (ioRootPtr == NULL) {
ioExtension = true ;
ioRootPtr = inDescriptor ;
}else{
const int32_t comparaison = strcmp (ioRootPtr->mGalgasTypeName, inDescriptor->mGalgasTypeName) ;
if (comparaison > 0) {
recursiveInsert (ioRootPtr->mPreviousType, inDescriptor, ioExtension) ;
if (ioExtension) {
ioRootPtr->mBalance++;
if (ioRootPtr->mBalance == 0) {
ioExtension = false;
}else if (ioRootPtr->mBalance == 2) {
if (ioRootPtr->mPreviousType->mBalance == -1) {
rotateLeft (ioRootPtr->mPreviousType) ;
}
rotateRight (ioRootPtr) ;
ioExtension = false;
}
}
}else if (comparaison < 0) {
recursiveInsert (ioRootPtr->mNextType, inDescriptor, ioExtension) ;
if (ioExtension) {
ioRootPtr->mBalance-- ;
if (ioRootPtr->mBalance == 0) {
ioExtension = false ;
}else if (ioRootPtr->mBalance == -2) {
if (ioRootPtr->mNextType->mBalance == 1) {
rotateRight (ioRootPtr->mNextType) ;
}
rotateLeft (ioRootPtr) ;
ioExtension = false;
}
}
}else{
ioExtension = false;
C_String errorMessage ;
errorMessage << "FATAL ERROR (type '@" << inDescriptor->mGalgasTypeName << "' already defined)" ;
fatalError (errorMessage, __FILE__, __LINE__) ;
}
}
}
C_galgas_type_descriptor::C_galgas_type_descriptor (const char * inGalgasTypeName,
const C_galgas_type_descriptor * inSuperClassDescriptor) :
mNextType (NULL),
mPreviousType (NULL),
mBalance (0),
mGalgasTypeName (inGalgasTypeName),
mSlotID (gSlotID),
mSuperclassDescriptor (inSuperClassDescriptor) {
gSlotID ++ ;
bool extension = false ; // Unused here
recursiveInsert (gGalgasTypeListRoot, this, extension) ;
}
int BTInsert (BinaryTreePtr btp, int a) {
if (btp->head == 0) {
Node * newNode = malloc(sizeof(Node));
newNode->data = a;
newNode->leftNode = 0;
newNode->rightNode = 0;
return 1;
} else {
Node * traversalNode = btp->head;
recursiveInsert(traversalNode);
}
}
bool BPlusTree::add(Record* record) {
/* Si el tamanio del registro que quiero insertar es mayor al porcentaje TreeConstraits::getPercentRecord() del nodo, lanzo una excepcion */
if ((int)record->getSize() > (TreeConstraits::getEfectiveSizeNode() * TreeConstraits::getPercentRecord() / 100) || record->getKey()->getSize() > keyTopSize)
throw new exception;
Node* newChildNode = NULL;
Key toPromoteKey;
if (root == NULL) {
root = createLeafNode();
root->number = firstLeaf = 0;
serializeDataConfig();
(static_cast <LeafNode*> (root))->nextLeaf = 0;
this->NodesMount = 1;
}
bool result = recursiveInsert(root, *(record->getKey()), *(record->getData()), &toPromoteKey, &newChildNode);
if (newChildNode) {
persistNode(newChildNode);
InnerNode* newRoot = createInnerNode(root->level + 1);
// Muevo la raiz a otra posicion y persisto la nueva raiz en la posicion cero
root->number = getNodeNumberToSeize();
if (root->isLeaf()) {
firstLeaf = root->number;
serializeDataConfig();
}
persistNode(root);
newRoot->keys[0] = toPromoteKey;
newRoot->sons[0] = root->number;
newRoot->sons[1] = newChildNode->number;
newRoot->keyMount = 1;
newRoot->occupiedSpace += toPromoteKey.getSize() + TreeConstraits::getControlSizeRecord();
newRoot->number = 0;
persistNode(newRoot);
freeNodeMemory(root);
freeNodeMemory(newChildNode);
root = newRoot;
} else {
persistNode(root);
}
return result;
}
void FolderWizardTargetPage::slotUpdateDirectories(QStringList list)
{
QString webdavFolder = QUrl(ownCloudInfo::instance()->webdavUrl()).path();
QTreeWidgetItem *root = _ui.folderTreeWidget->topLevelItem(0);
if (!root) {
root = new QTreeWidgetItem(_ui.folderTreeWidget);
root->setText(0, Theme::instance()->appNameGUI());
root->setIcon(0, Theme::instance()->applicationIcon());
root->setToolTip(0, tr("Choose this to sync the entire account"));
root->setData(0, Qt::UserRole, "/");
}
foreach (QString path, list) {
path.remove(webdavFolder);
QStringList paths = path.split('/');
if (paths.last().isEmpty()) paths.removeLast();
recursiveInsert(root, paths, path);
}
void FolderWizardTargetPage::slotUpdateDirectories(QStringList list)
{
QFileIconProvider prov;
QIcon folderIcon = prov.icon(QFileIconProvider::Folder);
QString webdavFolder = QUrl(ownCloudInfo::instance()->webdavUrl()).path();
connect(_ui.folderTreeWidget, SIGNAL(itemExpanded(QTreeWidgetItem*)), SLOT(slotItemExpanded(QTreeWidgetItem*)));
QTreeWidgetItem *root = _ui.folderTreeWidget->topLevelItem(0);
if (!root) {
root = new QTreeWidgetItem(_ui.folderTreeWidget);
root->setText(0, tr("Root (\"/\")", "root folder"));
root->setIcon(0, folderIcon);
root->setToolTip(0, tr("Choose this to sync the entire account"));
root->setData(0, Qt::UserRole, "/");
}
foreach (QString path, list) {
path.remove(webdavFolder);
QStringList paths = path.split('/');
if (paths.last().isEmpty()) paths.removeLast();
recursiveInsert(root, paths, path);
}
static void recursiveInsert(QTreeWidgetItem *parent, QStringList pathTrail, QString path)
{
QFileIconProvider prov;
QIcon folderIcon = prov.icon(QFileIconProvider::Folder);
if (pathTrail.size() == 0) {
if (path.endsWith('/')) {
path.chop(1);
}
parent->setToolTip(0, path);
parent->setData(0, Qt::UserRole, path);
} else {
QTreeWidgetItem *item = findFirstChild(parent, pathTrail.first());
if (!item) {
item = new QTreeWidgetItem(parent);
item->setIcon(0, folderIcon);
item->setText(0, pathTrail.first());
item->setChildIndicatorPolicy(QTreeWidgetItem::ShowIndicator);
}
pathTrail.removeFirst();
recursiveInsert(item, pathTrail, path);
}
}
bool BPlusTree::recursiveInsert(Node* nodoCorriente, Key clave, ByteString dato, Key* clavePromocion, Node** nuevoNodo) {
if (!nodoCorriente->isLeaf()) {
InnerNode *nodoInteriorCorriente = static_cast<InnerNode*> (nodoCorriente);
Key nuevaClave;
Node* nuevoNodoHijo = NULL;
int posicion = getPosition(nodoInteriorCorriente, clave);
Node* nodoHijo = hidratateNode(nodoInteriorCorriente->sons[posicion]);
bool resultado = recursiveInsert(nodoHijo, clave, dato, &nuevaClave, &nuevoNodoHijo);
if (nuevoNodoHijo) {
if (nodoInteriorCorriente->isOverflow(nuevaClave.getSize() + TreeConstraits::getControlSizeRecord() + keyTopSize)) {
splitInnerNode(nodoInteriorCorriente, clavePromocion, nuevoNodo, posicion);
if (posicion == nodoInteriorCorriente->keyMount + 1
&& nodoInteriorCorriente->keyMount < (*nuevoNodo)->keyMount) {
InnerNode *nuevoNodoInterior = static_cast<InnerNode*> (*nuevoNodo);
nodoInteriorCorriente->keys[nodoInteriorCorriente->keyMount] = *clavePromocion;
nodoInteriorCorriente->sons[nodoInteriorCorriente->keyMount + 1] = nuevoNodoInterior->sons[0];
nodoInteriorCorriente->keyMount++;
nodoInteriorCorriente->occupiedSpace += (*clavePromocion).getSize() + TreeConstraits::getControlSizeRecord();
nuevoNodoInterior->sons[0] = nuevoNodoHijo->number;
*clavePromocion = nuevaClave;
persistNode(nuevoNodoHijo);
freeNodeMemory(nuevoNodoHijo);
persistNode(nodoHijo);
freeNodeMemory(nodoHijo);
return resultado;
} else {
if (posicion >= nodoInteriorCorriente->keyMount + 1) {
posicion -= (nodoInteriorCorriente->keyMount + 1);
nodoInteriorCorriente = static_cast<InnerNode*> (*nuevoNodo);
}
}
}
int i = nodoInteriorCorriente->keyMount;
while (i > posicion) {
nodoInteriorCorriente->keys[i] = nodoInteriorCorriente->keys[i - 1];
nodoInteriorCorriente->sons[i + 1] = nodoInteriorCorriente->sons[i];
i--;
}
nodoInteriorCorriente->keys[posicion] = nuevaClave;
nodoInteriorCorriente->sons[posicion + 1] = nuevoNodoHijo->number;
nodoInteriorCorriente->keyMount++;
nodoInteriorCorriente->occupiedSpace += nuevaClave.getSize() + TreeConstraits::getControlSizeRecord();
persistNode(nuevoNodoHijo);
freeNodeMemory(nuevoNodoHijo);
}
persistNode(nodoHijo);
freeNodeMemory(nodoHijo);
return resultado;
} else {
LeafNode *nodoHojaCorriente = static_cast<LeafNode*> (nodoCorriente);
int posicion = getPosition(nodoHojaCorriente, clave);
// chequea que no exista la clave
if (posicion < nodoHojaCorriente->keyMount && equalKey(clave, nodoHojaCorriente->keys[posicion])) {
return false;
}
int i = nodoHojaCorriente->keyMount - 1;
while (i >= 0 && minorKey(clave, nodoHojaCorriente->keys[i])) {
nodoHojaCorriente->keys[i + 1] = nodoHojaCorriente->keys[i];
nodoHojaCorriente->byteData[i + 1] = nodoHojaCorriente->byteData[i];
i--;
}
nodoHojaCorriente->keys[i + 1] = clave;
nodoHojaCorriente->byteData[i + 1] = dato;
nodoHojaCorriente->keyMount++;
nodoHojaCorriente->occupiedSpace += dato.getSize() + clave.getSize() + TreeConstraits::getControlSizeRecord();
if (nodoHojaCorriente->isOverflow(keyTopSize)) {
splitLeafNode(nodoHojaCorriente, clavePromocion, nuevoNodo);
if (posicion >= nodoHojaCorriente->keyMount) {
posicion -= nodoHojaCorriente->keyMount;
nodoHojaCorriente = static_cast<LeafNode*> (*nuevoNodo);
}
}
if (nuevoNodo && nodoHojaCorriente != *nuevoNodo && posicion == nodoHojaCorriente->keyMount - 1) {
*clavePromocion = clave;
}
return true;
}
}
IntervalTreeNode* IntervalTree::insert(SimpleInterval* new_interval)
{
IntervalTreeNode* y;
IntervalTreeNode* x;
IntervalTreeNode* new_node;
x = new IntervalTreeNode(new_interval);
recursiveInsert(x);
fixupMaxHigh(x->parent);
new_node = x;
x->red = true;
while(x->parent->red)
{
/// use sentinel instead of checking for root
if(x->parent == x->parent->parent->left)
{
y = x->parent->parent->right;
if(y->red)
{
x->parent->red = true;
y->red = true;
x->parent->parent->red = true;
x = x->parent->parent;
}
else
{
if(x == x->parent->right)
{
x = x->parent;
leftRotate(x);
}
x->parent->red = false;
x->parent->parent->red = true;
rightRotate(x->parent->parent);
}
}
else
{
y = x->parent->parent->left;
if(y->red)
{
x->parent->red = false;
y->red = false;
x->parent->parent->red = true;
x = x->parent->parent;
}
else
{
if(x == x->parent->left)
{
x = x->parent;
rightRotate(x);
}
x->parent->red = false;
x->parent->parent->red = true;
leftRotate(x->parent->parent);
}
}
}
root->left->red = false;
return new_node;
}