Você está na página 1de 9

Rodrigo Soares da Silva 20201014040054

BTAVL.java
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Vector;

public class BtAVL {


private No root;
private int size;
public BtAVL(int item) {
No raiz = new No();
raiz.value= item;
raiz.pai = null;
raiz.direito = null;
raiz.esquerdo = null;
raiz.FB = 0;
root = raiz;
size++;
}
public No leftChild(No n) {
return n.esquerdo;
}
public No rightChild(No n) {
return n.direito;
}
public boolean hasLeft(No n) {
return (n.esquerdo != null);
}
public boolean hasRight(No n) {
return (n.direito != null);
}
public boolean isInternal(No x) {
return(x.direito != null || x.esquerdo != null);
}
public boolean isExternal(No v)

{
return (v.direito == null && v.esquerdo == null);
}
public No root() {
return root;
}
public int value(No n) {
return n.value;
}
public int size() {
return size;
}
public void updateFB(No no) {
no.setFB(altura(no.direito)-altura(no.esquerdo));
}

public int altura(No raiz) {


if(raiz==null)return -1;
if(isExternal(raiz)) return 0;
int alturaLeft= 0, alturaRight = 0;
if(hasLeft(raiz)) alturaLeft = altura(leftChild(raiz));
if(hasRight(raiz)) alturaRight = altura(rightChild(raiz));
return 1 + Math.max(alturaLeft, alturaRight);
}
public void inserir(int item, No no) {
No novo = new No();
novo.value= item;
novo.direito = null;
novo.esquerdo = null;
if(item>=value(no)) {
if(hasRight(no)) {
inserir(item, rightChild(no));
}else {
no.direito = novo;
novo.setPaiElement(no);
rebalanceUp(novo);
size++;
}
}else {
if(hasLeft(no)) {
inserir(item, leftChild(no));
}else {
no.esquerdo = novo;
novo.setPaiElement(no);
rebalanceUp(novo);
size++;

}
}
}
protected void rebalanceUp(No node) {
if(node == null) return;
rebalance(node);
if (node.pai != null) {
rebalanceUp(node.pai);
}
}

protected void rebalance(No node) {


updateFB(node);
if (node.FB > 1) {
if (altura(node.direito.direito) >
altura(node.direito.esquerdo)) {
leftRotation(node);
} else {
rightRotation(node.direito);
leftRotation(node);
}
} else if (node.FB < -1) {
if (altura(node.esquerdo.esquerdo) >
altura(node.esquerdo.direito))
rightRotation(node);
else {
leftRotation(node.esquerdo);
rightRotation(node);
}
}
}

private void leftRotation(No no) {


No noDireito = no.direito;

no.setRightChildren(noDireito.esquerdo);

noDireito.esquerdo.setPaiElement(no);
noDireito.setLeftChildren(no);
noDireito.setPaiElement(no.pai);
no.setPaiElement(noDireito);

if (no != this.root) {
if (noDireito.pai.esquerdo == no) {
noDireito.pai.setLeftChildren(noDireito);
} else {
noDireito.pai.setRightChildren(noDireito);
}
} else {
this.root = (No) noDireito;
}
noDireito.setFB(noDireito.FB + 1 - Math.min(no.FB, 0));
no.setFB(no.FB + 1 +Math.max(noDireito.FB, 0));

protected void rightRotation(No no) {


No noEsquerdo = no.esquerdo;

no.setLeftChildren(noEsquerdo.direito);

noEsquerdo.direito.setPaiElement(no);
noEsquerdo.setRightChildren(no);
noEsquerdo.setPaiElement(no.pai);
no.setPaiElement(noEsquerdo);

if (no != this.root) {
if (noEsquerdo.pai.esquerdo == no) {
noEsquerdo.pai.setLeftChildren(noEsquerdo);
} else {
noEsquerdo.pai.setRightChildren(noEsquerdo);
}
} else {
this.root = (No) noEsquerdo;
}
noEsquerdo.setFB(noEsquerdo.FB - 1 - Math.max(no.FB, 0));
no.setFB(no.FB - 1 + Math.min(noEsquerdo.FB, 0));
}

public void remover(int key) {


size--;
remocao(key,this.root);;

}
public int depth(No no) {
int i = altura(root) - altura(no);
return i;
}
private No remocao(int key, No raiz) {
if(raiz == null) return raiz;
if(key > value(raiz)) {raiz.direito = remocao(key,
rightChild(raiz));}
else if(key < value(raiz)) {
raiz.esquerdo = remocao(key, leftChild(raiz));
}
else{
if(isExternal(raiz)){raiz = null;}
else if(hasRight(raiz)){
raiz = rightChild(raiz);
while(hasRight(raiz)){
raiz = rightChild(raiz);
}
raiz.direito = remocao(value(raiz), rightChild(raiz));
}else{
raiz = leftChild(raiz);
while(hasLeft(raiz)){
raiz = leftChild(raiz);
}
raiz.esquerdo= remocao(value(raiz), leftChild(raiz));
}
}
return raiz;
}

public void inOrder(No raiz) {


if(isInternal(raiz)) {
if(hasLeft(raiz)) {

inOrder(leftChild(raiz));
}
}
System.out.print(raiz.value+"["+raiz.FB+"] ");
if(isInternal(raiz)) {
if(hasRight(raiz)) {
inOrder(rightChild(raiz));
}
}
}
public void postOrder(No raiz) {
if(isInternal(raiz)) {
if(hasLeft(raiz)) {
postOrder(leftChild(raiz));
}
}
if(isInternal(raiz)) {
if(hasRight(raiz)) {
postOrder(rightChild(raiz));
}
}
System.out.print(raiz.value+" ");
}
public void preOrder(No raiz) {
System.out.print(raiz.value+" ");
if(isInternal(raiz)) {
if(hasLeft(raiz)) {
preOrder(leftChild(raiz));
}
}
if(isInternal(raiz)) {
if(hasRight(raiz)) {
preOrder(rightChild(raiz));
}
}
}

private Iterator<No> INos(No raiz) {


ArrayList<No> d = new ArrayList<No>();
if (isInternal(raiz)){
if (hasLeft(raiz)) {
INos(leftChild(raiz));
}
d.add(raiz);
if (hasRight(raiz)) {
INos(rightChild(raiz));
}
}
return d.iterator();
}
private Iterator IElements(No raiz) {
ArrayList d = new ArrayList();
if(isInternal(raiz)) {
if(hasLeft(raiz)) {
IElements(leftChild(raiz));
}
}
d.add(raiz.value);
if(isInternal(raiz)) {
if(hasRight(raiz)) {
IElements(rightChild(raiz));
}
}
return d.iterator();
}
public Iterator<No> Nos()
{
return INos(root);
}
public Iterator elements()
{
return IElements(root);
}
public void printaux(No raiz, int espaco) {
if (raiz == null)
return;

if(raiz == root) {
for(int i = 0; i<espaco;i++) {
System.out.print(" ");
}
System.out.println(root.value);
}
if(raiz.esquerdo != null) {
for(int i = 0; i<espaco-2;i++) {
System.out.print(" ");
}
System.out.print(raiz.esquerdo.value);
}
if(raiz.direito != null) {
for(int i = 0; i<espaco-6;i++) {
System.out.print(" ");
}
System.out.print(raiz.direito.value);
}

printaux2(raiz.direito, espaco);
}
public void printaux2(No raiz, int espaco) {
if (raiz == null)
return;

printaux2(raiz.direito, espaco);
}

public void mostrar() {


inOrder(root);
}
public No buscar(int key, No n) {
if (root == null) return n;
if(isExternal(n)) {
if(key != value(n)) {
System.out.print("Não encontrado!! ");
return n;
}
else {return n;}
}
if(key<=value(n)) {
return buscar(key, leftChild(n));
}
else{
return buscar(key, rightChild(n));
}
}
class No{
public int value;
public int FB;
int height;
public No pai;
public No direito;
public No esquerdo;

public void setPaiElement(No no) {


this.pai = no;
}
public void setRightChildren(No no) {
this.direito = no;
}
public void setLeftChildren(No no) {
this.esquerdo = no;
}
public void setFB(int fb) {
this.FB = fb;
}
}
}
teste.java
package implementação_pesquisa;
public class teste {
public static void main(String[] args) {
BtAVL n = new BtAVL(10);
n.inserir(22, n.root());
n.inserir(5, n.root());
n.inserir(8, n.root());
n.inserir(15, n.root());
n.inserir(2, n.root());

System.out.println(n.buscar(15, n.root()).pai.esquerdo.value);
n.mostrar();

}
}

Você também pode gostar