Sintaxis de Arreglos Unidimensionales:

// Declaración de un arreglo unidimensional de enteros

int[] arreglo = new int[5];

// Inicialización de elementos
arreglo[0] = 10;
arreglo[1] = 20;
arreglo[2] = 30;
arreglo[3] = 40;
arreglo[4] = 50;

// Acceso a elementos
int primerElemento = arreglo[0];
Sintaxis de Arreglos Bidimensionales:
// Declaración de un arreglo bidimensional de enteros
int[][] matriz = new int[3][3];

// Inicialización de elementos
matriz[0][0] = 1;
matriz[0][1] = 2;
matriz[0][2] = 3;
matriz[1][0] = 4;
matriz[1][1] = 5;
matriz[1][2] = 6;
matriz[2][0] = 7;
matriz[2][1] = 8;
matriz[2][2] = 9;

// Acceso a elementos
int elemento = matriz[1][2];
Sintaxis de un Arreglo de Objetos:
// Declaración de un arreglo de objetos (por ejemplo, de la clase 'MiObjeto')
MiObjeto[] arregloObjetos = new MiObjeto[5];

// Inicialización de elementos (creación de objetos)

arregloObjetos[0] = new MiObjeto();
arregloObjetos[1] = new MiObjeto();
arregloObjetos[2] = new MiObjeto();
arregloObjetos[3] = new MiObjeto();
arregloObjetos[4] = new MiObjeto();

// Acceso a objetos en el arreglo

MiObjeto primerObjeto = arregloObjetos[0];
Declaración de la Clase Objeto: La declaración de una clase en Java se ve así:
public class MiClase {
// Atributos (variables de instancia)
private int atributo1;
private String atributo2;

// Constructor
public MiClase(int valor1, String valor2) {
atributo1 = valor1;
atributo2 = valor2;
}

// Métodos
public void metodo1() {
// Código del método
}

public int metodo2() {

// Código del método
return 0;
}
}
Ejemplo de Herencia:
public class Animal {
public void sonido() {
System.out.println("El animal hace un sonido");
}
}

public class Perro extends Animal {

public void sonido() {
System.out.println("El perro ladra");
}
}

public class Gato extends Animal {

public void sonido() {
System.out.println("El gato maulla");
}
}
Ejemplo de Polimorfismo:
Animal[] animales = new Animal[2];
animales[0] = new Perro();
animales[1] = new Gato();

for (Animal animal : animales) {

animal.sonido(); // Llama al método sonido correspondiente de cada subclase
}
Ejemplo de programa de recursividad:
public class RecursividadEjemplo {

public static void main(String[] args) {

int numero = 5;
int resultado = calcularFactorial(numero);
System.out.println("El factorial de " + numero + " es: " + resultado);
}

public static int calcularFactorial(int n) {

// Caso base
if (n == 0 || n == 1) {
return 1;
}
// Caso recursivo
else {
// Llamada recursiva
return n * calcularFactorial(n - 1);
}
}
}
Código de ordenamiento inserción:
public class OrdenamientoInsercion {
public static void main(String[] args) {
int[] arreglo = {5, 2, 8, 3, 1};
ordenarPorInsercion(arreglo);
imprimirArreglo(arreglo);
}
public static void ordenarPorInsercion(int[] arreglo) {
int n = arreglo.length;
for (int i = 1; i < n; i++) {
int valorActual = arreglo[i];
int j = i - 1;
while (j >= 0 && arreglo[j] > valorActual) {
arreglo[j + 1] = arreglo[j];
j--;
}
arreglo[j + 1] = valorActual;
}
}
public static void imprimirArreglo(int[] arreglo) {
for (int num : arreglo) {
System.out.print(num + " ");
}
}
}
Código de ordenamiento selección:
public class OrdenamientoSeleccion {
public static void main(String[] args) {
int[] arreglo = {5, 2, 8, 3, 1};
ordenarPorSeleccion(arreglo);
imprimirArreglo(arreglo);
}
public static void ordenarPorSeleccion(int[] arreglo) {
int n = arreglo.length;
for (int i = 0; i < n - 1; i++) {
int indiceMinimo = i;
for (int j = i + 1; j < n; j++) {
if (arreglo[j] < arreglo[indiceMinimo]) {
indiceMinimo = j;
}
}
int temp = arreglo[indiceMinimo];
arreglo[indiceMinimo] = arreglo[i];
arreglo[i] = temp;
}
}
public static void imprimirArreglo(int[] arreglo) {
for (int num : arreglo) {
System.out.print(num + " ");
}
}
}
Código de ordenamiento burbuja:
public class OrdenamientoBurbuja {
public static void main(String[] args) {
int[] arreglo = {5, 2, 8, 3, 1};
ordenarPorBurbuja(arreglo);
imprimirArreglo(arreglo);
}
public static void ordenarPorBurbuja(int[] arreglo) {
int n = arreglo.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (arreglo[j] > arreglo[j + 1]) {
int temp = arreglo[j];
arreglo[j] = arreglo[j + 1];
arreglo[j + 1] = temp;
}
}
}
}
public static void imprimirArreglo(int[] arreglo) {
for (int num : arreglo) {
System.out.print(num + " ");
}
}
}
Código de ordenamiento intercambio:
public class OrdenamientoIntercambio {
public static void main(String[] args) {
int[] arreglo = {5, 2, 8, 3, 1};
ordenarPorIntercambio(arreglo);
imprimirArreglo(arreglo);
}
public static void ordenarPorIntercambio(int[] arreglo) {
int n = arreglo.length;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (arreglo[i] > arreglo[j]) {
int temp = arreglo[i];
arreglo[i] = arreglo[j];
arreglo[j] = temp;
}
}
}
}
public static void imprimirArreglo(int[] arreglo) {
for (int num : arreglo) {
System.out.print(num + " ");
}
}
}
Código de ordenamiento rápido: public static void fusionar(int[] arreglo, int inicio, int
medio, int fin) {
public class OrdenamientoMezcla { int[] izquierda = Arrays.copyOfRange(arreglo,
inicio, medio + 1);
int[] derecha = Arrays.copyOfRange(arreglo, medio +
public static void main(String[] args) { 1, fin + 1);
int[] arreglo = {5, 2, 8, 3, 1}; int i = 0, j = 0, k = inicio;
ordenarPorMezcla(arreglo, 0, arreglo.length - while (i < izquierda.length && j < derecha.length) {
arreglo[k++] = (izquierda[i] <= derecha[j]) ?
1); izquierda[i++] : derecha[j++];
imprimirArreglo(arreglo); }
} while (i < izquierda.length) {
arreglo[k++] = izquierda[i++];
}
public static void ordenarPorMezcla(int[] arreglo,
int inicio, int fin) { while (j < derecha.length) {
arreglo[k++] = derecha[j++];
if (inicio < fin) { }
int medio = (inicio + fin) / 2; }
ordenarPorMezcla(arreglo, inicio, medio); public static void imprimirArreglo(int[] arreglo) {
ordenarPorMezcla(arreglo, medio + 1, fin); for (int num : arreglo) {
fusionar(arreglo, inicio, medio, fin); System.out.print(num + " ");
}
} }
} }
Código de ordenamiento mezcla:
public static void fusionar(int[] arreglo, int inicio, int
public class OrdenamientoMezcla { medio, int fin) {
int[] izquierda = Arrays.copyOfRange(arreglo, inicio,
public static void main(String[] args) { medio + 1);
int[] arreglo = {5, 2, 8, 3, 1}; int[] derecha = Arrays.copyOfRange(arreglo, medio + 1,
ordenarPorMezcla(arreglo, 0, arreglo.length - fin + 1);
1);
imprimirArreglo(arreglo); int i = 0, j = 0, k = inicio;
} while (i < izquierda.length && j < derecha.length) {
arreglo[k++] = (izquierda[i] <= derecha[j]) ?
public static void ordenarPorMezcla(int[] arreglo, izquierda[i++] : derecha[j++];
int inicio, int fin) { }
if (inicio < fin) {
int medio = (inicio + fin) / 2; while (i < izquierda.length) {
arreglo[k++] = izquierda[i++];
ordenarPorMezcla(arreglo, inicio, medio);
}
ordenarPorMezcla(arreglo, medio + 1, fin);
fusionar(arreglo, inicio, medio, fin);
while (j < derecha.length) {
} arreglo[k++] = derecha[j++];
} }
}

public static void imprimirArreglo(int[] arreglo) {

for (int num : arreglo) {
System.out.print(num + " ");
}
}
}
Código de búsqueda binaria:
public class BusquedaBinaria {
public static void main(String[] args) {
int[] arreglo = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int elementoBuscar = 6;
int indice = buscarBinaria(arreglo, elementoBuscar);
if (indice != -1) {
System.out.println("El elemento " + elementoBuscar + " se encuentra en el índice " + indice);
} else {
System.out.println("El elemento " + elementoBuscar + " no se encuentra en el arreglo");
}
}
public static int buscarBinaria(int[] arreglo, int elemento) {
int inicio = 0;
int fin = arreglo.length - 1;
while (inicio <= fin) {
int medio = inicio + (fin - inicio) / 2;
if (arreglo[medio] == elemento) {
return medio; // Se encontró el elemento
}
if (arreglo[medio] < elemento) {
inicio = medio + 1;
} else {
fin = medio - 1;
}
}
return -1; // No se encontró el elemento
}
}
Código de búsqueda secuencial:
public class BusquedaSecuencial {
public static void main(String[] args) {
int[] arreglo = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int elementoBuscar = 6;
int indice = buscarSecuencial(arreglo, elementoBuscar);
if (indice != -1) {
System.out.println("El elemento " + elementoBuscar + " se encuentra en el índice " + indice);
} else {
System.out.println("El elemento " + elementoBuscar + " no se encuentra en el arreglo");
}
}
public static int buscarSecuencial(int[] arreglo, int elemento) {
for (int i = 0; i < arreglo.length; i++) {
if (arreglo[i] == elemento) {
return i; // Se encontró el elemento
}
}
return -1; // No se encontró el elemento
}
}
Código de Insertar listas:
public class Lista {

private Nodo primero;

public void insertar(int dato) {

Nodo nuevo = new Nodo(dato);
nuevo.enlace = primero;
primero = nuevo;
}
}
Código de eliminar listas:
public class Lista {

private Nodo primero;

public void eliminar(int dato) {

Nodo actual = primero;
Nodo anterior = null;

while (actual != null && actual.dato != dato) {

anterior = actual;
actual = actual.enlace;
}

if (actual != null) {
if (anterior == null) {
primero = actual.enlace;
} else {
anterior.enlace = actual.enlace;
}
}
}
}
Código de buscar listas:
public class Lista {

private Nodo primero;

public Nodo buscar(int dato) {

Nodo actual = primero;

while (actual != null && actual.dato != dato) {

actual = actual.enlace;
}

return actual;
}
}
Código de Insertar dobles listas:
public class ListaDoble {

private NodoDoble cabeza;

public void insertar(int dato) {

NodoDoble nuevo = new NodoDoble(dato);
nuevo.adelante = cabeza;
if (cabeza != null) {
cabeza.atras = nuevo;
}
cabeza = nuevo;
}
}
Código de eliminar dobles listas:
public class ListaDoble {
private NodoDoble cabeza;
public void eliminar(int dato) {
NodoDoble actual = cabeza;
while (actual != null && actual.dato != dato) {
actual = actual.adelante;
}
if (actual != null) {
if (actual.atras != null) {
actual.atras.adelante = actual.adelante;
} else {
cabeza = actual.adelante;
}
if (actual.adelante != null) {
actual.adelante.atras = actual.atras;
}
}
}
}
Código de buscar dobles listas:
public class ListaDoble {

private NodoDoble cabeza;

public NodoDoble buscar(int dato) {

NodoDoble actual = cabeza;

while (actual != null && actual.dato != dato) {

actual = actual.adelante;
}

return actual;
}
}
Código de Insertar pilas:
void insertarPila(char caracter) {
if (pilaLlena()) {
System.out.println("Pila llena");
} else {
pilas[cima] = caracter;
cima++;
}
}
Código de eliminar pilas:
void eliminarPila() {
if (!pilaVacia()) {
System.out.println("Eliminado");
pilas[cima-1] = ' ';
cima--;
} else {
System.out.println("Pila vacia");
}
}
Código de Insertar colas:
void insertarCola(char caracter) {
if (colaLlena()) {
System.out.println("Cola llena");
} else {
fin++;
colas[fin] = caracter;
if (fin == 0) {
frente = 0;
}
}
}
Código de eliminar colas:
void eliminarCola() {
if (colaVacia()) {
System.out.println("Cola vacia");
} else {
System.out.println("Eliminado" + colas[frente]);
colas[frente] = ' ';
if (frente == fin) {
frente = -1;
fin = -1;
} else {
for (int j = 0; j < fin; j++) {
colas[j] = colas[j + 1];
}
colas[fin] = ' ';
fin--;
}
}
}
Código de Insertar árboles:
public static NodoABB insertar(NodoABB raiz, int valor) {
if (raiz == null) {
raiz = new NodoABB(valor);
return raiz;
}

if (valor < raiz.valor) {

raiz.izquierdo = insertar(raiz.izquierdo, valor);
} else if (valor > raiz.valor) {
raiz.derecho = insertar(raiz.derecho, valor);
}

return raiz;
}
Código de eliminar árboles:
// Eliminar un valor del árbol
public static NodoABB eliminar(NodoABB raiz, int valor) {
if (raiz == null) {
return raiz;
}
if (valor < raiz.valor) {
raiz.izquierdo = eliminar(raiz.izquierdo, valor);
} else if (valor > raiz.valor) {
raiz.derecho = eliminar(raiz.derecho, valor);
} else {
// Nodo con un solo hijo o sin hijos
if (raiz.izquierdo == null) {
return raiz.derecho;
} else if (raiz.derecho == null) {
return raiz.izquierdo;
}
// Nodo con dos hijos: Obtener el sucesor inorden (el más pequeño en el subárbol derecho)
raiz.valor = obtenerMenorValor(raiz.derecho);
// Eliminar el sucesor inorden
raiz.derecho = eliminar(raiz.derecho, raiz.valor);
}
return raiz;
}
Código de buscar árboles:
// Buscar un valor en el árbol
public static NodoABB buscar(NodoABB raiz, int valor) {
if (raiz == null || raiz.valor == valor) {
return raiz;
}

// Recorrer el árbol de manera recursiva

if (valor < raiz.valor) {
return buscar(raiz.izquierdo, valor);
}
return buscar(raiz.derecho, valor);
}
Código de algoritmo dijkstra:
import java.util.*; System.out.println("Distancias mínimas desde el origen:");
for (int i = 0; i < V; i++) {
public class DijkstraExample {
System.out.println("Hacia el nodo " + i + ": " +
public static void main(String[] args) { dist[i]);
int[][] graph = {
{0, 4, 0, 0, 0}, }
{4, 0, 8, 0, 0}, }
{0, 8, 0, 7, 0},
{0, 0, 7, 0, 9},
{0, 0, 0, 9, 0} public static int minDistance(int[] dist, boolean[] sptSet) {
};
int V = dist.length;
dijkstra(graph, 0); int min = Integer.MAX_VALUE;
}
int minIndex = -1;
public static void dijkstra(int[][] graph, int src) {
int V = graph.length;
int[] dist = new int[V]; for (int v = 0; v < V; v++) {
boolean[] sptSet = new boolean[V]; if (!sptSet[v] && dist[v] <= min) {
Arrays.fill(dist, Integer.MAX_VALUE); min = dist[v];
dist[src] = 0; minIndex = v;
for (int count = 0; count < V - 1; count++) { }
int u = minDistance(dist, sptSet);
sptSet[u] = true; }

for (int v = 0; v < V; v++) {

if (!sptSet[v] && graph[u][v] != 0 && dist[u] != return minIndex;
Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v]) { }
dist[v] = dist[u] + graph[u][v];
} }
}
}
 public static void floydWarshall(int[][] graph) {
Código de algoritmo floyd: int V = graph.length;
int[][] dist = new int[V][V];

import java.util.*; for (int i = 0; i < V; i++) {

for (int j = 0; j < V; j++) {
dist[i][j] = graph[i][j];
public class FloydWarshallExample { }
}

final static int INF = 99999; for (int k = 0; k < V; k++) {

for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
public static void main(String[] args) { if (dist[i][k] + dist[k][j] < dist[i][j]) {
int[][] graph = { dist[i][j] = dist[i][k] + dist[k][j];
}
{0, 4, INF, INF, INF}, }
{4, 0, 8, INF, INF}, }
{INF, 8, 0, 7, INF}, }

{INF, INF, 7, 0, 9}, System.out.println("Matriz de distancias mínimas entre todos los pares de
{INF, INF, INF, 9, 0} nodos:");
for (int i = 0; i < V; ++i) {
}; for (int j = 0; j < V; ++j) {
if (dist[i][j] == INF) {
System.out.print("INF ");
floydWarshall(graph); } else {
} System.out.print(dist[i][j] + " ");
}
}
System.out.println();
}
}
}