DIAGRAMA DE FLUJO

ejercicios

ENLISTAR LISTAS
import java.util.*;

public class EnlistarListas{

public static void main(String[] args) {

Map<String,String> hm = new HashMap<String,String>();

hm.put("1","java ");
hm.put("2","en");
hm.put("3","listas");

// Añadimos un elemento con clave existente. Se sobrescribe su valor
// ya que no puede haber valores duplicados

Iterator it = hm.entrySet().iterator();

while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
System.out.println(e.getKey() + " " + e.getValue());
}
}

}




EJERCICIO PILAS
import java.io.*;

class Pila{
public static BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
public static final int MAX_LENGTH = 5;
public static String Pila[] = new String[MAX_LENGTH];
public static int cima = -1;

  public static void main(String args[])throws IOException{

    Menu();
  }
  public static void Menu()throws IOException{
  System.out.println("\n\n\t\t\t=========Menu Manejo Pila=============");
  System.out.println("\t\t\t=                  =");
  System.out.println("\t\t\t= 1- Insertar elemento        =");
  System.out.println("\t\t\t= 2- Eliminar elemento        =");
  System.out.println("\t\t\t= 3- Buscar elemento        =");
  System.out.println("\t\t\t= 4- Imprimir pila          =");
  System.out.println("\t\t\t= 5- Actualizar valor en pila    =");
  System.out.println("\t\t\t= 6- Salir              =");
  System.out.println("\t\t\t======================================");
  System.out.print("\t\t\tOpcion: ");
  int op = Integer.parseInt(entrada.readLine());
  Opciones(op);

  }
  public static void Opciones(int op)throws IOException{
    switch(op){
  case 1: Insertar();
      break;
  case 2: Eliminar();
      break;
  case 3: Buscar();
      break;
  case 4: Imprimir();
      break;
  case 5: Actualizar();
      break;
  case 6: System.exit(1);
      break;
  default:Menu();
      break;
  }
  }
  public static void Insertar()throws IOException{

    System.out.print("\nDigite algo para la pila: ");
    String dato = entrada.readLine();
    Crear(dato);
  }
  public static void Crear(String dato)throws IOException{
  if ((Pila.length-1)==cima){
    System.out.println("Capacidad de la pila al limite\n\n\n");
    Imprimir();
  }else{
    ++cima;
    }
  Agregar(dato);
  }
  public static void Agregar(String dato)throws IOException{
  Pila[cima]=dato;
  Menu();
  }
  public static void Imprimir()throws IOException{
  for(int i=Pila.length-1;i>=0;i--){
    System.out.println(Pila[i]);
  }
  Menu();
  }
  public static void Eliminar()throws IOException{
  if(cima== -1){
  System.out.println("\n\n\nNo se puede eliminar, pila vacia !!!" );
  }else{
    Pila[cima] = null;
    --cima;
    }
  Menu();
  }
  public static void Buscar()throws IOException{
  System.out.println("\n\n\nDigite la cadena a buscar: ");
  String cad = entrada.readLine();
    for(int i=0;i<Pila.length-1;i++){
  if(cad.equals(Pila[i])){
    System.out.println("Elemento encontrado,posicion "+i);
    break;
    }else{
      System.out.println("Elemento no encontrado :(");
      }
  }
  Menu();
  }
  public static void Actualizar()throws IOException{
  System.out.print("Digite el nombre del valor que desea actualizar: ");
  String actual = entrada.readLine();
  System.out.print("Digite el nombre del nuevo valor: ");
  String nuevo = entrada.readLine();
      for(int i=0;i<Pila.length-1;i++){
    if(actual.equals(Pila[i])){
        Pila[i]=nuevo;
        break;
      }else{
        System.out.println("Elemento no encontrado :(");
        }
  }
  Menu();
  }
}

MATRIZES

MATRIZ1

public class Matriz1 {
public static void main (String arg [])throws Exception{
int matriz[][]=new int [3][3];

matriz [0][0]=9;

matriz [0][1]=9;

matriz [0][2]=9;

matriz [1][0]=16;

matriz [1][1]=16;

matriz [1][2]=16;

matriz [2][0]=25;

matriz [2][1]=25;

matriz [2][2]=25;
System.out.println(" MATRIZ 1 ");
System.out.println();
for (int i=0;i<3;i++){
for (int j=0;j<3;j++){
System.out.print(matriz [i][j] + "\t");
}
System.out.println();
}
}
}

MATRIZ2

class MatrizDiagonal {
public static void main (String arg [])throws Exception{
int matriz[][]=new int [3][3];
matriz [0][0]=5;
matriz [0][1]=0;
matriz [0][2]=0;
matriz [1][0]=0;
matriz [1][1]=5;
matriz [1][2]=0;
matriz [2][0]=0;
matriz [2][1]=0;
matriz [2][2]=5;
System.out.println (" MATRIZ DIAGONAL " );

System.out.println();
for (int i=0;i<3;i++){
for (int j=0;j<3;j++){

System.out.print(matriz [i][j] + "\t");
}
System.out.println();

}
}
}

QUE ES UN ORDENAMIENTO

QUE ES UN ORDENAMIENTO?

Es la operación de arreglar los registros de una tabla en algún orden secuencial de acuerdo a un criterio de ordenamiento.
El ordenamiento se efectúa con base en el valorde algún campo en un registro.
El propósito principal de un ordenamiento es el de facilitar las búsquedas de los miembros del conjunto ordenado.

MÉTODO BURBUJA.

El bubble sort, también conocido como ordenamiento burbuja, funciona de la siguiente manera: Se recorre el arreglo intercambiando los elementos adyacentes que estén desordenados. Se recorre el arreglo tantas veces hasta que ya no haya cambios. Prácticamente lo que hace es tomar el elemento mayor y lo va recorriendo de posición en posición hasta ponerlo en su lugar.



Procedimiento Bubble Sort

paso 1: [Inicializa i al final de arreglo] For i <- N down to 1 do

paso 2: [Inicia desde la segunda pos.] For j <- 2 to i do

paso 4: [Si a[j-1] es mayor que el que le sigue] If a[j-1] < a[j] then

paso 5: [Los intercambia] Swap(a, j-1, j).

paso 7: [Fin] End.
Tiempo de ejecución del algoritmo burbuja:

1.Para el mejor caso (un paso) O(n)

2.Peor caso n(n-1)/2

3.Promedio O(n2)
 
  QUICKSORT
 
Quicksort en acción sobre una lista de números aleatorios. Las líneas horizontales son valores pivote.El ordenamiento rápido (quicksort en inglés) es un algoritmo basado en la técnica de divide y vencerás, que permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n.

MATRICES

Búsqueda


La búsqueda consiste acceder a la raíz del árbol, si el elemento a localizar coincide con éste la búsqueda ha concluido con éxito, si el elemento es menor se busca en el subárbol izquierdo y si es mayor en el derecho. Si se alcanza un nodo hoja y el elemento no ha sido encontrado se supone que no existe en el árbol. Cabe destacar que la búsqueda en este tipo de árboles es muy eficiente, representa una función logarítmica. El máximo número de comparaciones que necesitaríamos para saber si un elemento se encuentra en un árbol binario de búsqueda estaría entre [log2(N+1)] y N, siendo N el número de nodos. La búsqueda de un elemento en un ABB (Árbol Binario de Búsqueda) se puede realizar de dos formas, iterativa o recursiva.



Tipos de búsqueda



Inserción

La inserción es similar a la búsqueda y se puede dar una solución tanto iterativa como recursiva. Si tenemos inicialmente como parámetro un árbol vacío se crea un nuevo nodo como único contenido el elemento a insertar. Si no lo está, se comprueba si el elemento dado es menor que la raíz del árbol inicial con lo que se inserta en el subárbol izquierdo y si es mayor se inserta en el subárbol derecho. De esta forma las inserciones se hacen en las hojas.



Borrado

La operación de borrado no es tan sencilla como las de búsqueda e inserción. Existen varios casos a tener en consideración:

• Borrar un nodo sin hijos o nodo hoja: simplemente se borra y se establece a nulo el apuntador de su padre.



• Borrar un nodo con un subárbol hijo: se borra el nodo y se asigna su subárbol hijo como subárbol de su padre.



• Borrar un nodo con dos subárboles hijo: la solución está en reemplazar el valor del nodo por el de su predecesor o por el de su sucesor en inorden y posteriormente borrar este nodo. Su predecesor en inorden será el nodo más a la derecha de su subárbol izquierdo (mayor nodo del subarbol izquierdo), y su sucesor el nodo más a la izquierda de su subárbol derecho (menor nodo del subarbol derecho). En la siguiente figura se muestra cómo existe la posibilidad de realizar cualquiera de ambos reemplazos:



Recorridos

Se puede hacer un recorrido de un árbol en profundidad o en anchura.

Los recorridos en anchura son por niveles, se realiza horizontalmente desde la raíz a todos los hijos antes de pasar a la descendencia de alguno de los hijos.

El recorrido en profundidad lleva al camino desde la raíz hacia el descendiente más lejano del primer hijo y luego continúa con el siguiente hijo. Como recorridos en profundidad tenemos inorden, pre orden y postor den.

Una propiedad de los ABB es que al hacer un recorrido en profundidad inorden obtenemos los elementos ordenados de forma ascendente.