Taller de Programación 1 Lic. J.

Felipez

MANEJO DE UNA ESTRUCTURA TREESET

import java.util.Iterator;
import java.util.TreeSet;

/**
* Manejo de TreeSet.
* Arbol binario de búsqueda (BST) balanceado de solo claves.
* No acepta claves duplicadas.
* Las operaciones de inserción/búsqueda/eliminación se realizan en O(log n).
*
*/
public class EjemploTreeSet {
public static void main(String[] args) {

TreeSet<Integer> claves = new TreeSet<Integer>();

claves.clear(); // Elimina todos los elementos.

/* ¿El árbol está vacío? */

System.out.println(claves.isEmpty()); // true

claves.add(100); // Ingresa 100

claves.add(10); // Ingresa 10
claves.add(50); // Ingresa 50
claves.add(1); // Ingresa 1
claves.add(13); // Ingresa 13

claves.remove(10); // Elimina clave 10

System.out.println(claves); // Imprime [1, 13, 50, 100]

System.out.println(claves.contains(50)); // Imprime true
System.out.println(claves.headSet(50)); // claves < 50, Salida [1, 13]
System.out.println(claves.tailSet(50)); // claves >= 50, Salida [50, 100]

// Muestra todos los elementos

Iterator<Integer> it = claves.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}

}
}
Taller de Programación 2 Lic. J. Felipez

MANEJO DE UNA ESTRUCTURA TREEMAP

import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

/**
* Manejo de TreeMap.
* Arbol binario de búsqueda (BST) balanceado (clave -> dato)
* No acepta claves duplicadas.
* Las operaciones de inserción/búsqueda/eliminación se realizan en O(log n).
*
*/
public class EjemploTreeMap {
public static void main(String[] args) {

TreeMap<Integer, String> arbol = new TreeMap<Integer, String>();

arbol.clear(); // Elimina todos los elementos.

/* ¿El árbol está vacío? */

System.out.println(arbol.isEmpty()); // true

arbol.put(100, "a"); // Ingresa <100,"a">

arbol.put(10, "b"); // Ingresa <10,"b">
arbol.put(50, "c"); // Ingresa <50,"c">
arbol.put(1, "d"); // Ingresa <1,"d">
arbol.put(13, "e"); // Ingresa <13,"e">

arbol.remove(10); // Elimina <10, "b">

System.out.println(arbol.keySet()); // Imprime [1, 13, 50, 100]

System.out.println(arbol.values()); // Imprime [d, e, c, a]
System.out.println(arbol.containsKey(50)); // Imprime true
System.out.println(arbol.get(50)); // Imprime "c"

// Muestra todos los elementos

for (Map.Entry<Integer, String> e : arbol.entrySet())
System.out.println(e.getKey() + " - " + e.getValue());

// Obtiene el BST balanceado entre 13 <= clave < 100

SortedMap<Integer, String> res = arbol.subMap(13, 100);

System.out.println(res.keySet()); // Imprime [13, 50]

System.out.println(res.values()); // Imprime [e, c]
}
}
Taller de Programación 3 Lic. J. Felipez

MANEJO DE UNA ESTRUCTURA LINKEDHASHMAP

import java.util.LinkedHashMap;
import java.util.Map;

/**
* Manejo de LinkedHashMap.
* No ordena por la clave, se muestra en el orden en que fueron ingresados
* en el mapa (clave -> dato)
* No acepta claves duplicadas.
* Las operaciones de inserción/búsqueda/eliminación se realizan en O(1).
*
*/
public class EjemploLinkedHashMap {
public static void main(String[] args) {

LinkedHashMap<Integer, String> mapa = new LinkedHashMap<Integer, String>();

mapa.clear(); // Elimina todos los elementos.

/* ¿El mapa está vacío? */

System.out.println(mapa.isEmpty()); // true

mapa.put(100, "a"); // Ingresa <100,"a">

mapa.put(10, "b"); // Ingresa <10,"b">
mapa.put(50, "c"); // Ingresa <50,"c">
mapa.put(1, "d"); // Ingresa <1,"d">
mapa.put(13, "e"); // Ingresa <13,"e">

mapa.remove(10); // Elimina <10, "b">

System.out.println(mapa.keySet()); // Imprime [100, 50, 1, 13]

System.out.println(mapa.values()); // Imprime [a, c, d, e]
System.out.println(mapa.containsKey(50)); // Imprime true
System.out.println(mapa.get(50)); // Imprime "c"

// Muestra todos los elementos

for (Map.Entry<Integer, String> e : mapa.entrySet())
System.out.println(e.getKey() + " - " + e.getValue());

}
}