NoAVL<T>* inserir(const T& dado, NoAVL<T>* arv) {
if (!arv) {
return new NoAVL(dado);
}
if (dado < *arv->dado) {
arv->esquerda = inserir(dado, arv->esquerda);
} else {
arv->direita = inserir(dado, arv->direita);
}
arv->atualizaAltura();
int balanceamento = fatorDeBalanceamento(arv);
if (balanceamento > 1) {
if (dado > *arv->esquerda->dado) {
arv->esquerda = rotacaoSimplesEsq(arv->esquerda);
}
return rotacaoSimplesDir(arv);
}
if (balanceamento < -1) {
if (dado < *arv->direita->dado) {
arv->direita = rotacaoSimplesDir(arv->direita);
}
return rotacaoSimplesEsq(arv);
}
return arv;
}
int main(void){
ME matriz, matriz2, matriz3, matriz4;
no *q;
define(&matriz,3,3);
define(&matriz2,3,3);
define(&matriz3,3,3);
define(&matriz4,3,3);
inserir(&matriz,2,2,5);
inserir(&matriz,3,3,8);
inserir(&matriz2,1,1,3);
inserir(&matriz2,2,2,3);
printmatriz(&matriz,3,3);
printf("\n");
printmatriz(&matriz2,3,3);
somamatriz(&matriz,&matriz2,&matriz3);
printf("\n");
//q=buscaparametro(&matriz2,1,1);
//printf("%d ",q->valor);
printmatriz(&matriz3,3,3);
printf("\n");
multiplicaSenhor(&matriz,&matriz2,&matriz4);
printmatriz(&matriz4,3,3);
return 0;
}
void EventosInputTexto::processarEvento(const SDL_Event& evento)
{
switch(evento.type)
{
case SDL_TEXTINPUT:
{
#if UNI_PLATAFORMA_ANDROID
inserir(evento.text.text);
#else
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
std::wstring ws = converter.from_bytes(evento.text.text);
std::string s;
for(unsigned int i = 0; i < ws.size(); ++i)
s.push_back((char)ws[i]);
inserir(s);
#endif
}
break;
case SDL_TEXTEDITING:
// Faz nada. Estou tratando edicao de texto de outra maneira.
break;
}
}
int main() {
LISTA_ENCADEADA minha_lista;
minha_lista.cont = 0;
minha_lista.primeiro = NULL;
minha_lista.ultimo = NULL;
// Uma maneira de se fazer: instancie diretamente a struct e passe seu endereco
ELEMENTO aluno1;
aluno1.DRE = 111;
aluno1.CRA = 8.5;
strcpy(aluno1.nome, "Aluno1");
inserir(&minha_lista, &aluno1, NULL);
// Outra maneira: crie o ponteiro e aloque memória para ele,
// passando depois o proprio ponteiro
ELEMENTO* aluno2_ptr;
aluno2_ptr = (ELEMENTO*) malloc(sizeof(ELEMENTO));
aluno2_ptr->DRE = 222;
aluno2_ptr->CRA = 6;
strcpy(aluno2_ptr->nome, "Aluno2");
inserir(&minha_lista, aluno2_ptr, &aluno1);
print_lista(&minha_lista);
printf("\n");
return 1;
}
int main(){
char modelo;
int ano;
Lista lista;
//cria a lista vazia
CriarLista(&lista);
//Incluindo Elementos na lista
//modelo="fiat";
ano = 1990;
inserir(modelo,ano,1,&lista);
printf("\nlista qtd: %d\n", lista.qtd);
//Incluindo Elementos na lista
//modelo="fiat";
ano = 2010;
inserir(modelo,ano,2,&lista);
printf("\nlista qtd: %d\n", lista.qtd);
//Incluindo Elementos na lista
//modelo="fiat";
ano = 2015;
inserir(modelo,ano,3,&lista);
printf("\nlista qtd: %d\n", lista.qtd);
printf("\n imprimindo lista: \n");
imprimeLista(lista);
system("pause");
}
void popular(Arvore* arvore){
inserir(arvore, 15); //raiz
inserir(arvore, 13);
inserir(arvore, 20);
inserir(arvore, 19);
inserir(arvore, 31);
}
NoAVL<T>* inserir(const T& dado, NoAVL<T>* arv) {
if (dado <= *arv->dado) {
arv->esquerda =
(arv->esquerda) ?
inserir(dado, arv->esquerda) : new NoAVL<T>(dado);
} else {
arv->direita =
arv->direita ?
inserir(dado, arv->direita) : new NoAVL<T>(dado);
};
arv->altura = DefinirAltura(arv);
switch (definirTipoGira(arv)) {
case tpGiroDireita: {
if ((FatorFilhoGiroDireita(arv)) < 0)
arv->esquerda = girar(arv->esquerda, false);
arv = girar(arv, true);
break;
}
case tpGiroEsquerda:
if ((FatorFilhoGiroEsquerda(arv)) > 0)
arv->direita = girar(arv->direita, true);
arv = girar(arv, false);
break;
default:
break;
}
return arv;
}
int main(){
inserir(&lista,3);
inserir(&lista,4);
inserir(&lista,5);
imprimir(lista);
system("PAUSE");
imprimirOrdemDigitacao(lista);
system("PAUSE");
return 0;
}
void main(){
char assasino[10], assasinado[10];
ARVORE* Arv;
Arv = inicializa(Arv);
while(scanf("%s %s",assasino,assasinado)!=EOF){
Arv->raiz = inserir(Arv, assasino, Arv->raiz, Arv->raiz,1);
Arv->raiz = inserir(Arv, assasinado, Arv->raiz, Arv->raiz,0);
}
printf("HALL OF MURDERERS\n");
exibirEmOrdem(Arv->raiz);
}
No* inserir(ARVORE* arv, char chave[], No *no, No *anterior, int assa){
No *esq,*dir,*aux; //Ponteiros de Nós que auxiliam substituições futuras
if(no==NULL){//no que olhamos é nulo;
no= (No *)malloc(sizeof(No));
strcpy(no->chave,chave);
no->pEsquerda = NULL;
no->pDireita = NULL;
no->pai = anterior;
no->mortos=0;
no->balanceamento=0;
if(assa==0)
no->situacao=0;
else{
no->situacao=1;
no->mortos=1;
}
return (no);
}
if(strcmp(chave,no->chave)<0){// indica que o valor a ser inserido é menor que o atual
no->pEsquerda = inserir(arv, chave, no->pEsquerda, no, assa);
if(fatorBalanceamento_NO(no)>=2){
if(strcmp(chave,no->pEsquerda->chave)<0){
no=rotacaoLL(no);
}
else if(strcmp(chave,no->pEsquerda->chave)>0){
no=rotacaoLR(no);
}
}
}
else if(strcmp(chave,no->chave)>0){//indica que o valor a ser inserido é maior que o atual
no->pDireita = inserir(arv, chave, no->pDireita, no, assa);
if(fatorBalanceamento_NO(no)>=2){
if(strcmp(chave,no->pDireita->chave)>0){
no=rotacaoRR(no);
}
else if(strcmp(chave,no->pDireita->chave)<0){
no=rotacaoRL(no);
}
}
}
else{//indica que temos a chave com mesmo valor do no
if(assa==1){
no->mortos+=1;
}
else
no->situacao=0;
}
no->balanceamento=maior(alt_NO(no->pEsquerda),alt_NO(no->pDireita))+1;
return(no);
}
int main(int argc, char *argv[])
{
struct tLdde *lista = criaLista();
int escolha, qtde, remChave;
struct tItem *itRem;
char resp;
do
{
escolha = menu();
switch(escolha)
{
case 1: inserir(lista, criaItem());
break;
case 2: system("cls");
printf("Informe o valor da chave a ser removida: ");
scanf("%d", &remChave);
itRem = remover(lista, remChave);
if(itRem != NULL)
{
printf("\nItem chave [%d] localizado. Deseja realmente exclui-lo. [S]im [N]ao: ", remChave);
do
{
resp = getche();
}while(toupper(resp) != 'S' && toupper(resp) != 'N');
if(toupper(resp) == 'S')
{
free(itRem);
printf("\nItem chave [%d] removido com sucesso...\n", remChave);
}
else
{
inserir(lista, itRem);
printf("\nRemocao do item chave [%d] abortada...\n", remChave);
}
system("pause");
}
else
{
printf("O item chave [%d] nao estah na lista...\n", remChave);
system("pause");
}
break;
case 3: qtde = mostrar(lista->primeiro);
printf("\nA lista possui %d itens...\n", qtde);
system("pause");
}
}while(escolha != 4);
printf("Saindo...\n");
system("pause");
}
void inserir(no **raiz, int elemento) {
if(*raiz == NULL) { //faz a verificação se o espaço nao contem elementos da arvore
*raiz = (no *)malloc(sizeof(no)); //aloca espaço para uma nova struct
(*raiz)-> chave = elemento; //define a chave dessa struct igual ao elemento de entrada
(*raiz)-> dir = NULL; //aterra o lado direito da nova folha
(*raiz)-> esq = NULL; //aterra o lado esquerdo da nova folha
}
if(elemento < (*raiz)->chave) { //verifica se o elemento de entrada é menor que o numero chave atual
inserir(&(*raiz)->esq, elemento); //executa novamente a função com o endereço esquerdo como raiz
}
if(elemento > (*raiz)->chave) { //verifica se o elemento de entrada é maior que o numero chave atual
inserir(&(*raiz)->dir, elemento); //executa novamente a função com o endereço direito como raiz
}
}
template <class C, class I> void ABC<C, I>::inserir(C pclau, I pinfo, Node **node, int paltura) {
if(*node == NULL) {
*node = new Node(pclau, pinfo);
numelements++;
if(alturaarbre<paltura) alturaarbre=paltura;
}
else if(pclau > (*node)->clau) inserir(pclau, pinfo, &(*node)->fdre, paltura+1);
else if(pclau < (*node)->clau) inserir(pclau, pinfo, &(*node)->fesq, paltura+1);
else {
(*node)->clau = pclau;
(*node)->info = pinfo;
}
}
AVL inserirAVL(AVL t, void* data, int* cresceu, int(*comp)(void*,void*)){
if (t==NULL) {
t = (AVL)malloc(sizeof(struct nodo));
t->data = data;
t->filho[ESQ] = t->filho[DIR] = NULL;
t->factor_balanceamento = EQUAL;
*cresceu = 1;
}
else if (comp(data,t->data)>0)
t = inserir(t,DIR,data,cresceu,comp);
else
t = inserir(t,ESQ,data,cresceu,comp);
return t;
}
//Soma dois conjuntos.
conjunto * somar(conjunto * ca, conjunto * cb) {
conjunto * c = NULL;
while (ca != NULL) {//insere todos os elementos de ca em c
c = inserir(c, ca->numero);
ca = ca->prox;
}
while (cb != NULL) {//insere todos os elementos de cb em c
c = inserir(c, cb->numero);
cb = cb->prox;
}
return c;
}
Arvore* inserir(Arvore* arvore, int valor){
if (estaVazia(arvore)){
arvore->raiz = inserirNo(valor);
}else{
if(arvore->raiz->valor < valor){
arvore->raiz = arvore->raiz->sad;
inserir(arvore, valor);
}
else if (arvore->raiz->valor > valor){
arvore->raiz = arvore->raiz->sae;
inserir(arvore, valor);
}
}
return arvore;
}
void inserir (no **raiz, int k){//função que insere novos nós na árvore
if(*raiz == NULL){
no *aux = (no *)malloc(sizeof(no)); //cria uma variável auxiliar com alocação dinÂmica de memória
aux->chave = k;
aux->dir=aux->esq=NULL;
*raiz = aux;
return;
}
if((*raiz)->chave > k){ //usando recursão fazemos com que o nó, se maior que o elemento analisado á para a direita
inserir(&(*raiz)->esq, k);//e se for menor para a esquerda
}
if((*raiz)->chave<k){
inserir(&(*raiz)->dir, k);
}
}
main(){
PEDIDO zero = {"Acapulco", 01, 100};
PEDIDO um = {"Bruxelas", 02, 200};
PEDIDO dois = {"Cairo", 03, 300};
TFila fila;
fila.inicio = fila.fim = 0;
fila.contador = 0;
inserir (&fila, zero);
inserir (&fila, um);
inserir (&fila, dois);
mostra(fila);
retirar (&fila);
mostra(fila);
}
int inserir(int key,tree** t){
tree* tmp = *t;
if(tmp==NULL){
*t = criar_tree();
tmp = *t;
tmp->id = key;
tmp->left = tmp->rigth = NULL;
return 1;
}else if(key < tmp->id){
inserir(key,&tmp->left);
}else if(key > tmp->id){
inserir(key,&tmp->rigth);
}
return 0;
}
void produtor(int *id) {
double x = 0;
while(1) {
x += 1 + *id;
inserir(x);
}
}
int main(int argc, char** argv) {
RubroNegra arvore;
arvore = novaRubroNegra();
int chave;
char operacao;
void* resultadoBusca;
while (operacao != 'q') {
usage();
operacao = getchar();
getchar();
switch (operacao) {
case 'i':
scanf("%d", &chave);
printf("Inserindo chave: [%d].\n", chave);
if (inserir(arvore, chave, (void*) chave)) printf("Chave [%d] já existe.\n", chave);
else
printf("Chave [%d] inserida.\n", chave);
getchar();
break;
case 'r':
scanf("%d", &chave);
printf("Removendo chave: [%d].\n", chave);
if (remover(arvore, chave)) printf("Chave [%d] não encontrada.\n", chave);
else
printf("Chave [%d] removida.\n", chave);
getchar();
break;
case 'b':
scanf("%d", &chave);
printf("Buscando chave: [%d].\n", chave);
resultadoBusca = buscar(arvore, chave);
if (resultadoBusca == NULL) printf("Chave [%d] não encontrada.\n", chave);
else
printf("Resultado da busca: [%d].\n", (int) resultadoBusca);
getchar();
break;
case 'p':
printf("Imprimindo árvore.\n");
imprimir(arvore);
break;
case 'd':
printf("Destruindo árvore.\n");
destruir(arvore);
printf("Árvore destruída.\n");
break;
default:
usage();
break;
}
}
return 0;
}
void inserirstats(int year,int numautores,int coautores){
Stats a;
a=NULL;
a=estatisticas;
a=inserir(year,a,numautores,coautores);
estatisticas=a;
}
//----------------------------Implementaçãp da Main-----------------------------
int main ()
{
int q, quantumDoProcessador;
char identificador[9];
TNo *escalonador = NULL;
FILE *arq;
arq = fopen("processos.txt", "r");
if (!arq)
{
printf("Falha na abertura do arquivo 'processos.txt'\n\n");
exit(0);
}
fscanf(arq, "%i", &quantumDoProcessador);
//chama as funções que irão preencher a fila enquanto houverem dados
while(fscanf(arq, "%s %i", identificador, &q)==2 && inserir(&escalonador, q, identificador));
printf("Quantum do processador = %i\n", quantumDoProcessador);
exibir (escalonador);
escalonarProcessos(&escalonador, quantumDoProcessador);
}
int main()
{
struct Arvore *t = criaArvore();
int num;
char c[5];
gets(c);
while(scanf("%d", &num) != EOF)
inserir(t, criaNo(&num));
if(strcmp(c, "POS") == 0)
posOrdem(t->raiz);
else if(strcmp(c, "PRE") == 0)
preOrdem(t->raiz);
else
inOrdem(t->raiz);
printf("%d", altura(t->raiz));
printf(" %d", rotacao);
}
void main(void)
{
struct dado info[5];
char op;
do {
clrscr();
printf("MENU PRINCIPAL\n");
printf("--------------\n");
printf("1. Inserir dados\n");
printf("2. Visualizar dados\n");
printf("3. Ler arquivo\n");
printf("4. Gravar arquivo\n");
printf("5. Sair\n");
op=getch();
if (op=='1') {
inserir(info);
} else if (op=='2') {
exibir(info);
} else if (op=='3') {
clrscr();
if (abrir(info)) {
printf("Arquivo aberto com sucesso!");
}
getch();
} else if (op=='4') {
clrscr();
if (salvar(info)) {
printf("Arquivo salvo com sucesso!");
}
getch();
}
} while (op!='5');
}
int main(){ //função principal.
char escolha;
inicialista(); //inicia a lista struct notas.
printf("\n\n\n");
for(;;){
escolha = menu(); //área do MENU.
switch(escolha){
case 1:
inserir();
break;
case 2:
salvar();
break;
case 3:
mostra();
break;
case 4:
carregar();
break;
case 5:
exit(0);
}
}
printf("\n\n");
return 0;
//system("pause");
}
Arv* inserir(Arv* raiz, int elem)
{
if (raiz == NULL)
{
return arv_cria(elem,NULL,NULL);
}
else
{
if(elem < raiz->elem)
raiz->esq = inserir(raiz->esq, elem);
else
raiz->dir = inserir(raiz->dir, elem);
}
return raiz;
}
main()
{
int op;
parq = fopen("dados.dat", "rb+"); // binário leitura e escrita
if (parq == NULL)
parq = fopen("dados.dat", "wb+"); // cria
do
{
system("cls");
printf("Cadastro\n\n\n");
printf("1 - Inserir dados...\n\n");
printf("2 - Listar dados...\n\n");
printf("0 - Sair");
printf("\n\nEscolha: ");
scanf("%d", &op);
switch (op)
{
case 1:
inserir();
break;
case 2:
listar();
break;
}
}
while (op != 0);
fclose(parq);
}
int main(){
tree* arv=NULL;
int a=4,x;
x = inserir(a,&arv);
x=inserir(5,&arv);
x=inserir(3,&arv);
remover(3,arv);
printf("R = %i\n",arv->id);
printf("Busca = %i\n",busca(a,arv));
printf("RD = %i\n",arv->rigth->id);
printf("RE = %i\n",arv->left->id);
free(arv);
system("pause");
return 0;
}
int main(){
int size_g, size_edg, source, target, cost;
scanf("%d%d", &size_g, &size_edg);
if(size_g < 1 || size_edg < 1)
return -1;
heap *root = heapCreateRoot();
vertex *vertices = (vertex*)calloc(size_g, sizeof(vertex));
edge **inv = (edge**)calloc(size_g, sizeof(edge*));
initGraph(vertices, size_g);
vertices[0].heap_node.key = 0;
heapInsert(root, &(vertices[0].heap_node));
while(scanf("%d%d%d", &source, &target, &cost) != EOF) {
inserir(vertices, inv, root, size_g, source, target, cost);
}
g_print_graph(vertices, size_g);
freeGraph(vertices, size_g);
freeInv(inv, size_g);
free(vertices);
free(inv);
free(root);
return 0;
}