PROGRAMA ARBOLES

MAPA CONCEPTUAL ARBOLES

PROGRAMA DE COLAS

import java.util.*;

//import Elemento

public class Cola extends Vector {
 
  public int anadirElememto(int tiempo){
    Elemento elem;
    elem = new Elemento(tiempo);
    this.addElement(elem);
    return elem.creado;
  }

  public boolean tieneElementos(){
    Enumeration NUm = this.elements();
    return NUm.hasMoreElements();
  }

  public Elemento procesarElemento(Vector colaProcesados){
    Elemento elem =(Elemento)this.elementAt(0);
    elem.tiempoProceso = (int)(Math.random() * 10);
    colaProcesados.addElement(elem);
    this.removeElementAt(0);
    return elem;
  }
}
                                                         
                                                                                                                 
import java.lang.Math;
import java.awt.*;

public class Elemento {
  public int creado;
  public int inicioProceso;
  public int tiempoProceso;

  public Elemento(int tiempo) {
    creado = tiempo + (int)(Math.random() * 10);
  }



  public void Dibujar(Graphics g){
    g.setColor(Color.black);
    g.drawRect(creado*5,100,2,2);
    g.drawLine(creado*5,100,inicioProceso*5,150);
    g.drawRect(inicioProceso*5,150,tiempoProceso*5,2);
  }
}





                                          

import java.lang.Math;
import java.awt.*;
import java.util.*;

public class ColaSimple {
  private static int tiempo;
  private static int horaLibre;

  public static void main(String args[]) {
    System.out.println("Inicio de Simulación de Cola simple");
    Cola cola = new Cola();
    Vector colaProcesada = new Vector();

    Frame ventana = new Frame("Simulación de cola simple");
    DrawWindow mipanel = new DrawWindow(colaProcesada);
  ventana.add(mipanel);
  ventana.pack();
  ventana.setSize(500,500);






    while (tiempo < 100) {
      tiempo = cola.anadirElememto(tiempo);
      System.out.println("Tiempo:" + tiempo+ " Items: " + cola.size());
          while ((horaLibre < tiempo) && (cola.tieneElementos())) {
            Elemento procesado = cola.procesarElemento(colaProcesada);
            procesado.inicioProceso =  Math.max(horaLibre, procesado.creado);
            horaLibre = procesado.inicioProceso + procesado.tiempoProceso;
            System.out.println("Tiempo:" + tiempo+ " Items: " + cola.size()
              + " Hora entrada: " + procesado.creado+ " Tiempo proceso: " + procesado.tiempoProceso);

          }
    }
  ventana.show();
  }
}



                                           

import java.awt.*;
import java.util.Vector;
import java.util.Enumeration;

public class DrawWindow extends Panel {
    private Vector v;
    public DrawWindow(Vector v) {
        super(new FlowLayout());
        this.v=v;
    }

    public void paint(Graphics g) {
        Elemento dib;
        Enumeration e;
        e = v.elements();
        while(e.hasMoreElements()){
            dib=(Elemento)e.nextElement();
            dib.Dibujar(g);

       }

   }

}

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();
  }
}

LISTAS

import java.util.*; 
 class NodoLista4{ 
     String nom; 
     int calif1; 
     int calif2; 
     int calif3; 
 }
  class ListaAlumnos{ 
   
        static double prom; 
    public static void main( String args[] ){ 
      Scanner leer = new Scanner(System.in); 
   
         NodoLista4 nodo = new NodoLista4(); 
         int op; 
   
         ArrayList lista = new ArrayList(); 
      do{ 
         System.out.println( "Ingrese el nombre del alumno:" ); 
         nodo.nom = leer.next(); 
         System.out.println( "Ingrese la primera calificación:" ); 
         nodo.calif1 = leer.nextInt(); 
         System.out.println( "Ingrese la segunda calificación:" ); 
         nodo.calif2 = leer.nextInt(); 
        System.out.println( "Ingrese la tercera calificación:" ); 
         nodo.calif3 = leer.nextInt(); 
   
         lista.add("Nombre del alumno:\n"+nodo.nom); 
         lista.add("Calificación 1:\n"+nodo.calif1); 
        lista.add("Calificación 2:\n"+nodo.calif2); 
        lista.add("Calificación 3\n"+nodo.calif3); 
  
        promedio(nodo.calif1, nodo.calif2, nodo.calif3); 
  
         lista.add("Su promedio es:\n"+prom); 
   
         System.out.println( "¿Desea ingresar otro alumno?" ); 
        System.out.println( "1.-Si\t 2.-No" ); 
         op = leer.nextInt(); 
      } 
       while(op != 2); 
        List lista2 = new ArrayList(lista); 
         Iterator it = lista2.iterator(); 
        while (it.hasNext()){ 
             System.out.println(it.next()+""); 
          } 
   } 
   
      private static double promedio(int calif1, int calif2, int calif3){ 
          int suma = calif1 + calif2 + calif3; 
          prom = suma/3; 
          return prom; 
       } 
 }



PROMEDIO

import java.io.*;
 class promedio          {
  public static void main (String arg[])throws Exception{
  // con el DataInputStream puedo ingresar datos por teclado
  DataInputStream entrada=new DataInputStream(System.in);
      int X=0;
       {String nombre="";
 System.out.println("ingrese su nombre:");
  nombre=(entrada.readLine());



   System.out.println("      a cuantas notas le desea sacar promedio ");
      X=Integer.parseInt(entrada.readLine());

   int Pro=0;
   int suma=0;
   int i;
    for(i=0;i<X;i++){
     System.out.println("digite sus notas ");
     // declaro una variable y le doy la orden que me almacene lo que se ingresa por teclado
     int edad=Integer.parseInt(entrada.readLine());
     suma=edad+suma;  
    }
      Pro=suma/i;
       System.out.println("su  nombre es:"+nombre);
    
      System.out.println("la suma de sus notas es"+suma);
      System.out.println(" ");
      System.out.println("el promedio es de: "+Pro);
  }

 }
 }

MATRIZ

MATRIZ EN  DIAGONAL
import java.io.*;
class matris
{
 public static void main (String arg[])
 {
  float A [][]=new float [3][3];
  for (int i=0;i<4;i++)
  {
   for (int t=0;t<4;t++)
   {
    if(i==t)
    {
     A[i][t]=5;
    }
    else
    {
     A[i][t]=0;
    }
    System.out.println(A[i][t]);
 
 
 
   }
  }
 }
}













MATRICES
import java.io.*;
class vector
{
 public static void main (String arg[])
 {
  float P=0;
  float Q=3;
  float mul;
  float A [][]=new float [3][3];
  float B [][]=new float [3][3];
  for (int i=0;i<4;i++)
  {
   for (int t=0;t<4;t++)
   {
    P=Q;
    mul=P*P;
 
    A[i][t]=mul;
    System.out.println(A[i][t]);
    Q=Q+1;
 
   }
  }
 }
}

PROGRAMA DE ORDENAMIENTO

import java.io.*;
 class numeros
{
 public static void main(String arg [] )throws Exception
 {
  DataInputStream Entrada = new DataInputStream (System.in);
 
  int Z=0;
 
  int F=0;
       int j=1;
       int k=0;
       int aux;
 
  System.out.println("cuantos numero ordenara");
  System.out.println("");
  Z=Integer.parseInt (Entrada.readLine());
  System.out.println("");
 
  int num[]=new int[Z];
 
 
  for(int i=0;i<Z;i++)
  {
   System.out.println("ingrese numeros");
   num[i]=Integer.parseInt (Entrada.readLine());
  
  
  }
 
  System.out.println("");
  System.out.println("numeros sin ordenar");
  System.out.println("");
 
  for(int i=0;i<Z;i++)
  {
   System.out.print(num[i]+"    ");
  
  }
        System.out.println(""); 
  while (j<Z && F==0)
  {
   F=1;
         k=0;
        
         while (k<(Z-j))
         {
          if(num[k]>num[k+1])
          {
           aux=num[k];
            num[k]=num[k+1];
            num[k+1]=aux;
            F=0;
          }
          k=k+1;
         }
         j=j+1;
  }
 
  System.out.println("");
  System.out.println("");
  System.out.println("numeros ya ordenados");
  System.out.println("");
  System.out.println("");
  System.out.println("");
 
  for(int i=0;i<Z;i++)
  {
  
   System.out.print(num[i]+"    ");
  
 
  }
  System.out.println("");
 
 }
}






SHELL

import java.io.*;
public class shell{
public static void main (String arg[] )throws Exception
{
 DataInputStream entrada=new DataInputStream (System.in);
    int Z;
    System.out.println("CANTIDAD DE NUMEROS A ORDENAR");
    Z=Integer.parseInt(entrada.readLine());
 int A[]=new int [Z];
 for(int i=0;i<Z;i++)
 {
  System.out.println("INGRESE NUMERO");
  A[i
   ]=Integer.parseInt(entrada.readLine());
 }

   int k=A.length/2;
   while (k>=1)
   {
     for (int subarray = 0; subarray < k; subarray++)
     {
       for (int i = k+subarray; i < A.length; i += k)
       {
         int v = A[i];
         int j = i - k;
         while (j >= 0 && A[j] > v)
         {
           A[j + k] = A[j];
           j-=k;
         }
         A[j + k] = v;
       }
     }
  
   k /= 2;
   
   }
   System.out.println(" ");
 
  
   for(int i=0;i<Z;i++)
 {

  System.out.print(" "+A[i]);
 
 }
   }
}

ORDENAMIENTO

EL ordenamiento es un de los procedimientos más comunes y útiles en el procesamiento de datos, es la clasificación u ordenación de los mismos. Se considera ordenar al proceso de reorganizar un conjunto dado de objetos en una secuencia determinada. Cuando se analiza un método de ordenación, hay que determinar cuántas comparaciones e intercambios se realizan para el caso más favorable, para el caso medio y para el caso más desfavorable.


METODO RAPIDO

Si bien el método de la burbuja era considerado como el peor método de ordenación simple o menos eficiente, el método Quicksort basa su estrategia en la idea intuitiva de que es más fácil ordenar una gran estructura de datos subdividiéndolas en otras más pequeñas introduciendo un orden relativo entre ellas. En otras palabras, si dividimos el array a ordenar en dos subarrays de forma que los elementos del subarray inferior sean más pequeños que los del subarray superior, y aplicamos el método reiteradamente, al final tendremos el array inicial totalmente ordenado. Existen además otros métodos conocidos, el de ordenación por montículo y el de shell.

Metodo de burbrja

Es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar

Selección.

Los métodos de ordenación por selección se basan en dos principios básicos:
Seleccionar el elemento más pequeño (o más grande) del arreglo.
Colocarlo en la posición más baja (o más alta) del arreglo.
A diferencia del método de la burbuja, en este método el elemento más pequeño (o más grande) es el que se coloca en la posición final que le corresponde.



Inserción.
El fundamento de este método consiste en insertar los elementos no ordenados del arreglo en subarreglos del mismo que ya estén ordenados. Dependiendo del método elegido para encontrar
es una manera muy natural de ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria. Requiere O(n²) operaciones para ordenar una lista de n elementos.

Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Después, cuando hay k elementos ordenados de menor a mayor, se toma el elemento k+1 y se compara con todos los elementos ya ordenados, deteniéndose cuando se encuentra un elemento menor (todos los elementos mayores han sido desplazados una posición a la derecha). En este punto se inserta el elemento k+1 debiendo desplazarse los demás elementos.

BUSQUEDAD

Declarar un vector y matriz



declaracion de matriz:

import java.io.*;

class matriz{
public static void main(String alex[])throws Exception{
 DataInputStream entrada = new DataInputStream(System.in);
System.out.print("ingrese tamaño de la matriz");
int x=Integer.parseInt(entrada.readLine());
int matriz[][];
matriz = new int[4][4];
//for (int x=0; x < matrix.length; x++) {
// for (int y=0; y < matriz[x].length; y++) {
// System.out.println (matriz[x][y]);
}
}

declaracion de vectores:

import java.io.*;

class vector{
public static void main(String arg[])throws Exception{
DataInputStream entrada = newDataInputStream(System.in);
System.out.print("ingrese tamaño del vector");
int x=Integer.parseInt(entrada.readLine());
double vectora1 []=new double [];
double vectorb1 []=new double [];
for(int i=0;i<x;i++){
System.out.print("ingrese los valores del vector a");
vectora1[i]=Double.parseDouble(entrada.readLine());
}
for(int i=0;i<x;i++){
System.out.print("ingrese los valores del vectorb");
vectorb1[i]=Double.parseDouble(entrada.readLine());
}

BUSQUEDA

La búsqueda es aquella que está diseñada para localizar un elemento con ciertas propiedades dentro de una estructura de datos; por ejemplo, ubicar el registro correspondiente a cierta persona en una base de datos, o la mejor movida en una partida de ajedrez.La variante más simple del problema es la búsqueda de un número en un vector.



 TIPOS DE BUSQUEDA

Búsqueda secuencial


Se utiliza cuando el vector no está ordenado o no puede ser ordenado previamente. Consiste en buscar el elemento comparándolo secuencialmente con cada elemento del array hasta encontrarlo, o hasta que se llegue al final. La existencia se puede asegurar cuando el elemento es localizado, pero no podemos asegurar la no existencia hasta no haber analizado todos los elementos del array.



Búsqueda binaria (dicotómica)


Se utiliza cuando el vector en el que queremos determinar la existencia de un elemento está previamente ordenado. Este algoritmo reduce el tiempo de búsqueda considerablemente, ya que disminuye exponencialmente el número de interaciones necesarias.


Para implementar este algoritmo se compara el elemento a buscar con un elemento cualquiera del array (normalmente el elemento central): si el valor de éste es mayor que el del elemento buscado se repite el procedimiento en la parte del array que va desde el inicio de éste hasta el elemento tomado, en caso contrario se toma la parte del array que va desde el elemento tomado hasta el final. De esta manera obtenemos intervalos cada vez más pequeños, hasta que se obtenga un intervalo indivisible. Si el elemento no se encuentra dentro de este último entonces se deduce que el elemento buscado no se encuentra en todo el array.

CODIGO DE PROGRAMACION

CREAR UN PROGRAMA CON UN FOR, WHILE, Y DO WHILE QUE ME MUESTRE LOS NUMEROS PARES O IMPARES DE EL 1 AL 100 Y CREAR LAS TABLAS DE MULTIPLICAR CON DOS FOR ANIDADOS.

FOR:

import java.io.*;
class pares{
public static void main(String args[]){
System.out.println("\nNumeros impares del 100 al 1:\n");
for(int i=100 ; i>1 ; i-- ){
if ( i % 2 == 0 )
System.out.print(i+",");
} // fin del for
System.out.print("\n\nLo mismo pero de otra forma en el codigo. \n\n");
for(int i=100 ; i>1 ; i-=2 )
System.out.print(i+",");
System.out.print("\n");
} // fin de main
} // fin de la clase pares
 
 
WHILE:

import java.io.*;
class pares im{
public static void main(String [] args){
BufferedReader entrada=new BufferedReader(new InputStreamReader(System.in));
long numero;
String e= new String("");
try{
System.out.println("Escriba el numero que desea evaluar");
while(true)
{
System.out.print("numero :");
e=entrada.readLine();
numero=Integer.parseInt(e);
if(numero%2!=0)
System.out.println("\nEs impar");
else
System.out.println("\nEs Par");
}
}
catch(IOException er){
System.out.println(er);
}
}
}



DO WHILE:

import java.*;
class IMPAR
{
public static void main (String Args []){
// DataInputStream entrada=new DataInputStream(System.in);
int par=0;
int imp=0;
int res=0;
int i=0;
int t=0;
do
{
if(i%2==0)
{
System.out.println("pares"+" "+i);
}
i++;
}
while (i<101);
do
{
if(t%2==0)
{
}
else
{
System.out.println("impares"+" "+t);
}
t++;
}
while (t<101);
}
}

TABLAS:

import java.*;
public class TABLAS {
public static void main(String arg [])throws Exception{
int Resultado=0;
for (int x=1;x<=10;x++){
System.out.println ("tabla" );
for (int y=1;y<=10;y++){
Resultado=x*y;
System.out.println (" Tabla " + x + " * "+y+" = "+ Resultado);
}
}
}
}

ARREGLOS

Los arreglos son un conjunto de datos o una estructura de datos homogéneos que se encuentran ubicados en forma consecutiva en la memoria RAM ( sirve para almacenar datos en forma temporal).En si los arreglos puede definirse como un grupo o una colección finita, homogénea y ordenada de elementos.


ARREGLOS UNIDIMENSIONALES

Un arreglo es un conjunto finito y ordenado de elementos homogéneos. La propiedad ordenado significa que el primer elemento, el segundo, el tercero,el enésimo puede ser identificado. La homogeneidad implica que todos los elementos del arreglo son datos del mismo tipo.Un vector o arreglo unidimensional consta de un elementos que pueden representarse como:

A [1] A[2] A[3] ... A[i] ... A[n}

Nótese que todos los elementos comparten el mismo identificador (A en este caso) mientras
que el subíndice identifica a cada elemento individual.Al número de elementos de un vector se le denomina rango del vector.
Los vectores se almacenan en la memoria central del computador en un orden adyacente de
posiciones de memoria sucesivas. Cada elemento de un vector se puede procesar como si
fuera una variable simple que ocupa una posición de memoria dada, de manera tal que cada
elemento del vector es accesible directamente.


ARREGLOS BIDIMENSIONALES

Los arreglos bidimensionales se usan para representar datos que pueden verse como una tabla con filas y
columnas. La primera dimensión del arreglo representa las columnas, cada elemento contiene un valor y cada dimensión representa una relación
La representación en memoria se realiza de dos formas : almacenamiento por columnas o por renglones.
Para determinar el número total de elementos en un arreglo bidimensional usaremos las siguientes fórmulas:

RANGO DE RENGLONES (R1) = Ls1 − (Li1+1)
RANGO DE COLUMNAS (R2) = Ls2 − (Li2+1)
No. TOTAL DE COMPONENTES = R1 * R2


ARREGLOS MULTIDIMENSIONALES

Este también es un tipo de dato estructurado, que está compuesto por un dimensiones. Para hacer referencia acada componente del arreglo es necesario utilizar un índices, uno para cada dimensión
Para determinar el número de elementos en este tipo de arreglos se usan las siguientes fórmulas:
RANGO (Ri) = lsi − (lii + 1)
No. TOTAL DE ELEMENTOS = R1 * R2* R3 * ...* Rn
donde:
i = 1 ... n
para i desde 1 hasta N haz
x<−−arreglo[i]


ESCRITURA
Consiste en asignarle un valor a cada elemento del arreglo.
La escritura se realiza de la siguiente manera:
para i desde 1 hasta N haz
arreglo[i]<−−x

ASIGNACION
No es posible asignar directamente un valor a todo el arreglo, por lo que se realiza de la manera siguiente:
para i desde 1 hasta N haz
arreglo[i]<−−algún_valor

ACTUALIZACION
Dentro de esta operación se encuentran las operaciones de eliminar, insertar y modificar datos. Para realizar
este tipo de operaciones se debe tomar en cuenta si el arreglo está o no ordenado.

Ejemplos

CONDICIONAL

• If-Then :

If A > 10 Then A = A + 1 : B = B + A : C = C + B

INTERACTIVAS

• While:

int num;
num = 0;
while (num<=10)
{
printf(“Repetición numero %d”, num);
num = num + 1;
}

• Do While :

while (condición){
sentencias a ejecutar
}
Un ejemplo de código donde se utiliza este bucle se puede ver a continuación.
var color = ""
while (color != "rojo")
color = dame un color
}

• For:

for(x=1;x⇐10;x=x+1)





JERARQUIAS

• Swicth:

switch (expresión)
{
case cte_1: sentencia_11;
sentencia_12;

case cte_2: sentencia_21;
sentencia_22;

case cte_n: sentencia_n;
sentencia_n;

}

Estructuras Basicas

• CONDICIONAL

if -then : Es la ejecución condicional de una sentencia en un programa.que significa Si (IF) y se da una condición determinad,Entonces (THEN) y se ejecuta una instrucción

• INTERACTIVAS

while : Es una estructura de repetición es decir,Permite al programador que se repita una acción las veces que se desee Mientras la condición se mantenga verdadera

do while: El do while tiene la misma esencia del bluce while con la diferencia que este ejecuta la acción antes de comprovar la condición

for: Es un ciclo para repetir una serie de secuencias de instrucciones empezando desde (cero) 0 hasta 10 (Diez) o las veces que se desee aun mentando en cada vuelta o repetición una sola vez

• JERARQUÍAS

Switch: Es la estructura de control que se emplea en programacion a la que le pertenecen el if,else o until  entre otras .

en programacion es mas usado el if que switch pero cuando se va a utilizar ciertas cantidades de acciones es recomendado o se utiliza mas el swicth anidado por medio de ifs.