ejercicio1:

import [Link];
public class Main {
public static void main(String[] args) {
Scanner scanner= new Scanner([Link]);
[Link]("Introduce tamaño");
int tamaño= [Link]();
int matriz[][]= new int[tamaño][tamaño];
llenar(matriz);
imprimir(matriz);

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

ejercicio2:

import [Link];
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);
[Link]("Introduce tamaño");
int tamaño = [Link]();
int[] array = new int[tamaño];
int []arrayAux=new int[tamaño];
int total = [Link];
int mitad = total / 2;

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

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

ejercicio 3:
import [Link];
import [Link];

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

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

/*
[Link]("Selecciona un tipo de dispositivo:");
int tipo=0;
for (int i=0;i<capacidad;i++){
switch (tipo=[Link]()){
case 1:
[Link]("id");
String id=[Link]();
[Link]("nombre");
String nombre=[Link]();
[Link]("potencia");
double potencia=[Link]();
[Link](new Generador(id,nombre,potencia));
case 2:
String idConsumidor=[Link]();
 String nombreConsumidor=[Link]();
double potenciaConsumida=[Link]();
[Link](new
Consumidor(idConsumidor,nombreConsumidor,potenciaConsumida));
}
}
*/

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

public Dispositivos(String identificador, String nombreDescriptivo) {

[Link] = identificador;
[Link] = 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);
[Link]=potenciaGenerada;
}

public double getPotenciaGenerada() {

return potenciaGenerada;
}
public void mostrarDatos(){
[Link]("Generador:"+getIdentificador()+", Nombre: "+
getNombreDescriptivo()+", potencia generada(KW):"+ potenciaGenerada);
}
public String toString() {
return "identificador: " + getIdentificador() + ", nombredispositivo: " +
getNombreDescriptivo()+", potencia generada(KW):"+ potenciaGenerada;
}
@Override
public void consumo() {
[Link]("potencia generada-"+potenciaGenerada);
}
}
public class Consumidor extends Dispositivos{
private double potenciaConsumida;
public Consumidor(String identificador, String nombreDescriptivo,double
potenciaConsumida) {
super(identificador, nombreDescriptivo);
 [Link]=potenciaConsumida;
}
@Override
public void consumo() {
[Link]("potencia consumida +"+potenciaConsumida);
}
public double getPotenciaConsumida() {
return potenciaConsumida;
}
public String toString() {
return "identificador: " + getIdentificador() + ", nombredispositivo: " +
getNombreDescriptivo()+", potencia Consumida(KW):"+ potenciaConsumida;
}
public void mostrarDatos(){
[Link]("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);
[Link]=capacidadMaxima;
[Link]=nivelActual;
}

@Override
public void consumo() {
[Link]("Nivel de energia"+ (nivelActual-capacidadMaxima));
}
public String toString() {
return "identificador: " + getIdentificador() + ", nombredispositivo: " +
getNombreDescriptivo()+", potencia generada(KW):"+ (nivelActual-capacidadMaxima);
}
public void mostrarDatos(){
[Link]("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);
[Link](tarea);
[Link](tarea1);
[Link]();

}
}
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([Link](),[Link]());
if (frente == null) {
frente = nuevoNodo;
fin = nuevoNodo;
} else {
[Link] = nuevoNodo;
fin = nuevoNodo;
}
tamaño++;
[Link]("Se agregó: "+ getNombre()+",prioridad:
"+getPrioridad());
}

public int desencolar() {

if (frente == null) {
[Link]("La cola está vacía.");
return -1;
}
int dato = [Link];
frente = [Link];
if (frente == null) {
fin = null;
}
tamaño--;
return dato;
}

public int verFrente() {

if (frente == null) {
[Link]("La cola está vacía.");
return -1;
}
return [Link];
}

public boolean estaVacia() {

return frente == null;
}

public int tamaño() {

return tamaño;
}

public void mostrarCola() {

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

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

super(nombre,prioridad);
[Link] = dato;
[Link] = 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) {

[Link] = nombre;
[Link] = 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();
 [Link](20);
[Link](15);
[Link](25);
[Link]();
}
}
class Nodo {
int valor;
Nodo izquierdo;
Nodo derecho;

public Nodo(int valor) {

[Link] = 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 < [Link]) {

[Link] = insertarRecursivo([Link], valor);
} else if (valor > [Link]) {
[Link] = insertarRecursivo([Link], 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 == [Link]) {
return true;
}

if (valor < [Link]) {

return buscarRecursivo([Link], valor);
 } else {
return buscarRecursivo([Link], 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 < [Link]) {

[Link] = eliminarRecursivo([Link], valor);
} else if (valor > [Link]) {
[Link] = eliminarRecursivo([Link], valor);
} else {
// Caso 1: sin hijos
if ([Link] == null && [Link] == null) {
return null;
}

// Caso 2: un solo hijo

if ([Link] == null) {
return [Link];
}

if ([Link] == null) {
return [Link];
}

// Caso 3: dos hijos

int minimoValor = encontrarMinimo([Link]);
[Link] = minimoValor;
[Link] = eliminarRecursivo([Link], minimoValor);
}

return actual;
}

private int encontrarMinimo(Nodo nodo) {

while ([Link] != null) {
nodo = [Link];
}
return [Link];
}
public void nodosHuerfanos(){
int padre= nodospadreAux(raiz);
int hijos=nodosHijo(raiz);
[Link]("Nodos padre: "+ padre+", hijos: "+ hijos);
}
private int nodospadreAux(Nodo nodo){
if (nodo==null){
return 0;
}
int cuentaPadres=0;
 if (([Link]!=null&&[Link]==null)&&([Link]%2!=0)){
cuentaPadres+=[Link];
}
if (([Link]!=null&&[Link]==null)&&([Link]%2!
=0)) {
cuentaPadres+=[Link];
}

return cuentaPadres+ nodospadreAux([Link])+

nodospadreAux([Link]);
}
private int nodosHijo(Nodo nodo){
if (nodo==null){
return 0 ;
}
int cuentaHijos=0;
if (([Link]!=null&&[Link]==null)&&([Link]%2!=0)){
cuentaHijos+=[Link];
}
if (([Link]!=null&&[Link]==null)&&([Link]%2!
=0)) {
cuentaHijos+=[Link];
}

return cuentaHijos+ nodosHijo([Link])+nodosHijo([Link]);

}
}