/* Insert sessid and socket pair in AVL Tree */
AVLTree_Node* insertion(AVLTree_Node *T,uint16_t x, struct node *head)
{
if(T==NULL)
{
T=(AVLTree_Node*)malloc(sizeof(AVLTree_Node));
T->data=x;
T->head = head;
T->left=NULL;
T->right=NULL;
}
else
if(x > T->data) // insert in right subtree
{
T->right=insertion(T->right,x,head);
if(BF(T)==-2)
if(x>T->right->data)
T=RR(T);
else
T=RL(T);
}
else
if(x<T->data)
{
T->left=insertion(T->left,x,head);
if(BF(T)==2)
if(x < T->left->data)
T=LL(T);
else
T=LR(T);
}
T->ht=height(T);
//root=T;
return(T);
}
/**
* Sort array ar[left,right] using Quicksort method.
*/
void do_qsort (void *const pbase, size_t n, size_t s,
int(*cmp)(const void *,const void *)) {
void *pp;
long ct, num;
if (n <= 1) { return; }
/* locate median (also placeds it in pbase[n-1]. */
selectPivotIndex(pbase,n,s,cmp);
pp = partition (pbase,n,s,cmp);
ct = (long)pp - (long)pbase;
num = ct / s;
if (ct > minSize*s && ct > s) {
do_qsort (pbase, num, s, cmp);
} else if (ct > 1) {
insertion (pbase, num, s, cmp);
}
ct = (long)pbase + (n-1)*s - (long)pp;
num = ct / s;
if (ct > minSize*s && ct > s) {
do_qsort (pp+s, num, s, cmp);
} else if (ct > 1) {
insertion (pp+s, num, s, cmp);
}
}
/* joueur humain joue un coup */
int jouer(int tour)
{
int ligne, col;
int correctAnswer = 0;
do {
ligne = saisie_donnee("Ligne : ");
col = saisie_donnee("Colonne : ");
if(g.tab[col][ligne] != '.')
correctAnswer = 1;
} while(correctAnswer == 1);
struct Coup *coup = malloc(sizeof(coup));
if(tour == 0) {
coup->ligne = ligne;
coup->colonne = col;
strncpy(coup->player, game->nomJoueur1, PLAYER_NAME_SIZE);
insertion(liste, coup);
g.tab[col][ligne] = 'O';
} else {
coup->ligne = ligne;
coup->colonne = col;
strncpy(coup->player, game->nomJoueur2, PLAYER_NAME_SIZE);
insertion(liste, coup);
g.tab[col][ligne] = 'X';
}
afficherListe(liste);
return 0;
}
// Fonction d'insertion d'un élément dans un arbre
// Insere l'élément au bon endroit
// Equilibre l'arbre
ABRe *insertion(ABRe *abr, Noeud **x) {
if(!abr)
return creer_abr(*x);
if(compareN(*x,abr->n)==0) {
*x=abr->n;
return abr;
}
if(compareN(*x,abr->n)<0) {
if(!abr->g) {
ABRe *a=creer_abr(*x);
abr->g=a;
}
else
abr->g=equilibre(insertion(abr->g,x));
}
else {
if(!abr->d) {
ABRe *a=creer_abr(*x);
abr->d=a;
}
else
abr->d=equilibre(insertion(abr->d,x));
}
majHauteur(abr);
return equilibre(abr);
}
avlnode * Tree::insertion(avlnode * temp, int value, int value1)
{
avlnode * temp1 = findnode(value);
if (temp1!=NULL)
{
((temp1->head2)->head)=(temp1->head2)->add(value1);
return temp;
}
if (temp==NULL)
{
temp = new avlnode;
temp->data=value;
temp->left=NULL;
temp->right=NULL;
temp->head2=new Connection;
((temp->head2)->head)=(temp->head2)->add(value1);
}
else if (value>temp->data)
{
temp->left=insertion(temp->left, value, value1);
temp=balance (temp);
}
else if (value<temp->data)
{
temp->right=insertion(temp->right, value, value1);
temp=balance (temp);
}
return temp;
}
// Fonction d'insertion d'un élément dans un arbre
// Insere l'élément au bon endroit
// Equilibre l'arbre
ABR *insertion(ABR *abr, int x) {
if(!abr)
return creer_abr(x);
if(x==abr->n)
return abr;
if(x<abr->n) {
if(!abr->g) {
ABR *a=creer_abr(x);
abr->g=a;
}
else
abr->g=equilibre(insertion(abr->g,x));
}
else {
if(!abr->d) {
ABR *a=creer_abr(x);
abr->d=a;
}
else
abr->d=equilibre(insertion(abr->d,x));
}
majHauteur(abr);
return equilibre(abr);
}
/* insertion in binary search tree */
void insertion(struct treeNode **node, int data) {
if (*node == NULL) {
*node = createNode(data);
} else if (data < (*node)->data) {
insertion(&(*node)->left, data);
} else if (data > (*node)->data) {
insertion(&(*node)->right, data);
}
}
int main()
{
Liste *maListe = initialisation();
insertion(maListe, 4);
insertion(maListe, 8);
insertion(maListe, 15);
suppression(maListe);
afficherListe(maListe);
return 0;
}
/* insertion in binary search tree */
void insertion(node **nd, int data)
{
if (*nd == NULL)
{
*nd = createNode(data);
}
else if (data < (*nd)->data)
{
insertion(&(*nd)->left, data);
}
else if (data > (*nd)->data)
{
insertion(&(*nd)->right, data);
}
}
// ----------------------------------------------------------------------------
bool
CVcfReader::xAssignVariantDelins(
const CVcfData& data,
unsigned int index,
CRef<CSeq_feat> pFeature )
// ----------------------------------------------------------------------------
{
CVariation_ref::TData::TSet::TVariations& variants =
pFeature->SetData().SetVariation().SetData().SetSet().SetVariations();
CRef<CVariation_ref> pVariant(new CVariation_ref);
{{
string insertion(data.m_Alt[index]);
CRef<CSeq_literal> pLiteral(new CSeq_literal);
pLiteral->SetSeq_data().SetIupacna().Set(insertion);
pLiteral->SetLength(insertion.size());
CRef<CDelta_item> pItem(new CDelta_item);
pItem->SetSeq().SetLiteral(*pLiteral);
CVariation_inst& instance = pVariant->SetData().SetInstance();
//Let's try to smartly set the Type.
if( data.m_Alt[index].size() == 1 && data.m_strRef.size() == 1) {
instance.SetType(CVariation_inst::eType_snv);
} else {
instance.SetType(CVariation_inst::eType_delins);
}
instance.SetDelta().push_back(pItem);
}}
variants.push_back(pVariant);
return true;
}
// ----------------------------------------------------------------------------
bool
CVcfReader::xAssignVariantIns(
const CVcfData& data,
unsigned int index,
CRef<CSeq_feat> pFeature )
// ----------------------------------------------------------------------------
{
CVariation_ref::TData::TSet::TVariations& variants =
pFeature->SetData().SetVariation().SetData().SetSet().SetVariations();
CRef<CVariation_ref> pVariant(new CVariation_ref);
{{
string insertion(data.m_Alt[index]);
CRef<CSeq_literal> pLiteral(new CSeq_literal);
pLiteral->SetSeq_data().SetIupacna().Set(insertion);
pLiteral->SetLength(insertion.size());
CRef<CDelta_item> pItem(new CDelta_item);
pItem->SetAction(CDelta_item::eAction_ins_before);
pItem->SetSeq().SetLiteral(*pLiteral);
CVariation_inst& instance = pVariant->SetData().SetInstance();
instance.SetType(CVariation_inst::eType_ins);
instance.SetDelta().push_back(pItem);
}}
variants.push_back(pVariant);
return true;
}
void unico (int *inteiros, int n) // esta função analisa quais elementos de um vetor não se repetem
{
if (n > 8 && n != 1) // entre as linhas 53 e 56 é checado qual o melhor algortimo de ordenação baseado no tamanho do vetor
quicksort(inteiros,0, n-1);
if(n < 8 && n != 1)
insertion(inteiros, n);
int x = 0;
int *valores_unicos = NULL; // este ponteiro aponta para o endereço de memória dos valores únicos
while(x<=n-2) // este ciclo verifica elementos únicos entre x=0 e x=n-2
{
if(*(inteiros + x + 1) > *(inteiros + x))
{
valores_unicos = inteiros + x;
printf("%i\n", *(inteiros + x));
x++;
}
if(*(inteiros + x + 1) == *(inteiros + x))
{
while(*(inteiros + x) == *(inteiros + x + 1))
x++;
x++; //Quando o ciclo terminar vet[x] ainda será igual ao valor que estava repetindo,
//adicionando +1 a x, o valor seguinte será diferente.
}
}
if (x == n-1 && *(inteiros + x) > *(inteiros + x + 1)) // verifica se apenas o último valor é único
{
valores_unicos = inteiros + x;
printf("%i\n", *(inteiros + x));
}
if(valores_unicos == NULL && n != 1) // se o ponteiro não apontar para nenhum endereço de memória, então não há valores únicos
printf("Nao ha valores unicos.\n");
}
int main(int argc, char *argv[])
{
uEntity* u= malloc(sizeof(uEntity));
int r = init_uEntity(u);
if (r==0) {
(*u).ent->id = argv[1];
(*u).id_app = "12345979";
insertion((*u).ent,argv[2],atoi(argv[3]));
if(strcmp((*u).ent->my_ip,argv[1])!=0){
pthread_t th1;
pthread_create(&th1,NULL,pth_tserv,(*u).ent);
pthread_t th2;
pthread_create(&th2,NULL,rec_udp,u);
pthread_t th3;
pthread_create(&th3,NULL,envoi_udp,u);
pthread_join(th1,NULL);
pthread_join(th2,NULL);
pthread_join(th3,NULL);
}
//pthread_t th4;
//pthread_create(&th4,NULL,rec_multi_udp,u);
//pthread_join(th1,NULL);
//pthread_join(th4,NULL);
}else{
printf("Problem with init entity\n");
}
return 0;
}
int main()
{
INT N = 3242;
INT M = 23;
INT NN = insertion(N, M, 5, 2);
std::cout<<std::bitset<32>(N) << "\t" << std::bitset<32>(M) << "\t" << std::bitset<32>(NN) << "\n";
}
int main() {
int val, ch;
while (1) {
printf("1. Inserção\t2. Deletar\n");
printf("3. Procurar\t4. Mostrar\n");
printf("5. Sair\nEntre com a opcao:");
scanf("%d", &ch);
switch (ch) {
case 1:
printf("Entre com o elemento a ser inserido:");
scanf("%d", &val);
insertion(val);
break;
case 2:
printf("Entre com o elemento que deseja remover:");
scanf("%d", &val);
deletion(val, root);
break;
case 3:
printf("Entre com o elemento que deseja procurar");
scanf("%d", &val);
searching(val, &ch, root);
break;
case 4:
traversal(root);
break;
case 5:
exit(0);
default:
printf("Voce entrou com uma opcao invalida!!\n");
break;
}
printf("\n");
}
}
/*
* Titre: initialisation
*
* Description: Initialise une liste avec un nombre
*
* Retour: Liste
*/
Liste *initialisation(int n, int k)
{
Liste *liste = malloc(sizeof(*liste));
Element *element = malloc(sizeof(*element));
if (liste == NULL || element == NULL)
{
exit(EXIT_FAILURE);
}
element->nombre = 1;
element->suivant = NULL;
liste->premier = element;
liste->courant = NULL;
liste->dernier = element;
int i;
for(i=2;i<=n;i++)
{
insertion(liste, i);
}
liste->courant = liste->dernier;
return liste;
}
void Calendar::addEvent()
{
EventDialog dialog(this);
dialog.setModal(true);
if(dialog.exec() == QDialog::Accepted)
{
Event tmpEvent = dialog.getEvent();
qDebug() << tmpEvent.name();
if((!tmpEvent.name().isEmpty()) || (!tmpEvent.description().isEmpty()))
{
QSqlQueryModel check;
check.setQuery("SELECT * FROM events WHERE date_time='" + tmpEvent.dateTime().toString(m_dateFormat) + "'", m_db);
if(check.rowCount() == 0)
{
QSqlQuery insertion(m_db);
insertion.prepare("INSERT INTO events(name, description, date_time) VALUES"
"(?,?,?)");
insertion.addBindValue(tmpEvent.name());
insertion.addBindValue(tmpEvent.description());
insertion.addBindValue(tmpEvent.dateTime().toString(m_dateFormat));
insertion.exec();
qDebug() << "Pushed";
m_sqlTableModel->select();
}
else
{
//Item with this date already exists
QMessageBox::warning(this, tr("Calendar"), tr("Item with this date and time already exists."));
}
}
}
}
main()
{
int *vet; //Declaro um vetor de inteiros
int i=1;
int n, x1, x2, dif1, dif2; //Declaroção algumas variáveis que serão utilizados ao longo do programa
printf("Digite o numero de inteiros a serem lidos (maior ou igual a 2): "); //Entra com o número n>=2 que define o total de valores a serem lidos
scanf("%d", &n);
while(n<=2) //Caso o usuário digite um valor menor do que 2
{
printf("Eh necessário, pelo menos, um par de inteiros para o programa funcionar\nDigite um valor maior ou igual a dois:");
scanf("%d", &n);
}
vet=(int*)malloc(sizeof(int)*n); //Alocação de memória para um vetor com n elementos
read_numbers(vet, n); //Leitura das entradas e armazenamento no vetor
insertion(vet, n); //Ordenação do vetor por meio do algoritmo de ordenação insertion
dif1=vet[1]-vet[0];
x1=vet[0];
x2=vet[1];
while(i<n-2) //Percorre o vetor buscando o par de números com a menor diferença e armazena-os nas variáveis x1 e x2
{
dif2=vet[i+1]-vet[i];
if(dif2<dif1)
{
x1=vet[i];
x2=vet[i+1];
dif1=dif2;
}
i++;
}
printf("O par de numero com menor diferenca eh:\n\n"); //Imprime o par de número com a menor diferença
printf("%d e %d", x1, x2);
free(vet); //Desalocaçãode memória utilizada
getch();
}
/* Head ends here */
void insertionSort(int ar_size, int * ar) {
int sum = 0;
for (int i = 2; i <= ar_size; i++) {
sum += insertion(i, ar);
}
printf("%d\n", sum);
}
/* quicksort without small cases, then insertion sort over all. */
void
sortPointers (void **vals, int total_elems,
int(*cmp)(const void *,const void *)) {
do_qsort (vals, cmp, 0, total_elems-1);
insertion (vals, cmp, 0, total_elems-1);
}
int main()
{
int data, ch;
while (1)
{
printf("\n1. Insertion in Binary Search Tree");
printf("\n2. Preorder traversal ");
scanf("%d",&ch);
switch(ch)
{
case 1:
while (1)
{
printf("Enter your data:");
scanf("%d", &data);
insertion(&root, data);
printf("Continue Insertion(0/1):");
scanf("%d", &ch);
if (!ch)
break;
}
break;
case 2: pre_order(root);
break;
default: exit(0);
}
}
}
//main function
void main() {
//clear screen
clrscr();
//input array
cout<<"Sorting by Insertion:\n\---------------------\n\nInput";
//read from file
read();
//display on screen
display();
//do sorting method insertion sort
insertion();
//output the result
cout<<"\n\nOutput";
//display on screen
display();
//write to output File
write();
cout<<"\n\n\nPress any key for exit\nhttp://thinkphp.ro";
getch();
}
void main()
{
int a[] = {12, 11, 19, 10, 5};
int n = sizeof(a) / sizeof(a[0]);
print(a, n);
insertion(a, n);
print(a, n);
}
void tri_insertion(int n3,int *t3)
{ int i;
i=1;
while(i<n3)
{insertion(&i,t3,*(t3+i));// le "i" s'increment a l'interieur de la fonction insertion
}
}
int main(){
int ar[] = {1,2,5,7,3,1,6,1,2};
int size = sizeof(ar)/sizeof(ar[0]);
insertion(ar,size);
std::cout << "result ";
print(ar,size);
return 0;
}
int main( void )
{
int a[ 5 ] = { 5, 4, 3, 2, 1 };
insertion( a, 5 );
for ( int i = 0; i < 5; ++i )
printf( "%d ", a[ i ] );
return 0;
}
Ptr<StringBuilder::Insertion>
StringBuilder::insertAfter(const kf_int64_t& pos) {
if(_end == 0)
return insertBefore(pos);
Ptr<Insertion> insertion(new InsertionHead(pos + 1));
insertIntoInsertions(insertion);
return insertion.retain();
}
/*
Entrada: Recebe um ponteiro de inteiro que é o buffer atual para ser distribuído entre os arquivos temporários
Saída: Os números inseridos nos seus respectivos baldes.
Custo : O(m) - Percorre cada elemento do arquivo original, e depois compara com cada elemento do arquivo temporário
*/
void coloca_balde(int * buffer){
int i;
char * path = (char *) malloc(strlen(DIR)*sizeof(char));
for(i=0; i<MAX; i++){
strcat(strcpy(path,DIR),itoa_lock(determine_balde(buffer[i]),LOCK));
insertion(path,buffer[i]);
}
}
static void
presort(unsigned int a[], int N)
{
int i;
for(i = 0; i < N; i+=double_presort_count)
{
insertion(&a[i], presort_count);
insertion_reverse(&a[i+presort_count], presort_count);
}
}
int main(void)
{
int i;
int arr[SIZE];
rangeRand(0, 50, 10, arr);
putarr(arr, SIZE);
insertion(arr, SIZE);
putarr(arr, SIZE);
return 0;
}