viernes, 19 de noviembre de 2010
EJERCICIO DE PILAS ******PAQUETES*********
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.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.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.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;
}
}
EJERCICIO 2 DE ARBOLES
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.WindowConstants;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
class PruebaJTree
{
public static void main(String[] args)
{
// Construccion del arbol
DefaultMutableTreeNode abuelo = new DefaultMutableTreeNode("abuelos ");
DefaultTreeModel modelo = new DefaultTreeModel(abuelo);
JTree tree = new JTree(modelo);
// Construccion de los datos del arbol
DefaultMutableTreeNode padre = new DefaultMutableTreeNode("padre");
DefaultMutableTreeNode tio = new DefaultMutableTreeNode("tio");
DefaultMutableTreeNode tia = new DefaultMutableTreeNode("tita");
modelo.insertNodeInto(padre, abuelo, 0);
modelo.insertNodeInto(tio, abuelo, 1);
modelo.insertNodeInto(tia, abuelo, 2);
DefaultMutableTreeNode hijo = new DefaultMutableTreeNode("hijo");
DefaultMutableTreeNode hija = new DefaultMutableTreeNode("hija");
modelo.insertNodeInto(hijo, padre, 0);
modelo.insertNodeInto(hija, padre, 1);
DefaultMutableTreeNode prima = new DefaultMutableTreeNode("prima");
DefaultMutableTreeNode primo = new DefaultMutableTreeNode("primo");
modelo.insertNodeInto(prima, tio, 0);
modelo.insertNodeInto(primo, tio, 1);
// Construccion y visualizacion de la ventana
JFrame v = new JFrame();
JScrollPane scroll = new JScrollPane(tree);
v.getContentPane().add(scroll);
v.pack();
v.setVisible(true);
v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
}
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.WindowConstants;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
class PruebaJTree
{
public static void main(String[] args)
{
// Construccion del arbol
DefaultMutableTreeNode abuelo = new DefaultMutableTreeNode("abuelos ");
DefaultTreeModel modelo = new DefaultTreeModel(abuelo);
JTree tree = new JTree(modelo);
// Construccion de los datos del arbol
DefaultMutableTreeNode padre = new DefaultMutableTreeNode("padre");
DefaultMutableTreeNode tio = new DefaultMutableTreeNode("tio");
DefaultMutableTreeNode tia = new DefaultMutableTreeNode("tita");
modelo.insertNodeInto(padre, abuelo, 0);
modelo.insertNodeInto(tio, abuelo, 1);
modelo.insertNodeInto(tia, abuelo, 2);
DefaultMutableTreeNode hijo = new DefaultMutableTreeNode("hijo");
DefaultMutableTreeNode hija = new DefaultMutableTreeNode("hija");
modelo.insertNodeInto(hijo, padre, 0);
modelo.insertNodeInto(hija, padre, 1);
DefaultMutableTreeNode prima = new DefaultMutableTreeNode("prima");
DefaultMutableTreeNode primo = new DefaultMutableTreeNode("primo");
modelo.insertNodeInto(prima, tio, 0);
modelo.insertNodeInto(primo, tio, 1);
// Construccion y visualizacion de la ventana
JFrame v = new JFrame();
JScrollPane scroll = new JScrollPane(tree);
v.getContentPane().add(scroll);
v.pack();
v.setVisible(true);
v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
}
EJERCICIO 1 DE ARBOLES
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.WindowConstants;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellRenderer;
public class PruebaJTree2
{
/**
* Ejemplo sencillo de uso de JTree
*
* @param args Argumentos de linea de comandos. Se ignoran.
*/
public static void main(String[] args)
{
// Construccion del arbol
DefaultMutableTreeNode abuelos = new DefaultMutableTreeNode("Herminda y Josè ");
DefaultTreeModel modelo = new DefaultTreeModel(abuelos);
JTree tree = new JTree(modelo);
// Cambiamos los iconos
DefaultTreeCellRenderer render= (DefaultTreeCellRenderer)tree.getCellRenderer();
render.setLeafIcon(new ImageIcon("d:/hijo.jpg"));
render.setOpenIcon(new ImageIcon("d:/pa.jpg"));
render.setClosedIcon(new ImageIcon("d:/pa.jpg"));
// Construccion de los datos del arbol
DefaultMutableTreeNode martha = new DefaultMutableTreeNode("Martha");
DefaultMutableTreeNode uriel = new DefaultMutableTreeNode("Uriel");
DefaultMutableTreeNode rubiel = new DefaultMutableTreeNode("Rubiel");
DefaultMutableTreeNode antonio = new DefaultMutableTreeNode("Antonio");
DefaultMutableTreeNode hilde = new DefaultMutableTreeNode("Hilde");
DefaultMutableTreeNode jamir = new DefaultMutableTreeNode("Jamir");
modelo.insertNodeInto(martha, abuelos, 0);
modelo.insertNodeInto(uriel, abuelos, 1);
modelo.insertNodeInto(rubiel, abuelos, 2);
modelo.insertNodeInto(antonio, abuelos,3);
modelo.insertNodeInto(hilde, abuelos, 4);
modelo.insertNodeInto(jamir, abuelos, 5);
DefaultMutableTreeNode diana = new DefaultMutableTreeNode("Diana");
DefaultMutableTreeNode maykool = new DefaultMutableTreeNode("Maykool");
DefaultMutableTreeNode jorge = new DefaultMutableTreeNode("Jorge");
modelo.insertNodeInto(diana, martha, 0);
modelo.insertNodeInto(maykool, martha, 1);
modelo.insertNodeInto(jorge, martha, 2);
DefaultMutableTreeNode andres = new DefaultMutableTreeNode("Andres");
modelo.insertNodeInto(andres, uriel, 0);
DefaultMutableTreeNode andrea = new DefaultMutableTreeNode("Andrea");
DefaultMutableTreeNode pedro = new DefaultMutableTreeNode("Pedro");
modelo.insertNodeInto(andrea, rubiel, 0);
modelo.insertNodeInto(pedro, rubiel, 1);
DefaultMutableTreeNode camilo = new DefaultMutableTreeNode("Camilo");
DefaultMutableTreeNode cristrian = new DefaultMutableTreeNode("Cristian");
DefaultMutableTreeNode gisel = new DefaultMutableTreeNode("Gisel");
modelo.insertNodeInto(camilo, jamir, 0);
modelo.insertNodeInto(cristrian, jamir, 1);
modelo.insertNodeInto(gisel, jamir, 1);
DefaultMutableTreeNode mauricio = new DefaultMutableTreeNode("Mauricio");
modelo.insertNodeInto(mauricio, camilo, 0);
// Construccion y visualizacion de la ventana
JFrame v = new JFrame();
JScrollPane scroll = new JScrollPane(tree);
v.getContentPane().add(scroll);
v.pack();
v.setVisible(true);
v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
}
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.WindowConstants;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeCellRenderer;
public class PruebaJTree2
{
/**
* Ejemplo sencillo de uso de JTree
*
* @param args Argumentos de linea de comandos. Se ignoran.
*/
public static void main(String[] args)
{
// Construccion del arbol
DefaultMutableTreeNode abuelos = new DefaultMutableTreeNode("Herminda y Josè ");
DefaultTreeModel modelo = new DefaultTreeModel(abuelos);
JTree tree = new JTree(modelo);
// Cambiamos los iconos
DefaultTreeCellRenderer render= (DefaultTreeCellRenderer)tree.getCellRenderer();
render.setLeafIcon(new ImageIcon("d:/hijo.jpg"));
render.setOpenIcon(new ImageIcon("d:/pa.jpg"));
render.setClosedIcon(new ImageIcon("d:/pa.jpg"));
// Construccion de los datos del arbol
DefaultMutableTreeNode martha = new DefaultMutableTreeNode("Martha");
DefaultMutableTreeNode uriel = new DefaultMutableTreeNode("Uriel");
DefaultMutableTreeNode rubiel = new DefaultMutableTreeNode("Rubiel");
DefaultMutableTreeNode antonio = new DefaultMutableTreeNode("Antonio");
DefaultMutableTreeNode hilde = new DefaultMutableTreeNode("Hilde");
DefaultMutableTreeNode jamir = new DefaultMutableTreeNode("Jamir");
modelo.insertNodeInto(martha, abuelos, 0);
modelo.insertNodeInto(uriel, abuelos, 1);
modelo.insertNodeInto(rubiel, abuelos, 2);
modelo.insertNodeInto(antonio, abuelos,3);
modelo.insertNodeInto(hilde, abuelos, 4);
modelo.insertNodeInto(jamir, abuelos, 5);
DefaultMutableTreeNode diana = new DefaultMutableTreeNode("Diana");
DefaultMutableTreeNode maykool = new DefaultMutableTreeNode("Maykool");
DefaultMutableTreeNode jorge = new DefaultMutableTreeNode("Jorge");
modelo.insertNodeInto(diana, martha, 0);
modelo.insertNodeInto(maykool, martha, 1);
modelo.insertNodeInto(jorge, martha, 2);
DefaultMutableTreeNode andres = new DefaultMutableTreeNode("Andres");
modelo.insertNodeInto(andres, uriel, 0);
DefaultMutableTreeNode andrea = new DefaultMutableTreeNode("Andrea");
DefaultMutableTreeNode pedro = new DefaultMutableTreeNode("Pedro");
modelo.insertNodeInto(andrea, rubiel, 0);
modelo.insertNodeInto(pedro, rubiel, 1);
DefaultMutableTreeNode camilo = new DefaultMutableTreeNode("Camilo");
DefaultMutableTreeNode cristrian = new DefaultMutableTreeNode("Cristian");
DefaultMutableTreeNode gisel = new DefaultMutableTreeNode("Gisel");
modelo.insertNodeInto(camilo, jamir, 0);
modelo.insertNodeInto(cristrian, jamir, 1);
modelo.insertNodeInto(gisel, jamir, 1);
DefaultMutableTreeNode mauricio = new DefaultMutableTreeNode("Mauricio");
modelo.insertNodeInto(mauricio, camilo, 0);
// Construccion y visualizacion de la ventana
JFrame v = new JFrame();
JScrollPane scroll = new JScrollPane(tree);
v.getContentPane().add(scroll);
v.pack();
v.setVisible(true);
v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
}
viernes, 5 de noviembre de 2010
EJERCICIO COLAS
import javax.swing.*;
public class ColaJava {
static Cola accion=new Cola();
public static void main(String[] args) {
int opc=0;
while(true){
opc=Integer.parseInt(JOptionPane.showInputDialog(null,
"---------------------------------------\n" +
"MANEJO DE COLA EN JAVA\n" +
"---------------------------------------\n" +
"1. Introducir dato\n" +
"2. Ver datos introducidos\n" +
"3. Salir\n" +
"---------------------------------------\n" +
"Teclea el numero de la accion a relizar:"
));
switch(opc){
case 1: accion.Introducir();
break;
case 2: accion.Mostrar();
break;
case 3: accion.Salir();
break;
default: JOptionPane.showMessageDialog(null,"No se realizo ninguna accion\nOpcion no valida");
break;
}
}
}
}
class Cola{
int tamaño=3;
String cola[]=new String [tamaño];
int frente=0;
int ultimo=-1;
public void Introducir(){
if(ultimo==cola.length-1){
JOptionPane.showMessageDialog(null,"No se realizo ninguna accion...");
JOptionPane.showMessageDialog(null,"La cola esta llena\nSaca un dato para poder introducir uno nuevo");
}
else{
ultimo++;
cola[ultimo]=JOptionPane.showInputDialog(null,"Que dato deseas introducir:");
}
}
public void Salir(){
if(ultimo==-1){
JOptionPane.showMessageDialog(null,"No se realizo ninguna accion ");
JOptionPane.showMessageDialog(null,"La cola esta vacia\nIntroduce un nuevo dato para poder sacar uno");
}
else{
JOptionPane.showMessageDialog(null,"Se saco el dato ( "+cola[frente]+" )");
for(int i=frente;i
}
cola[ultimo]=null;
ultimo--;
}
}
public void Mostrar(){
if(ultimo==-1){
JOptionPane.showMessageDialog(null,"La cola esta vacia\nNo hay datos que mostrar ");
}
else{
String mostrar="";
for(int i=frente;i<=ultimo;i++){
mostrar=mostrar+cola[i];
}
JOptionPane.showMessageDialog(null,"El dato frente es: "+cola[frente]);
JOptionPane.showMessageDialog(null,"El dato ultimo es: "+cola[ultimo]);
JOptionPane.showMessageDialog(null,"Los datos almacenados son:\n"+mostrar);
}
}
}
public class ColaJava {
static Cola accion=new Cola();
public static void main(String[] args) {
int opc=0;
while(true){
opc=Integer.parseInt(JOptionPane.showInputDialog(null,
"---------------------------------------\n" +
"MANEJO DE COLA EN JAVA\n" +
"---------------------------------------\n" +
"1. Introducir dato\n" +
"2. Ver datos introducidos\n" +
"3. Salir\n" +
"---------------------------------------\n" +
"Teclea el numero de la accion a relizar:"
));
switch(opc){
case 1: accion.Introducir();
break;
case 2: accion.Mostrar();
break;
case 3: accion.Salir();
break;
default: JOptionPane.showMessageDialog(null,"No se realizo ninguna accion\nOpcion no valida");
break;
}
}
}
}
class Cola{
int tamaño=3;
String cola[]=new String [tamaño];
int frente=0;
int ultimo=-1;
public void Introducir(){
if(ultimo==cola.length-1){
JOptionPane.showMessageDialog(null,"No se realizo ninguna accion...");
JOptionPane.showMessageDialog(null,"La cola esta llena\nSaca un dato para poder introducir uno nuevo");
}
else{
ultimo++;
cola[ultimo]=JOptionPane.showInputDialog(null,"Que dato deseas introducir:");
}
}
public void Salir(){
if(ultimo==-1){
JOptionPane.showMessageDialog(null,"No se realizo ninguna accion ");
JOptionPane.showMessageDialog(null,"La cola esta vacia\nIntroduce un nuevo dato para poder sacar uno");
}
else{
JOptionPane.showMessageDialog(null,"Se saco el dato ( "+cola[frente]+" )");
for(int i=frente;i
}
cola[ultimo]=null;
ultimo--;
}
}
public void Mostrar(){
if(ultimo==-1){
JOptionPane.showMessageDialog(null,"La cola esta vacia\nNo hay datos que mostrar ");
}
else{
String mostrar="";
for(int i=frente;i<=ultimo;i++){
mostrar=mostrar+cola[i];
}
JOptionPane.showMessageDialog(null,"El dato frente es: "+cola[frente]);
JOptionPane.showMessageDialog(null,"El dato ultimo es: "+cola[ultimo]);
JOptionPane.showMessageDialog(null,"Los datos almacenados son:\n"+mostrar);
}
}
}
viernes, 15 de octubre de 2010
***LISTAS CALIFICACIONES***
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;
}
}
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;
}
}
***LISTAS***
import java.awt.*;
import java.awt.event.*;
public class listas extends Frame
{
List lista=new List(0,true);
Label text=new Label("Alumnas");
public listas()
{
super("ELEGIR ALUMNO A EVALUAR");
lista.add("Eliana");
lista.add("Diana");
lista.add("mauricio");
lista.add("Bartolomeo");
lista.add("Marco");
lista.add("Montefalcone ");
lista.add("Sara");
lista.add("maria ");
lista.add("ana");
lista.add("juan ");
add(lista,BorderLayout.CENTER);
add(text,BorderLayout.SOUTH);
addWindowListener(new listeWindowListener());
setSize(350,100);
setResizable(false);
show();
}
public static void main(String [] arg)
{
new listas();
}
class listeWindowListener implements WindowListener
{
public void windowActivated(WindowEvent e)
{}
public void windowClosed(WindowEvent e)
{}
public void windowClosing(WindowEvent e)
{
String[] s=lista.getSelectedItems();
int i=0;
System.out.println(" ");
try
{
while (true)
{
System.out.println(s[i++]);
}
}
catch (ArrayIndexOutOfBoundsException er)
{System.out.println("Qué lo pases bien...");}
System.exit(0);
}
public void windowDeactivated(WindowEvent e)
{}
public void windowDeiconified(WindowEvent e)
{}
public void windowIconified(WindowEvent e)
{}
public void windowOpened(WindowEvent e)
{}
}
{
}
}
import java.awt.event.*;
public class listas extends Frame
{
List lista=new List(0,true);
Label text=new Label("Alumnas");
public listas()
{
super("ELEGIR ALUMNO A EVALUAR");
lista.add("Eliana");
lista.add("Diana");
lista.add("mauricio");
lista.add("Bartolomeo");
lista.add("Marco");
lista.add("Montefalcone ");
lista.add("Sara");
lista.add("maria ");
lista.add("ana");
lista.add("juan ");
add(lista,BorderLayout.CENTER);
add(text,BorderLayout.SOUTH);
addWindowListener(new listeWindowListener());
setSize(350,100);
setResizable(false);
show();
}
public static void main(String [] arg)
{
new listas();
}
class listeWindowListener implements WindowListener
{
public void windowActivated(WindowEvent e)
{}
public void windowClosed(WindowEvent e)
{}
public void windowClosing(WindowEvent e)
{
String[] s=lista.getSelectedItems();
int i=0;
System.out.println(" ");
try
{
while (true)
{
System.out.println(s[i++]);
}
}
catch (ArrayIndexOutOfBoundsException er)
{System.out.println("Qué lo pases bien...");}
System.exit(0);
}
public void windowDeactivated(WindowEvent e)
{}
public void windowDeiconified(WindowEvent e)
{}
public void windowIconified(WindowEvent e)
{}
public void windowOpened(WindowEvent e)
{}
}
{
}
}
***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
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
if(actual.equals(Pila[i])){
Pila[i]=nuevo;
break;
}else{
System.out.println("Elemento no encontrado :(");
}
}
Menu();
}
}
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
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
if(actual.equals(Pila[i])){
Pila[i]=nuevo;
break;
}else{
System.out.println("Elemento no encontrado :(");
}
}
Menu();
}
}
martes, 5 de octubre de 2010
viernes, 24 de septiembre de 2010
sábado, 11 de septiembre de 2010
jueves, 9 de septiembre de 2010
domingo, 5 de septiembre de 2010
METODOS DE ORDENAMIENTO
ENTRADAS DE ORDENAMIENTO
1. Ordenamiento de burbuja: 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.
EJEMPLO:
//Ordenamiento por Burbuja
// by ramses2999
public static int[] OrdenarBurbuja(int[] n){
int temp;
int t = n.length;
for (int i = 1; i < t; i++) {
for (int k = t- 1; k >= i; k--) {
if(n[k] < n[k-1]){
temp = n[k];
n[k] = n[k-1];
n[k-1]= temp;
}//fin if
}// fin 2 for
}//fin 1 for
return n;
}//fin
2
3. El ordenamiento Shell (Shell sort en inglés) es un algoritmo de ordenamiento. El método se denomina Shell en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso. Un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(nlog2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n). Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución.
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones: El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
public static void shellSort(int[] a) {
for ( int increment = a.length / 2;
increment > 0;
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) {
for (int i = increment; i < a.length; i++) {
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) {
int temp = a[j];
a[j] = a[j - increment];
a[j - increment] = temp;
}
}
}
}
4. El algoritmo de ordenamiento por mezcla (merge sort en inglés) es un algoritmo de ordenamiento externo estable basado en la técnica divide y vencerás. Es de complejidad O(n log n).
Conceptualmente, el ordenamiento por mezcla funciona de la siguiente manera:
1. Si la longitud de la lista es 0 ó 1, entonces ya está ordenada. En otro caso:
2. Dividir la lista desordenada en dos sublistas de aproximadamente la mitad del tamaño.
3. Ordenar cada sublista recursivamente aplicando el ordenamiento por mezcla.
4. Mezclar las dos sublistas en una sola lista ordenada.
El ordenamiento por mezcla incorpora dos ideas principales para mejorar su tiempo de ejecución:
1. Una lista pequeña necesitará menos pasos para ordenarse que una lista grande.
2. Se necesitan menos pasos para construir una lista ordenada a partir de dos listas también ordenadas, que a partir de dos listas desordenadas. Por ejemplo, sólo será necesario entrelazar cada lista una vez que están ordenadas.
public class MergeSort{
private int A[];
public int[] OrdenaMerge(int[] L) {
int n = L.length;
if (n > 1){
int m = (int) (Math.ceil(n/2.0));
int [] L1 = new int[m];
int [] L2 = new int[n-m];
for (int i = 0; i < m; i++){
L1[i] = L[i];
}
for (int i = m; i < n; i++){
L2[i-m] = L[i];
}
L = merge(OrdenaMerge(L1), OrdenaMerge(L2));
}
return L;
}
public int[] eliminar(int [] l){
int [] L = new int[l.length-1];
for(int i = 1; i < l.length; i++){
L[i-1] = l[i];
}
return L;
}
public int[] merge(int[] L1, int[] L2) {
int[] L = new int[L1.length+L2.length];
int i = 0;
while ((L1.length != 0) && (L2.length != 0)) {
if (L1[0] < L2[0]){
L[i++] = L1[0];
L1 = eliminar(L1);
if (L1.length == 0){
while (L2.length != 0) {
L[i++] = L2[0];
L2 = eliminar(L2);
}
}
}
else{
L[i++] = L2[0];
L2 = eliminar(L2);
if (L2.length == 0) {
while (L1.length != 0) {
L[i++] = L1[0];
L1 = eliminar(L1);
}
}
}
}
return L;
}
public void generarNumeros(){
Random ran = new Random();
int x;
for(int i = 0; i < A.length; i++){
x = (int)(ran.nextDouble()*10000);
A[i] = x;
}
}
public void imprimir(){
for(int i = 0; i < A.length; i++){
System.out.println(A[i]);
}
}
public int[] getA(){
return A;
}
public void setA(int []A){
this.A = A;
}
}
1. Ordenamiento de burbuja: 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.
EJEMPLO:
//Ordenamiento por Burbuja
// by ramses2999
public static int[] OrdenarBurbuja(int[] n){
int temp;
int t = n.length;
for (int i = 1; i < t; i++) {
for (int k = t- 1; k >= i; k--) {
if(n[k] < n[k-1]){
temp = n[k];
n[k] = n[k-1];
n[k-1]= temp;
}//fin if
}// fin 2 for
}//fin 1 for
return n;
}//fin
2
Quicksort
Tabla de variables | ||
Nombre | Tipo | Uso |
lista | Cualquiera | Lista a ordenar |
inf | Entero | Elemento inferior de la lista |
sup | Entero | Elemento superior de la lista |
elem_div | El mismo que los elementos de la lista | El elemento divisor |
temp | El mismo que los elementos de la lista | Para realizar los intercambios |
i | Entero | Contador por la izquierda |
j | Entero | Contador por la derecha |
cont | Entero | El ciclo continua mientras cont tenga el valor 1 |
Nombre Procedimiento: OrdRap
Parámetros:
lista a ordenar (lista)
índice inferior (inf)
índice superior (sup)
// Inicialización de variables
1. elem_div = lista[sup];
2. i = inf - 1;
3. j = sup;
4. cont = 1;
// Verificamos que no se crucen los límites
5. if (inf >= sup)
6. retornar;
// Clasificamos la sublista
7. while (cont)
8. while (lista[++i] < elem_div);
9. while (lista[--j] > elem_div);
10. if (i < j)
11. temp = lista[i];
12. lista[i] = lista[j];
13. lista[j] = temp;
14. else
15. cont = 0;
// Copiamos el elemento de división
// en su posición final
16. temp = lista[i];
17. lista[i] = lista[sup];
18. lista[sup] = temp;
// Aplicamos el procedimiento
// recursivamente a cada sublista
19. OrdRap (lista, inf, i - 1);
20. OrdRap (lista, i + 1, sup);
Nota:
- La primera llamada debería ser con la lista, cero (0) y el tamaño de la lista menos 1 como parámetros.
Esta vez voy a cambiar de lista ;-D
5 - 3 - 7 - 6 - 2 - 1 - 4
Comenzamos con la lista completa. El elemento divisor será el 4:
5 - 3 - 7 - 6 - 2 - 1 - 4
Comparamos con el 5 por la izquierda y el 1 por la derecha.
5 - 3 - 7 - 6 - 2 - 1 - 4
5 es mayor que cuatro y 1 es menor. Intercambiamos:
1 - 3 - 7 - 6 - 2 - 5 - 4
Avanzamos por la izquierda y la derecha:
1 - 3 - 7 - 6 - 2 - 5 - 4
3 es menor que 4: avanzamos por la izquierda. 2 es menor que 4: nos mantenemos ahí.
1 - 3 - 7 - 6 - 2 - 5 - 4
7 es mayor que 4 y 2 es menor: intercambiamos.
1 - 3 - 2 - 6 - 7 - 5 - 4
Avanzamos por ambos lados:
1 - 3 - 2 - 6 - 7 - 5 - 4
En este momento termina el ciclo principal, porque los índices se cruzaron. Ahora intercambiamos lista[i] con lista[sup] (pasos 16-18):
1 - 3 - 2 - 4 - 7 - 5 - 6
Aplicamos recursivamente a la sublista de la izquierda (índices 0 - 2). Tenemos lo siguiente:
1 - 3 - 2
1 es menor que 2: avanzamos por la izquierda. 3 es mayor: avanzamos por la derecha. Como se intercambiaron los índices termina el ciclo. Se intercambia lista[i] con lista[sup]:
1 - 2 - 3
Al llamar recursivamente para cada nueva sublista (lista[0]-lista[0] y lista[2]-lista[2]) se retorna sin hacer cambios (condición 5.).Para resumir te muestro cómo va quedando la lista:
Segunda sublista: lista[4]-lista[6]
7 - 5 - 6
5 - 7 - 6
5 - 6 - 7
Para cada nueva sublista se retorna sin hacer cambios (se cruzan los índices).
Finalmente, al retornar de la primera llamada se tiene el arreglo ordenado:
1 - 2 - 3 - 4 - 5 - 6 - 7
Eso es todo. Bastante largo ¿verdad?
Sólo voy a mencionar algunas optimizaciones que pueden mejorar bastante el rendimiento de quicksort:
- Hacer una versión iterativa: Para ello se utiliza una pila en que se van guardando los límites superior e inferior de cada sublista.
- No clasificar todas las sublistas: Cuando el largo de las sublistas va disminuyendo, el proceso se va encareciendo. Para solucionarlo sólo se clasifican las listas que tengan un largo menor que n. Al terminar la clasificación se llama a otro algoritmo de ordenamiento que termine la labor. El indicado es uno que se comporte bien con listas casi ordenadas, como el ordenamiento por inserción por ejemplo. La elección de n depende de varios factores, pero un valor entre 10 y 25 es adecuado.
- Elección del elemento de división: Se elige desde un conjunto de tres elementos: lista[inferior], lista[mitad] y lista[superior]. El elemento elegido es el que tenga el valor medio según el criterio de comparación. Esto evita el comportamiento degenerado cuando la lista está prácticamente ordenada.
- Estabilidad: No es estable.
- Requerimientos de Memoria: No requiere memoria adicional en su forma recursiva. En su forma iterativa la necesita para la pila.
- Tiempo de Ejecución:
- Caso promedio. La complejidad para dividir una lista de n es O(n). Cada sublista genera en promedio dos sublistas más de largo n/2. Por lo tanto la complejidad se define en forma recurrente como:
f(1) = 1
f(n) = n + 2 f(n/2)
La forma cerrada de esta expresión es:
f(n) = n log2n
Es decir, la complejidad es O(n log2n).
- El peor caso ocurre cuando la lista ya está ordenada, porque cada llamada genera sólo una sublista (todos los elementos son menores que el elemento de división). En este caso el rendimiento se degrada a O(n2). Con las optimizaciones mencionadas arriba puede evitarse este comportamiento.
Ventajas:
- Muy rápido
- No requiere memoria adicional.
Desventajas:
- Implementación un poco más complicada.
- Recursividad (utiliza muchos recursos).
- Mucha diferencia entre el peor y el mejor caso.
La mayoría de los problemas de rendimiento se pueden solucionar con las optimizaciones mencionadas arriba (al costo de complicar mucho más la implementación). Este es un algoritmo que puedes utilizar en la vida real. Es muy eficiente. En general será la mejor opción. Intenta programarlo. Mira el código si tienes dudas.
3. El ordenamiento Shell (Shell sort en inglés) es un algoritmo de ordenamiento. El método se denomina Shell en honor de su inventor Donald Shell. Su implementación original, requiere O(n2) comparaciones e intercambios en el peor caso. Un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(nlog2 n) en el peor caso. Esto es mejor que las O(n2) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n). Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución.
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones: El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.
public static void shellSort(int[] a) {
for ( int increment = a.length / 2;
increment > 0;
increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) {
for (int i = increment; i < a.length; i++) {
for (int j = i; j >= increment && a[j - increment] > a[j]; j -= increment) {
int temp = a[j];
a[j] = a[j - increment];
a[j - increment] = temp;
}
}
}
}
4. El algoritmo de ordenamiento por mezcla (merge sort en inglés) es un algoritmo de ordenamiento externo estable basado en la técnica divide y vencerás. Es de complejidad O(n log n).
Conceptualmente, el ordenamiento por mezcla funciona de la siguiente manera:
1. Si la longitud de la lista es 0 ó 1, entonces ya está ordenada. En otro caso:
2. Dividir la lista desordenada en dos sublistas de aproximadamente la mitad del tamaño.
3. Ordenar cada sublista recursivamente aplicando el ordenamiento por mezcla.
4. Mezclar las dos sublistas en una sola lista ordenada.
El ordenamiento por mezcla incorpora dos ideas principales para mejorar su tiempo de ejecución:
1. Una lista pequeña necesitará menos pasos para ordenarse que una lista grande.
2. Se necesitan menos pasos para construir una lista ordenada a partir de dos listas también ordenadas, que a partir de dos listas desordenadas. Por ejemplo, sólo será necesario entrelazar cada lista una vez que están ordenadas.
public class MergeSort{
private int A[];
public int[] OrdenaMerge(int[] L) {
int n = L.length;
if (n > 1){
int m = (int) (Math.ceil(n/2.0));
int [] L1 = new int[m];
int [] L2 = new int[n-m];
for (int i = 0; i < m; i++){
L1[i] = L[i];
}
for (int i = m; i < n; i++){
L2[i-m] = L[i];
}
L = merge(OrdenaMerge(L1), OrdenaMerge(L2));
}
return L;
}
public int[] eliminar(int [] l){
int [] L = new int[l.length-1];
for(int i = 1; i < l.length; i++){
L[i-1] = l[i];
}
return L;
}
public int[] merge(int[] L1, int[] L2) {
int[] L = new int[L1.length+L2.length];
int i = 0;
while ((L1.length != 0) && (L2.length != 0)) {
if (L1[0] < L2[0]){
L[i++] = L1[0];
L1 = eliminar(L1);
if (L1.length == 0){
while (L2.length != 0) {
L[i++] = L2[0];
L2 = eliminar(L2);
}
}
}
else{
L[i++] = L2[0];
L2 = eliminar(L2);
if (L2.length == 0) {
while (L1.length != 0) {
L[i++] = L1[0];
L1 = eliminar(L1);
}
}
}
}
return L;
}
public void generarNumeros(){
Random ran = new Random();
int x;
for(int i = 0; i < A.length; i++){
x = (int)(ran.nextDouble()*10000);
A[i] = x;
}
}
public void imprimir(){
for(int i = 0; i < A.length; i++){
System.out.println(A[i]);
}
}
public int[] getA(){
return A;
}
public void setA(int []A){
this.A = A;
}
}
viernes, 3 de septiembre de 2010
BUSQUEDA
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 maximo 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.
METODOS DE BUSQUEDA.
• Búsqueda secuencial: Este método sirve para cualquier tipo de array. Consiste en ir recorriendo el contenido del array hasta que se encuentre el dato buscado o se llegue al final. Este método no es muy efectivo, puesto que al enfrentarse a un alto numero de información, si el dato buscado no se encuentra al principio, resulta muy lento.
Ej:
PROGRAM Secuencial;
CONST
Max= 20;
TYPE
Rango= 1..max;
Vector= ARRAY [Rango] of integer;
VAR
V: vector;
Num: Integer;
Pos, cont: Rango;
BEGIN
Pos:=0;
Cont:=pos;
Repeat
Cont:=Cont+1;
If v[cont]=num then
Pos:=cont;
Until (cont=max) OR (pos<>0);
END.
• Búsqueda binária: Este método de búsqueda solo puede utilizarse con un array ordenado. Es más eficaz que la búsqueda secuencial. Consiste en un procedimiento recursivo que compara el elemento buscado con el elemento que ocupe la posición media de un rango comprendido entre el principio y el final de la estructura. Si el elemento buscado es mayor que el comparado se redefinirá el rango entre el elemento que ocupa la posición media y el elemento que ocupa el final del rango, sí no, hace lo mismo pero entre la mitad del rango y el principio. Y así hasta dar con el dato buscado o no encontrarlo.
Ej:
PROCEDURE Binaria (Ini, fin, num: Integer; V:Vector; Var pos:Integer);
Var
Med, Rango: Integer;
Begin
Rango:= (Fin-Ini)+1;
Med:=Rango DIV 2;
Med:=Ini+Med;
IF Rango > 1 Then
If V[Med]= num then
Pos:= med
Else
If num> V[Med] then
Binaria (med+1, fin, num, v, pos)
Else
Binaria (Ini, med-1, num, v, pos)
Else
IF num=V[med] then
Pos:=med
Else
Pos:=0;
End;
METODOS DE ORDENACIÓN.
• Método de la burbuja: Consiste en recorrer el array buscando el nº mayor y colocándolo en la última posición. Después la variable que indica la última posición del array decrementaría una posición y es en esta donde colocaríamos el siguiente nº que se considere mayor.
7
8
2
5
Mayor = 8
7
2
5
8
Mayor = 7
2
5
7
8
Ej:
PROCEDURE Burbuja (n:Integer; Var a: Datos);
Var
Aux, i, k:Integer;
Begin
For k:=1 to n-1 do
Begin
i:=1;
Repeat
If a > a then
Begin
Aux:= a;
A:=a;
A:=aux;
End;
I:= i+1;
Until i > n-k;
End;
End;
Una mejora sobre el algoritmo es hacer que salga del bule si no se ha hecho ninguna modificación al recorrer el array.
miércoles, 1 de septiembre de 2010
viernes, 27 de agosto de 2010
ARREGLOS
ARREGLOS
Un tipo arreglo es una lista de datos con un número fijo de componentes, todos del mismo tipo denominado tipo base; los que son referenciados o calificados mediante índices o expresiones ordinales encerradas en corchetes, que actúan como prefijo al identificador del arreglo, siendo su tipo denominado tipo índice.
Características
- Los arrays se crean con el operador new seguido del tipo y número de elementos.
- Se puede acceder al número de elementos de un array con la variable miembro implícita length (por ejemplo, vect.length).
- Se accede a los elementos de un array con los corchetes [] y un índice que varía de 0 a length-1.
- Se pueden crear arrays de objetos de cualquier tipo. En principio un array de objetos es un array de referencias que hay que completar llamando al operador new.
- Los elementos de un array se inicializan al valor por defecto del tipo correspondiente (cero para valores numéricos, la cadena vacía para Strings, false para boolean, null para referencias).
- Como todos los objetos, los arrays se pasan como argumentos a los métodos por referencia.
- Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array como argumento actual en la llamada a un método).
Declaración de Arreglos
- Como otras variables, antes de poder utilizar un array primero se debe declarar.
- int[] arrayDeEnteros;
- La parte int[] de la declaración indica que arrayDeEnteros es un array de enteros.
Otra forma de declararlos es la siguiente:
UNIDIMENSIONALES :
- tipo nombre_array[]=new tipo[nº];
- tipo nombre_array[]={ valores };
BIDIMENSIONALES :
- tipo nombre_array[][]=new tipo[nº][nº];
- tipo nombre_array[][]={valores};
Inicializar un Array.
Para inicializar un array existen 2 maneras:
- int [] arreglo= new int[4] o
- int [] arreglo={100,200,302,400}
- Al momento de inicializar un arreglo de la manera:
int [] arreglo= new int[4]
Cada posición del arreglo sera inicializada con el valor por defecto del tipo de variable.
Un tipo arreglo es una lista de datos con un número fijo de componentes, todos del mismo tipo denominado tipo base; los que son referenciados o calificados mediante índices o expresiones ordinales encerradas en corchetes, que actúan como prefijo al identificador del arreglo, siendo su tipo denominado tipo índice.
Características
- Los arrays se crean con el operador new seguido del tipo y número de elementos.
- Se puede acceder al número de elementos de un array con la variable miembro implícita length (por ejemplo, vect.length).
- Se accede a los elementos de un array con los corchetes [] y un índice que varía de 0 a length-1.
- Se pueden crear arrays de objetos de cualquier tipo. En principio un array de objetos es un array de referencias que hay que completar llamando al operador new.
- Los elementos de un array se inicializan al valor por defecto del tipo correspondiente (cero para valores numéricos, la cadena vacía para Strings, false para boolean, null para referencias).
- Como todos los objetos, los arrays se pasan como argumentos a los métodos por referencia.
- Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array como argumento actual en la llamada a un método).
Declaración de Arreglos
- Como otras variables, antes de poder utilizar un array primero se debe declarar.
- int[] arrayDeEnteros;
- La parte int[] de la declaración indica que arrayDeEnteros es un array de enteros.
Otra forma de declararlos es la siguiente:
UNIDIMENSIONALES :
- tipo nombre_array[]=new tipo[nº];
- tipo nombre_array[]={ valores };
BIDIMENSIONALES :
- tipo nombre_array[][]=new tipo[nº][nº];
- tipo nombre_array[][]={valores};
Inicializar un Array.
Para inicializar un array existen 2 maneras:
- int [] arreglo= new int[4] o
- int [] arreglo={100,200,302,400}
- Al momento de inicializar un arreglo de la manera:
int [] arreglo= new int[4]
Cada posición del arreglo sera inicializada con el valor por defecto del tipo de variable.
jueves, 19 de agosto de 2010
EJEMPLOS ESTRUCTURAS BÁSICAS
a) IF(masa <= 19)
{
System.out.println("x= sobrepeso");
}
ELSE
{
System.out.println("peso normal");
}
b) WHILE(X<=5)
{
suma=x*2;
x++;
}
c) DO
{
suma=x * 2;
x++;
System.out.println(x);
}
WHILE (x<=5);
d) FOR(int i=1; i=4;i++)
{
vector[i]=aux;
aux=aux+1;
}
d) SWITCH
int hijos;
printf(“Ingrese la cantidad de hijos que usted tiene: \n”);
scanf(“%d”, &hijos);
switch (hijos) {
case ‘0’:
printf(“No le corresponde asignación familiar por hijo\n”);
break;
case ‘1’:
printf(“Le corresponden 50usd de asignación familiar por su único hijo\n”);
break;
case ‘2’:
printf(“Le corresponden 75usd de asignación familiar por sus dos hijos\n”);
break;
default:
printf(“Le corresponden 100usd de asignación familiar por tener más de dos hijos\n”);
break;
};
{
System.out.println("x= sobrepeso");
}
ELSE
{
System.out.println("peso normal");
}
b) WHILE(X<=5)
{
suma=x*2;
x++;
}
c) DO
{
suma=x * 2;
x++;
System.out.println(x);
}
WHILE (x<=5);
d) FOR(int i=1; i=4;i++)
{
vector[i]=aux;
aux=aux+1;
}
d) SWITCH
int hijos;
printf(“Ingrese la cantidad de hijos que usted tiene: \n”);
scanf(“%d”, &hijos);
switch (hijos) {
case ‘0’:
printf(“No le corresponde asignación familiar por hijo\n”);
break;
case ‘1’:
printf(“Le corresponden 50usd de asignación familiar por su único hijo\n”);
break;
case ‘2’:
printf(“Le corresponden 75usd de asignación familiar por sus dos hijos\n”);
break;
default:
printf(“Le corresponden 100usd de asignación familiar por tener más de dos hijos\n”);
break;
};
viernes, 13 de agosto de 2010
ESTRUCTURA BÁSICAS
IF-THEN: Es una estructura de control utilizada para tomar desiciones según se cumpla una condición o varias o no.
WHILE: Señala el comienzo del bucle y después de esta palabra se espera la repetición, si la condición es cierta se pasa al cuerpo del bucle de lo contrario, al final de la instrucción mientras.
DO WHILE: MIentras la condición sea verdadera, se ejecutarán las sentencias del bucle.
FOR: Sirve para repetir un código dependiendo de un contador. Es una de las estructuras más usada para crear ciclos.
SWITCH: Permite elegir ejecutar diferentes códigos dependiendo de un valor.
WHILE: Señala el comienzo del bucle y después de esta palabra se espera la repetición, si la condición es cierta se pasa al cuerpo del bucle de lo contrario, al final de la instrucción mientras.
DO WHILE: MIentras la condición sea verdadera, se ejecutarán las sentencias del bucle.
FOR: Sirve para repetir un código dependiendo de un contador. Es una de las estructuras más usada para crear ciclos.
SWITCH: Permite elegir ejecutar diferentes códigos dependiendo de un valor.
Suscribirse a:
Entradas (Atom)