Ejercicios bsicos sobre ABB

Katiusha Canedo 212169017

import java.util.*;
public class Arbol {
private Nodo raiz;
public Arbol() {
raiz = null;
}
//ejericicio #1
public void insertar(int x) {
this.raiz = insertar(this.raiz, x);
}
private Nodo insertar(Nodo p, int x) {
if (p == null) {
return new Nodo(x);
}
if (x < p.elem) {
p.izq = insertar(p.izq, x);
} else {
p.der = insertar(p.der, x);
}
return p;
}
//ejercicio #2
public void preorden() {
preorden(raiz);
}
private void preorden(Nodo p) {
if (p != null) {
System.out.println(p.elem);
preorden(p.izq);
preorden(p.der);
}
}
//ejercicio #3
public void inorden() {
inOrden(raiz);
}
private void inOrden(Nodo p) {
if (p == null) {
return;
}
inOrden(p.izq);
System.out.println(p.elem);
inOrden(p.der);
}
//ejercicio #4
public void postOrden() {
postOrden(raiz);
}
public void postOrden(Nodo p) {
if (p != null) {
postOrden(p.izq);
postOrden(p.der);
System.out.println(p.elem);
}
}
//ejercicio #5
public boolean arbolLinealdes() {
Nodo p = raiz;
while (p != null) {
if (p.der != null) {
return false;
}
p = p.izq;
}
return true;
}
public boolean arbolLinealasc() {
Nodo p = raiz;
while (p != null) {
if (p.izq != null) {
return false;
}
p = p.der;
}
return true;
}
public boolean arbolLineal() {
return arbolLinealdes() == true || arbolLinealasc() == true;
}
//ejericicio #6
public int suma(int x) {
return sumamenor(raiz, x);
}
private int sumamenor(Nodo p, int x) {
int sum = 0;
if (p == null) {
return sum = 0;
} else {
int y = p.elem;
sum += sumamenor(p.izq, x) + sumamenor(p.der, x);
if (y < x) {
sum++;
}
}
return sum;
}
//ejercicio #7
public boolean mismoelem(Arbol A2) {
return mismo(raiz, A2.raiz);
}
private boolean mismo(Nodo p, Nodo q) {
boolean b = false;
if (p == null) {
return false;
} else {
b = mismo(p.izq, q.izq);
b = mismo(p.der, q.der);
if (p.elem != q.elem) {
b = false;
} else {
b = true;
}
}
return b;
}
//ejercicio #8
public int menor() {
Nodo p = raiz;
while (p.izq != null) {
p = p.izq;
}
return p.elem;
}
//ejercicio #9
public int mayor() {
Nodo p = raiz;
while (p.der != null) {
p = p.der;
}
return p.elem;
}
//ejericicio #10
public void mostrar_niveles() {
mostrar(raiz, 0);
}
private void mostrar(Nodo p, int x) {
if (p == null) {
return;
} else {
int y = p.elem;
mostrar(p.izq, x + 1);
System.out.println(y + " " + x);
mostrar(p.der, x + 1);
}
}
//ejercicio #11
public void recorrido_niveles() {
recorrido(raiz, 0);
}
private void recorrido(Nodo p, int x) {
if (p == null) {
return;
} else {
int y = p.elem;
System.out.println(y + " " + x);
recorrido(p.izq, x + 1);
recorrido(p.der, x + 1);
}
}
//ejercici0 #12
public int cantidad() {
return cantidad(raiz);
}
private int cantidad(Nodo p) {
if (p == null) {
return 0;
} else {
return cantidad(p.izq) + cantidad(p.der) + 1;
}
}
//ejercicio #13
public int suma() {
return suma(raiz);
}
private int suma(Nodo p) {
if (p == null) {
return 0;
} else {
return suma(p.izq) + suma(p.der) + p.elem;
}
}
//ejercicio #14
public void mostrarMayMen() {
Mostrarmaymen(raiz);
}
private void Mostrarmaymen(Nodo p) {
if (p == null) {
return;
} else {
int y = p.elem;
Mostrarmaymen(p.der);
System.out.println(y);
Mostrarmaymen(p.izq);
}
}
//ejercicio #15
public int sumaNivel(int k) {
return sumaNivel(raiz, k, 0);
}
private int sumaNivel(Nodo p, int k, int nivel) {
int sum = 0;
 if (p == null) {
return 0;
} else {
sum += sumaNivel(p.izq, k, nivel + 1) + sumaNivel(p.der, k, nivel +
1);
if (k == nivel) {
sum += p.elem;
}
}
return sum;
}
//ejercicio 16
public int cantNivel(int k) {
return cantNivel(raiz, k, 0);
}
private int cantNivel(Nodo p, int k, int nivel) {
int cant = 0;
if (p == null) {
return 0;
} else {
cant += cantNivel(p.izq, k, nivel + 1) + cantNivel(p.der, k, nivel +
1);
if (nivel <= k) {
cant++;
}
return cant;
}
}
//ejercicio 17
public int masProximo(int x) {
return masprox(raiz, x);
}
private int masprox(Nodo p, int x) {
int prox = 0;
if (p == null) {
return 0;
} else {
prox = masprox(p.izq, x);
prox = masprox(p.der, x);
if (x == p.elem) {
prox = p.izq.elem;
}
}
return prox;
}
//ejercicio 18
public boolean seencuentra(int x) {
return seencuen(raiz, x);
}
private boolean seencuen(Nodo p, int x) {
boolean b = false;
if (p == null) {
return false;
} else {
 b = seencuen(p.izq, x);
b = seencuen(p.der, x);
if (p.elem == x) {
b = true;
} else {
b = false;
}
}
return b;
}
public boolean estanTodos(Arbol A2) {
return estatodos(raiz, A2);
}
private boolean estatodos(Nodo p, Arbol A2) {
boolean b = false;
if (p == null) {
return false;
} else {
b = estatodos(p.izq, A2);
b = estatodos(p.der, A2);
if (!A2.seencuen(A2.raiz, p.elem)) {
b = false;
} else {
b = true;
}
}
return b;
}
//ejercicio #19
public boolean mismoele(Arbol A2) {
return mismoele(raiz, A2.raiz);
}
private boolean mismoele(Nodo p, Nodo q) {
boolean b = false;
if (p == null) {
return false;
} else {
b = mismoele(p.izq, q.izq);
b = mismoele(p.der, q.der);
if (p.elem != q.elem) {
b = false;
} else {
b = true;
}
}
return b;
}
//ejercicio 20
//parece el mismo q el 19
//ejercicio 21
public void mostrarTerm() {
mostrarter(raiz);
}
private void mostrarter(Nodo p) {
 if (p == null) {
return;
} else {
mostrarter(p.izq);
mostrarter(p.der);
if (p.izq == null || p.der == null) {
System.out.println(p.elem);
}
}
}
//ejercicio 22
public void mostrarnivel(int k) {
mostrarnivelk(raiz, k, 0);
}
private void mostrarnivelk(Nodo p, int k, int nivel) {
if (p == null) {
return;
} else {
mostrarnivelk(p.izq, k, nivel + 1);
mostrarnivelk(p.der, k, nivel + 1);
if (nivel == k) {
System.out.println(p.elem);
}
}
}
//ejercicio 23
public int diferencia() {
return this.mayor() - this.menor();
}
//ejercicio 24
public int altura() {
return altu(raiz);
}
private int altu(Nodo p) {
int alt = 0;
if (p == null) {
return 0;
} else {
alt = altu(p.izq);
altu(p.der);
if (p != null) {
alt++;
}
}
return alt;
}
//ejercicio #25
public void creararbol(ArrayList<Integer> L1) {
Arbol A1 = new Arbol();
int i = 0;
while (i < L1.size()) {
A1.insertar(L1.get(i));
i++;
}
}
//ejercicio #26
public void preorden(ArrayList<Integer> L1) {
pre(raiz, L1);
}
private void pre(Nodo p, ArrayList<Integer> L1) {
if (p == null) {
return;
}
L1.add(p.elem);
pre(p.izq, L1);
pre(p.der, L1);
}
//ejercicio 27
public void poner_en_lista_inorden(ArrayList<Integer> L1) {
poner_en_lista(raiz, L1);
}
private void poner_en_lista(Nodo p, ArrayList<Integer> L1) {
if (p == null) {
return;
}
poner_en_lista(p.izq, L1);
L1.add(p.elem);
poner_en_lista(p.der, L1);
}
//ejercicio 28
public void postorden(ArrayList<Integer> L1) {
post(raiz, L1);
}
private void post(Nodo p, ArrayList<Integer> L1) {
if (p == null) {
return;
}
post(p.izq, L1);
post(p.der, L1);
L1.add(p.elem);
}
//ejercicio 29
public void nivelescolocados(ArrayList<Integer> L1) {
colocar(raiz, L1);
}
private void colocar(Nodo p, ArrayList<Integer> L1) {
if (p == null) {
return;
} else {
int y = p.elem;
L1.add(y);
colocar(p.izq, L1);
colocar(p.der, L1);
if (p != null) {
 }
}
}
}