ejercicio1:

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner= new Scanner(System.in);
System.out.println("Introduce tamaño");
int tamaño= scanner.nextInt();
int matriz[][]= new int[tamaño][tamaño];
llenar(matriz);
imprimir(matriz);

}
public static void llenar(int[][]matriz){
for (int i=0;i<matriz.length;i++){
for (int a=0;a<matriz[i].length;a++){
System.out.print(i+1);
/* matriz[i][a]=matriz[i+1][a+1];*/
}
}
}
public static void imprimir(int [][]matriz){
for (int[]fila:matriz){
for (int numero:fila){
System.out.print(numero+" ");
}
System.out.println();
}
}
}

ejercicio2:

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Introduce tamaño");
int tamaño = scanner.nextInt();
int[] array = new int[tamaño];
int []arrayAux=new int[tamaño];
int total = array.length;
int mitad = total / 2;

for (int i = 0; i < mitad; i++) {

if (i % 2 == 0) {
System.out.println("Introduce un par");
array[i] = scanner.nextInt();
if (array[i] % 2 != 0) {
System.out.println("Numero no par,introduce de nuevo");
}
} else {
System.out.println("introduce un impar");
array[i] = scanner.nextInt();
if (array[i] % 2 == 0) {
System.out.println("Numero no impar,introduce de nuevo");
}
}
}
int suma=0;
 for (int numeros:array){
suma+=numeros;
}
array[mitad]=suma;
for (int i = mitad ;i < array.length; i++) {
if (i % 2 == 0) {
System.out.println("Introduce un par");
array[i] = scanner.nextInt();
if (array[i] % 2 != 0) {
System.out.println("Numero no par,introduce de nuevo");
}
} else {
System.out.println("introduce un impar");
array[i] = scanner.nextInt();
if (array[i] % 2 == 0) {
System.out.println("Numero no impar,introduce de nuevo");
}
}
}
for (int valores:array){
System.out.println(valores);
}
}
}

ejercicio 3:
import java.util.ArrayList;
import java.util.Scanner;

//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or

// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
public class Main {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("Introduce la capacidad de dispositivos");
int capacidad= scanner.nextInt();
ArrayList<Dispositivos>lista=new ArrayList<>(capacidad);
lista.add(new Generador("g002","generador turbo",200));
lista.add(new Consumidor("c002","consumidor c",300));
lista.add(new Bateria("b002","bateria AAA",200,50));
for (int i=0;i< lista.size();i++){
System.out.println(lista.get(i));
}

/*
System.out.println("Selecciona un tipo de dispositivo:");
int tipo=0;
for (int i=0;i<capacidad;i++){
switch (tipo=scanner.nextInt()){
case 1:
System.out.print("id");
String id=scanner.nextLine();
System.out.print("nombre");
String nombre=scanner.nextLine();
System.out.print("potencia");
double potencia=scanner.nextDouble();
lista.add(new Generador(id,nombre,potencia));
case 2:
String idConsumidor=scanner.nextLine();
 String nombreConsumidor=scanner.nextLine();
double potenciaConsumida=scanner.nextDouble();
lista.add(new
Consumidor(idConsumidor,nombreConsumidor,potenciaConsumida));
}
}
*/

}
}
public abstract class Dispositivos {
private String identificador;
private String nombreDescriptivo;

public Dispositivos(String identificador, String nombreDescriptivo) {

this.identificador = identificador;
this.nombreDescriptivo = nombreDescriptivo;
}

public String getIdentificador() {

return identificador;
}

public String getNombreDescriptivo() {

return nombreDescriptivo;
}

public abstract void consumo();

}
public class Generador extends Dispositivos{
private double potenciaGenerada;

public Generador(String identificador, String nombreDescriptivo,double

potenciaGenerada) {
super(identificador, nombreDescriptivo);
this.potenciaGenerada=potenciaGenerada;
}

public double getPotenciaGenerada() {

return potenciaGenerada;
}
public void mostrarDatos(){
System.out.println("Generador:"+getIdentificador()+", Nombre: "+
getNombreDescriptivo()+", potencia generada(KW):"+ potenciaGenerada);
}
public String toString() {
return "identificador: " + getIdentificador() + ", nombredispositivo: " +
getNombreDescriptivo()+", potencia generada(KW):"+ potenciaGenerada;
}
@Override
public void consumo() {
System.out.println("potencia generada-"+potenciaGenerada);
}
}
public class Consumidor extends Dispositivos{
private double potenciaConsumida;
public Consumidor(String identificador, String nombreDescriptivo,double
potenciaConsumida) {
super(identificador, nombreDescriptivo);
 this.potenciaConsumida=potenciaConsumida;
}
@Override
public void consumo() {
System.out.println("potencia consumida +"+potenciaConsumida);
}
public double getPotenciaConsumida() {
return potenciaConsumida;
}
public String toString() {
return "identificador: " + getIdentificador() + ", nombredispositivo: " +
getNombreDescriptivo()+", potencia Consumida(KW):"+ potenciaConsumida;
}
public void mostrarDatos(){
System.out.println("Generador:"+getIdentificador()+", Nombre: "+
getNombreDescriptivo()+", potencia Consumida(KW):"+ potenciaConsumida);
}
}
public class Bateria extends Dispositivos{
private double capacidadMaxima;
private double nivelActual;
public Bateria(String identificador, String nombreDescriptivo,double
capacidadMaxima,double nivelActual) {
super(identificador, nombreDescriptivo);
this.capacidadMaxima=capacidadMaxima;
this.nivelActual=nivelActual;
}

@Override
public void consumo() {
System.out.println("Nivel de energia"+ (nivelActual-capacidadMaxima));
}
public String toString() {
return "identificador: " + getIdentificador() + ", nombredispositivo: " +
getNombreDescriptivo()+", potencia generada(KW):"+ (nivelActual-capacidadMaxima);
}
public void mostrarDatos(){
System.out.println("Generador:"+getIdentificador()+", Nombre: "+
getNombreDescriptivo()+", potencia generada(KW):"+ (nivelActual-capacidadMaxima));
}
}

ejercicio 4:

public class Main {

public static void main(String[] args) {
Cola cola=new Cola("estudio",60);
Tarea tarea= new Tarea("deberes",50);
Tarea tarea1=new Tarea("Gimnasio",20);
cola.encolar(tarea);
cola.encolar(tarea1);
cola.mostrarCola();

}
}
class Cola extends Tarea {
private Nodo frente;
private Nodo fin;
private int tamaño;
 public Cola(String nombre, int prioridad) {
super(nombre, prioridad);
frente = null;
fin = null;
tamaño = 0;
}

public void encolar(Tarea tarea) {

Nodo nuevoNodo = new Nodo(tarea.getNombre(),tarea.getPrioridad());
if (frente == null) {
frente = nuevoNodo;
fin = nuevoNodo;
} else {
fin.siguiente = nuevoNodo;
fin = nuevoNodo;
}
tamaño++;
System.out.println("Se agregó: "+ getNombre()+",prioridad:
"+getPrioridad());
}

public int desencolar() {

if (frente == null) {
System.out.println("La cola está vacía.");
return -1;
}
int dato = frente.dato;
frente = frente.siguiente;
if (frente == null) {
fin = null;
}
tamaño--;
return dato;
}

public int verFrente() {

if (frente == null) {
System.out.println("La cola está vacía.");
return -1;
}
return frente.dato;
}

public boolean estaVacia() {

return frente == null;
}

public int tamaño() {

return tamaño;
}

public void mostrarCola() {

if (frente == null) {
System.out.println("La cola está vacía.");
return;
}
Nodo actual = frente;
 System.out.print("Cola: ");
while (actual != null) {
System.out.print(actual.dato + " -> ");
actual = actual.siguiente;
}
System.out.println("NULL");
}
public void insertarPrioridadAux(Tarea tarea){
insertarPrioridad(frente,tarea);
}
private void insertarPrioridad(Nodo nodo,Tarea tarea){
if (nodo==null){
return;
}
if (tarea.getPrioridad()<nodo.siguiente.getPrioridad()){
insertarPrioridad(nodo.siguiente,tarea);
}else {
encolar(tarea);
}
}
}
class Nodo extends Tarea {
int dato;
Nodo siguiente;

public Nodo(int dato,String nombre,int prioridad) {

super(nombre,prioridad);
this.dato = dato;
this.siguiente = null;
}
public Nodo(String nombre,int prioridad) {
super(nombre,prioridad);

}
public class Tarea {
private String nombre;
private int prioridad;

public Tarea(String nombre, int prioridad) {

this.nombre = nombre;
this.prioridad = prioridad;
}

public String getNombre() {

return nombre;
}

public int getPrioridad() {

return prioridad;
}
}

ejercicio 5:

public class Main {

public static void main(String[] args) {
ArbolBinarioBusqueda arbolBinarioBusqueda=new ArbolBinarioBusqueda();
 arbolBinarioBusqueda.insertar(20);
arbolBinarioBusqueda.insertar(15);
arbolBinarioBusqueda.insertar(25);
arbolBinarioBusqueda.nodosHuerfanos();
}
}
class Nodo {
int valor;
Nodo izquierdo;
Nodo derecho;

public Nodo(int valor) {

this.valor = valor;
izquierdo = null;
derecho = null;
}
}
class ArbolBinarioBusqueda {
Nodo raiz;

public ArbolBinarioBusqueda() {
raiz = null;
}

// Insertar un valor
public void insertar(int valor) {
raiz = insertarRecursivo(raiz, valor);
}

private Nodo insertarRecursivo(Nodo actual, int valor) {

if (actual == null) {
return new Nodo(valor);
}

if (valor < actual.valor) {

actual.izquierdo = insertarRecursivo(actual.izquierdo, valor);
} else if (valor > actual.valor) {
actual.derecho = insertarRecursivo(actual.derecho, valor);
}

return actual;
}

// Buscar un valor
public boolean buscar(int valor) {
return buscarRecursivo(raiz, valor);
}

private boolean buscarRecursivo(Nodo actual, int valor) {

if (actual == null) {
return false;
}

if (valor == actual.valor) {
return true;
}

if (valor < actual.valor) {

return buscarRecursivo(actual.izquierdo, valor);
 } else {
return buscarRecursivo(actual.derecho, valor);
}
}

// Eliminar un valor
public void eliminar(int valor) {
raiz = eliminarRecursivo(raiz, valor);
}

private Nodo eliminarRecursivo(Nodo actual, int valor) {

if (actual == null) {
return null;
}

if (valor < actual.valor) {

actual.izquierdo = eliminarRecursivo(actual.izquierdo, valor);
} else if (valor > actual.valor) {
actual.derecho = eliminarRecursivo(actual.derecho, valor);
} else {
// Caso 1: sin hijos
if (actual.izquierdo == null && actual.derecho == null) {
return null;
}

// Caso 2: un solo hijo

if (actual.izquierdo == null) {
return actual.derecho;
}

if (actual.derecho == null) {
return actual.izquierdo;
}

// Caso 3: dos hijos

int minimoValor = encontrarMinimo(actual.derecho);
actual.valor = minimoValor;
actual.derecho = eliminarRecursivo(actual.derecho, minimoValor);
}

return actual;
}

private int encontrarMinimo(Nodo nodo) {

while (nodo.izquierdo != null) {
nodo = nodo.izquierdo;
}
return nodo.valor;
}
public void nodosHuerfanos(){
int padre= nodospadreAux(raiz);
int hijos=nodosHijo(raiz);
System.out.println("Nodos padre: "+ padre+", hijos: "+ hijos);
}
private int nodospadreAux(Nodo nodo){
if (nodo==null){
return 0;
}
int cuentaPadres=0;
 if ((nodo.derecho!=null&&nodo.izquierdo==null)&&(nodo.derecho.valor%2!=0)){
cuentaPadres+=nodo.valor;
}
if ((nodo.izquierdo!=null&&nodo.derecho==null)&&(nodo.izquierdo.valor%2!
=0)) {
cuentaPadres+=nodo.valor;
}

return cuentaPadres+ nodospadreAux(nodo.izquierdo)+

nodospadreAux(nodo.derecho);
}
private int nodosHijo(Nodo nodo){
if (nodo==null){
return 0 ;
}
int cuentaHijos=0;
if ((nodo.derecho!=null&&nodo.izquierdo==null)&&(nodo.derecho.valor%2!=0)){
cuentaHijos+=nodo.derecho.valor;
}
if ((nodo.izquierdo!=null&&nodo.derecho==null)&&(nodo.izquierdo.valor%2!
=0)) {
cuentaHijos+=nodo.izquierdo.valor;
}

return cuentaHijos+ nodosHijo(nodo.izquierdo)+nodosHijo(nodo.derecho);

}
}