No *rotacaoLL(No *raiz){
No *no=raiz->pEsquerda;
no->pai=raiz->pai;
raiz->pEsquerda=no->pDireita;
no->pDireita=raiz;
raiz->balanceamento=maior(alt_NO(raiz->pEsquerda),alt_NO(raiz->pDireita))+1;
no->balanceamento=maior(alt_NO(no->pEsquerda),raiz->balanceamento)+1;
raiz->pai=no;
return no;
}
static void fixDown(int k, double prty[]) {
int j;
while (2*k <= N) {
j = 2*k;
if (j < N && maior(j, j+1)) j++;
if (!maior( k, j)) break;
exch(k, j);
k = j;
}
}
void Rot_Simp_esq (ArvAVL *raiz){ // rotacao simples a esquerda: quer dizer que o no inserido ficou a direida da subarvore da direita, ocasionando um fatbal +2. O ponteiro de ponteiro recebido como raiz é deste nó com fatbal +2.
ArvAVL no;
no = (*raiz)->dir;
(*raiz)->dir = no->esq;
no->esq = (*raiz);
(*raiz)->alt = maior(alt_NO((*raiz)->esq), alt_NO((*raiz)->dir))+1;
no->alt = maior(alt_NO(no->dir), alt_NO(no->esq))+1;
*raiz = no;
}
void Rot_Simp_dir (ArvAVL *raiz){ // rotacao simples a direita: quer dizer que o no inserido ficou a esquerda da subarvore da esquerda, ocasionando um fatbal -2. o ponteiro de ponteiro recebido como raiz é deste nó com fatbal -2.
ArvAVL no;
no = (*raiz)->esq;
(*raiz)->esq = no->dir;
no->dir = (*raiz);
(*raiz)->alt = maior (alt_NO((*raiz)->esq),alt_NO((*raiz)->dir)) +1;
no->alt = maior(alt_NO(no->esq), alt_NO(no->dir))+1; // alteracao das alturas, sempre sera isso. pego a maior altura entre os dois filhos e acrescento um. faco recursivamente ate a folha que eh 0.
*raiz = no; // se faz necessaria a troca pois estamos usando uma referencia e, portanto, temos que definir a nova raiz.
}
int insere_ArvAVL (ArvAVL *raiz, int chave){
int res;
if(*raiz == NULL){ // arvore vazia ou no folha
ArvAVL novo;
novo = (ArvAVL)malloc(sizeof(struct NO));
if(novo == NULL)
return 0;
novo->chave = chave;
novo->alt = 0;
novo->esq = NULL;
novo->dir = NULL;
*raiz = novo;
return 1;
}
ArvAVL atual = *raiz;
if(chave < atual->chave){ // inserção na sub arvore da esquerda
if((res = insere_ArvAVL(&(atual->esq), chave)) == 1){
atual->alt = maior(alt_NO(atual->esq),alt_NO(atual->dir)) + 1;
if(FatBal(atual) <= -2){
if(chave < (*raiz)->esq->chave ){
Rot_Simp_dir(raiz);
}else{
Rot_dupla_direita_met2(raiz);
}
}
}
}
else{
if(chave > atual->chave){
if((res = insere_ArvAVL(&(atual->dir), chave)) == 1){
atual->alt = maior(alt_NO(atual->esq),alt_NO(atual->dir)) + 1;
if(FatBal(atual) >= 2){
if((*raiz)->dir->chave < chave){
Rot_Simp_esq(raiz);
}else{
Rot_dupla_esquerda_met2(raiz);
}
}
}
}
else{
printf("Valor duplicado!!\n");
return 0;
}
}
return res;
}
//---------------------------------------------------------------------------------------------------------------
parvore Busca_No(parvore a,tcod x)//funcao de busca
{
if(!vazia(a))
if(maior(a->cod,x))
Busca_No(a->esq,x);
else
if(maior(x,a->cod))
Busca_No(a->dir,x );
else
return(a);
else
return(NULL);
}
// Rotação RR
void RotacaoSimplesAEsquerda(struct No ** noRaiz)
{
struct No *no;
no = (*noRaiz)->direita;
(*noRaiz)->direita = no->esquerda;
no->esquerda = (*noRaiz);
(*noRaiz)->altura = maior(RecuperaAlturaNo((*noRaiz)->esquerda), RecuperaAlturaNo((*noRaiz)->direita)) + 1;
no->altura = maior(RecuperaAlturaNo(no->direita), (*noRaiz)->altura) + 1;
(*noRaiz) = no;
}
// Adiciona dado na posição definida pela comparação de grandeza
void adicionaEmOrdem(const T& data) {
Elemento<T> *atual;
int pos = 0;
if (listaVazia())
return adicionaNoInicio(data);
atual = head;
while (atual->getProximo() != NULL && maior(data, atual->getInfo())) {
atual = atual->getProximo();
pos++;
}
if (maior(data, atual->getInfo()))
adicionaNaPosicao(data, pos + 1);
adicionaNaPosicao(data, pos);
}
void ListaEnc<T>::adicionaEmOrdem(const T& dado) {
if (listaVazia()) {
return adicionaNoInicio(dado);
}
Elemento<T>* atual = cabeca;
int posicao = 1;
while (atual->getProximo() != 0 && maior(dado, atual->getInfo())) {
atual = atual->getProximo();
posicao++;
}
if (maior(dado, atual->getInfo())) {
return adicionaNaPosicao(dado, posicao + 1);
}
adicionaNaPosicao(dado, posicao);
}
struct No * RemoverRecursivo(struct No * anda, Chave c, struct Item *I)
{
if(anda == NULL)
{
return NULL;
}
else if(ChaveMenor(c, GetChave(anda->I)))
{
anda->esquerda = RemoverRecursivo(anda->esquerda, c, I);
anda->altura = maior(RecuperaAlturaNo(anda->esquerda), RecuperaAlturaNo(anda->direita)) + 1;
return anda;
}
else if(ChaveMaior(c, GetChave(anda->I)))
{
anda->direita = RemoverRecursivo(anda->direita, c, I);
anda->altura = maior(RecuperaAlturaNo(anda->esquerda), RecuperaAlturaNo(anda->direita)) + 1;
return anda;
}
else if(anda->esquerda == NULL && anda->direita == NULL)
{
*I = anda->I;
free(anda);
return NULL;
}
else if(anda->esquerda != NULL && anda->direita == NULL)
{
*I = anda->I;
struct No* esq = anda->esquerda;
free(anda);
return esq;
}
else if(anda->esquerda == NULL && anda->direita != NULL)
{
*I = anda->I;
struct No* dir = anda->direita;
free(anda);
return dir;
}
else
{
*I = anda->I;
struct No * maioresquerda = anda->esquerda;
while(maioresquerda->direita != NULL)
maioresquerda = maioresquerda->direita;
anda->esquerda = RemoverRecursivo(anda->esquerda, GetChave(maioresquerda->I), &(anda->I));
return anda;
}
}
/*!
Adiciona um dado em ordem na lista.
\param endereço do dado do tipo T que sera inserido em ordem na lista.
*/
void adicionaEmOrdem(const T& data) {
printf("Adiciona em ordem errado!\n");
if (listaVazia())
adicionaNoInicio(data);
Elemento<T>* aux;
int pos;
aux = head;
pos = 0;
while (aux->getProximo() != NULL && maior(data, aux->getInfo())) {
aux = aux->getProximo();
pos++;
}
if (maior(data, aux->getInfo()))
adiciona(data);
adicionaNaPosicao(data, pos);
}
int InsereAVL(struct No ** noRaiz, struct Item I)
{
int resultado;
if (*noRaiz == NULL)
{
struct No * NovoNo = CriaNo(I);
if (NovoNo == NULL)
{
return 0;
}
*noRaiz = NovoNo;
return 1;
}
struct No * noAtual = * noRaiz;
if (ChaveMenor(GetChave(I), GetChave(noAtual->I)))
{
if ((resultado = InsereAVL(&(noAtual->esquerda), I)) == 1)
{
if (FatorDeBalanceamentoDoNo(noAtual) >= 2)
{
if ( ChaveMenor(GetChave(I), GetChave((*noRaiz)->esquerda->I)))
{
RotacaoSimplesADireita(noRaiz);
}
else
{
RotacaoDuplaADireita(noRaiz);
}
}
}
}
else
{
if ((resultado = InsereAVL(&(noAtual->direita), I)) == 1)
{
if (FatorDeBalanceamentoDoNo(noAtual) >= 2)
{
if ( ChaveMenor(GetChave( (*noRaiz)->direita->I ), GetChave(I)))
{
RotacaoSimplesAEsquerda(noRaiz);
}
else
{
RotacaoDuplaAEsquerda(noRaiz);
}
}
}
}
noAtual->altura = maior( RecuperaAlturaNo(noAtual->esquerda), RecuperaAlturaNo(noAtual->direita) ) + 1;
return resultado;
}
int maior(celula *p, int mai) {
if (p != NULL) {
if (p->dado > mai) mai = p->dado;
return maior(p->next, mai);
}
return mai;
}
int main(void) {
unsigned int i = 0, j, tam = 10, n, *v = (unsigned int*) malloc(
tam * sizeof(unsigned int));
freopen("e8.txt", "r", stdin);
freopen("s8.txt", "w", stdout);
if (v != NULL) {
scanf("%u", &n);
while (n) {
v[i] = n;
i++;
if (i >= tam) {
tam = tam * 2;
v = (unsigned int*) realloc(v, tam * sizeof(unsigned int));
}
scanf("%u", &n);
}
ordena(v, i);
for (j = 0; j < i; j++) {
printf("%u ", v[j]);
}
printf("\n");
printf("%.1lf\n", media(v, i));
printf("%u\n", maior(v, i));
printf("%u\n", menor(v, i));
}
free(v);
fclose(stdin);
fclose(stdout);
return 0;
}
/**
NOME DA FUNÇÃO: adicionaEmOrdem
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
partindo do pressuposto que a lista está previamente ordenada, adiciona, se possível, um novo contato na
sua posição correspondente para manter a lista ordenada.
PARÂMETROS:
nome tipo valor/referência descrição
---------------------------------------------------------------------
dado tAgenda valor elemento a ser adicionado
VALOR DE RETORNO:
nome tipo descrição
---------------------------------------------------------------------
-- int 0 em caso de sucesso, código de erro em caso de problema
*/
int adicionaEmOrdem(tAgenda dado) {
int pos = 0;
while (pos <= aLista.ultimo && maior(dado, aLista.elem[pos]))
pos++;
return adicionaNaPosicao(dado, pos);
}
// Calcula o número mínimo de caracteres necessários
// para transformar dada palavra em um palíndromo
int prog_din(char * palavra) {
int j, k, l;
int array[2][MAX_CARACTERES];
int length = strlen(palavra);
// Seta os valores iniciais em zero para o array
memset(array, 0, sizeof(array));
// Percorre a palavra de trás para frente
for(j = length-1; j >= 0; j--) {
char ch = palavra[j];
// Percorre a palavra em seu sentido normal
for (k = 0; k < length; k++) {
if (ch == palavra[k]) {
array[1][k+1] = array[0][k] + 1;
} else {
array[1][k+1] = maior(array[1][k], array[0][k+1]);
}
}
// Salva na posição zero do array os dados calculados
for (l = 0; l <= length; l++) {
array[0][l] = array[1][l];
}
}
// invetorna o tamanho da palavra subitraindo-se
// o maior palíndromo encontrado
return (length - array[1][k]);
}
int main(){
int a,b;
scanf("%d %d", &a,&b);
maior(&a,&b);
printf("%d %d\n\a",a,b);
return 0;
}
void main(){
int vetor[total];
criarvetor(vetor,total);
impressao(vetor,total);
maior(vetor,total);
}
ArvAvl * insere_ArvAVL(ArvAVL * arv, int info ){
if( arv == NULL ){
arv = aloca(info);
}
else if( info < arv->info ){
arv->esq = insere( info, arv->esq );
if( altura( arv->esq ) - altura( arv->dir ) == 2 ){
if( info < arv->esq->info )
arv = rotacaoRR( arv );
else
arv = rotacaoLR( arv );
}
}
else if( info > arv->info ){
arv->dir = insere( info arv >dir);
if( altura( arv->dir ) - altura( arv->esq ) == 2 ){
if( info > arv->dir->info )
arv = rotacaoLL( arv );
else
arv = rotacaoRL( arv );
}
}
arv->altura = maior( altura( arv->esq ), altura( arv->dir ) ) + 1;
return arv;
}
int calculaAltura(tipoNo *raiz){
if(raiz == NULL){
return 0;
}
else {
return (maior(calculaAltura(raiz->noEsquerdo),calculaAltura(raiz->noDireito)) + 1);
}
}
int maiores(Abin a, int x){
if(a != NULL){
if(a->valor > x)
return 1 + maiores(a->esq, x);
else return maior(a->dir,x);
}
return 0;
}
int calculaAltura(NO *raiz) {
if(raiz == NULL) {
return 0;
}
else {
return (maior(calculaAltura(raiz->esquerda),calculaAltura(raiz->direita)) + 1);
}
}
int main() {
int vetor[] = {1,2,1,4,8,7,6,5,10,9};
mostra_i(vetor, TAM);
printf("O maior elemento é: %d\n", maior(vetor));
return 0;
}
void Rot_dupla_dir (ArvAVL *raiz){ // metodo explicado em aula, onde a rotacao dupla a direita sera tratada com trocas de ponteiros e o ajuste braçal da arvore, neste caso a raiz da sub-arvore da direita do filho da esquerda se tornara a raiz da subarvore principal tratada.
ArvAVL no1;
ArvAVL no2;
no1 = (* raiz)-> esq;
no2 = (* raiz)-> esq -> dir; // dupla rot para direita, no2 está na sub arvore da direita do filho da esquerda e se tornará a nova raiz desta subarvore
no1->dir = no2->esq;
(*raiz)->esq = no2->dir;
no2->esq = no1;
no2->dir = (* raiz);
(*raiz)->alt = maior(alt_NO((*raiz)->esq), alt_NO((*raiz)->dir))+1;
no1->alt = maior(alt_NO(no1->dir), alt_NO(no1->esq))+1;
no2->alt = maior(alt_NO(no2->dir), alt_NO(no2->esq))+1;
(*raiz) = no2;
}
struct No * InserirRecursivo(struct No * anda, struct Item I)
{
if(anda == NULL)
{
anda = CriaNo(I);
}
else if(ChaveMenor(GetChave(I), GetChave(anda->I)))
{
anda->esquerda = InserirRecursivo(anda->esquerda, I);
anda->altura = 1 + maior( RecuperaAlturaNo(anda->esquerda), RecuperaAlturaNo(anda->direita) );
}
else
{
anda->direita = InserirRecursivo(anda->direita, I);
anda->altura = maior( RecuperaAlturaNo(anda->esquerda), RecuperaAlturaNo(anda->direita) ) + 1;
}
return anda;
}
void selectionI(int* vet,int tam, long long int*comparacoes, long long int *trocas){
int i,pos_maior;
for(i = tam-1; i > 0; i--){
pos_maior = maior(vet,i,comparacoes);
(*trocas)++;
troca(&vet[i],&vet[pos_maior]);
}
}
ulong SSTree::lca_lookup(ulong v, ulong w){
if (v == 0 || w == 0) return 0;
if (v == w || v == root()) return v;
if (w == root()) return root();
ulong u = menor(v,w);
ulong x = maior(v,w);
if (_findclose[u] > _findclose[x]) return u;
return _enclose[rmq->lookup(u, x) + 1];
}
int main(void)
{
int a,b;
int maior(int x, int y);
printf("Digite dois valores:\n");
scanf("%i", &a);
scanf("%i", &b);
maior(a,b);
return 0;
}
/**
*Método que adiciona um objeto da classe ElementoDeLista.
*
*
* @param InfoLista *dado= ponteiro para um objeto da classe InfoLista.
*
* @return LISTA_CHEIA = caso a lista em execução já possua o numero de elementos determinado pela variável MAXLISTA.
* @return ERRO_POSICAO = caso a posição informada seja inválida, ou seja, caso nao esteja entre o inicio e o final da lista.
* @return tamanho = tamanho final da lista.
*/
int CabecaDeLista::adicionaEmOrdem(InfoLista *dado) {
ElementoDeLista *atual;
int posicao;
if (vazia()) {
return adicionaNoInicio(dado);
} else {
atual = primeiro;
posicao = 1;
while (atual->proximo != 0 && maior(dado, atual->info)) {
atual = atual->proximo;
posicao++;
}
if (maior(dado, atual->info)) {
return adicionaNaPosicao(dado, posicao + 1);
} else {
return adicionaNaPosicao(dado, posicao);
}
}
}
main()
{
int num,num2;
printf("\n\nDigite o 1° numero: ");
scanf("%d",&num);
printf("\n\nDigite o 2° numero: ");
scanf("%d",&num2);
printf("O numero maior vale: %d", maior(num,num2));
}
