Você está em: Home » Todos os artigos

Grafos


Grafo (estructura de dat

Un grafo en el ámbito de las ciencias de la computación es una estructura de datos, en concreto un tipo abstracto de datos (TAD), que consiste en un conjunto de nodos (también llamados vértices) y un conjunto de arcos (aristas) que establecen relaciones entre los nodos. El concepto degrafo TAD desciende directamente del concepto matemático de grafo.
Informalmente se define como G = (V, E), siendo los elementos de V los vértices, y los elementos de E, las aristas (edges en inglés). Formalmente, un grafo, G, se define como un par ordenado, G = (V, E), donde V es un conjunto finito y E es un conjunto que consta de dos elementos de V.

En teoría de grafos, un vértice o nodo es la unidad fundamental de la que están formados los grafos. Un grafo no dirigido está formado por un conjunto de vértices y un conjunto de aristas (pares no ordenados de vértices), mientras que un grafo dirigido está compuesto por un conjunto de vértices y un conjunto de arcos (pares ordenados de vértices). En este contexto, los vértices son tratados como objetos indivisibles y sin propiedades, aunque puedan tener una estructura adicional dependiendo de la aplicación por la cual se usa el grafo; por ejemplo, una red semántica es un grafo en donde los vértices representan conceptos o clases de objetos.
Los dos vértices que conforman una arista se llaman puntos finales ("endpoints", en inglés), y esa arista se dice que es incidente a los vértices. Un vértice w es adyacente a otro vértice v si el grafo contiene una arista (v,w) que los une. La vecindad de un vértice v es un grafo inducido del grafo, formado por todos los vértices adyacentes a v.

En Teoría de grafos, las aristas, junto con los vértices, forman los elementos principales con los que trabaja esta disciplina, siendo consideradas las aristas las uniones entre nudos o vértices.

Existen diferentes implementaciones del tipo grafo: con una matriz de adyacencias (forma acotada) y con listas y multilistas de adyacencia (no acotadas).
  • Matriz de adyacencias: se asocia cada fila y cada columna a cada nodo del grafo, siendo los elementos de la matriz la relación entre los mismos, tomando los valores de 1 si existe la arista y 0 en caso contrario.
Matriz de adyacencia.jpg
  • Lista de adyacencias: se asocia a cada nodo del grafo una lista que contenga todos aquellos nodos que sean adyacentes a él.
Listas de adyacencia.jpg

Especificación de los tipos abstractos de datos de un grafo no dirigido


Generadores

Crear un grafo vacío: Devuelve un grafo vacío.
  • op crearGrafo : -> Grafo [ctor] .
Añadir una arista: Dado un grafo, añade una relación entre dos nodos de dicho grafo.
  • op añadirArista : Grafo Nodo Nodo -> [Grafo] [ctor] .
Añadir un nodo: Dado un grafo, incluye un nodo en el en caso en el que no exista previamente.
  • op añadirNodo : Grafo Nodo -> Grafo [ctor] .


Constructores

Borrar nodo: Devuelve un grafo sin un nodo y las aristas relacionadas con él. Si dicho nodo no existe se devuelve el grafo inicial.
  • op borrarNodo : Grafo Nodo -> Grafo .
Borrar arista: Devuelve un grafo sin la arista indicada. En caso de que la arista no exista devuelve el grafo inicial.
  • op borrarArista : Grafo Nodo Nodo -> Grafo .


Grafo Vacio: Comprueba si un grafo no tiene ningún nodo.
  • op esVacio : Grafo -> Bool .
Contener Nodo: Comprueba si un nodo pertenece a un grafo.
  • op contiene : Grafo Nodo -> Bool .
Adyacentes: Comprueba si dos nodos tienen una arista que los relacione.
  • op adyacentes : Grafo Nodo Nodo -> Bool .
Para la especificación de un grafo dirigido tenemos que modificar algunas de las ecuaciones de las operaciones borrarArista y añadirArista para que no se considere el caso de aristas bidireccionales.
Leia Mais

PRACTICA


crear un sistema que simule la aduana.

package adb;

/**
 *
 * @author Romina
 */
public class Aduana {
    private String nombre;
    private String tipo;
    private String chasis;
    private String motor;
    private int modelo;
    private String color;
    private double costo;
  
    public Aduana(){
        nombre = "";
        tipo = "";
        chasis = "";
        motor = "";
        modelo = 0;
        color = "";
        costo = 0.0;
      
    }
    public Aduana(String nombre, String tipo, String chasis,
          String motor, int modelo, String color, double costo){
        this.nombre = nombre;
        this.tipo = tipo;
        this.chasis = chasis;
        this.motor = motor;
        this.modelo = modelo;
        this.color = color;
        this.costo = costo;
    }
    public void setNombre(String nombre){
        this.nombre = nombre;
    }
    public void setTipo(String tipo){
        this.tipo = tipo;
    }
    public void setChasis(String chasis){
        this.chasis = chasis;
    }
    public void setMotor(String motor){
        this.motor = motor;
    }
    public void setModelo(int modelo){
        this.modelo = modelo;
    }
    public void setColor(String color){
        this.color = color;
    }
    public void setCosto(double costo){
        this.costo = costo;
    }
  
    public String getNombre(){
        return nombre;
    }
    public String getTipo(){
        return tipo;
    }
    public String getChasis(){
        return chasis;
    }
    public String getMotor(){
        return motor;
    }
    public int getModelo(){
        return modelo;
    }
    public String getColor(){
        return color;
    }
    public double getCosto(){
        return costo;
    }
    public double getCostoNacionalizacion(){
 
        if((modelo >= 2010)&&(modelo <= 2012)){
            costo = costo * 0.30;
        }
        if((modelo >= 2005)&&(modelo <= 2009)){
            costo = costo * 0.50;
        }
        if((modelo >= 1990)&&(modelo <=2004)){
            costo = costo * 0.60;
        }
        return costo;
    }
 
}

* To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package adb;

import adb.Lista.ExcepcionListaVacia;

/**
 *
 * @author Romina
 */
public class Cola {
    private Lista listaCola;
  
    public Cola(){
     listaCola = new Lista("cola");
    }
    public void enqueue(Object objeto){
      listaCola.insertarAlFinal(objeto);
    }
  
    public Object dequeue() throws ExcepcionListaVacia{
      return listaCola.eliminarDelFrente();
    }
    public boolean estaVacia(){
     return listaCola.estaVacia();
    }
    public void imprimir(){
     listaCola.imprimir();
    }
}
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package adb;

/**
 *
 * @author Romina
 */
public class Hilo extends Thread {

    Splashcreen ref;

    public Hilo(Splashcreen ref) {
        this.ref = ref;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);
                ref.Llenar_Barra();

            } catch (InterruptedException ex) {

            }
        }
    }
    
}
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package adb;

/**
 *
 * @author Romina
 */
public class Lista {
   private Nodo primerNodo;
    private Nodo ultimoNodo;
    private String nombre;
    Object datoRemover;
    int pos = 0;      
    public Lista(){
        this("lista");
    }
    public Lista(String nombreLista){
        nombre = nombreLista;
        primerNodo = ultimoNodo = null;
    }
    public boolean estaVacia(){
        return primerNodo == null;
    }
    public void insertarAlFrente(Object elementoInsertar){
        
        if(estaVacia())
            primerNodo = ultimoNodo = new Nodo(elementoInsertar);
        else
            primerNodo = new Nodo(elementoInsertar, primerNodo);
    }
    public void insertarAlFinal(Object elementoInsertar){
        
        if(estaVacia())
            primerNodo = ultimoNodo = new Nodo(elementoInsertar);
        else 
            ultimoNodo = ultimoNodo.siguienteNodo = new Nodo(elementoInsertar);
    }
    public Object eliminarDelFrente() throws ExcepcionListaVacia{
        if(estaVacia())
            
            throw new ExcepcionListaVacia(nombre);
            
        Object elementoEliminado = primerNodo.datos;
        
        if(primerNodo == ultimoNodo)
            primerNodo = ultimoNodo = null;
        else
            primerNodo = primerNodo.siguienteNodo;
        return elementoEliminado;
    }
    public void insertarNpos(Object elementoInsertar, int pos){
        if(estaVacia())
            //insertarAlFrente();
        if(pos == 1){
            //insertarAlFrente();
        }
        if(pos == cantNodo()){
            //insetarAlFinal();
        }
        else{
            Nodo actual = primerNodo;
            for(int i = 0 ; i < pos - 1; i++){
                actual = actual.siguienteNodo;
                Nodo nuevo = new Nodo(elementoInsertar, actual.siguienteNodo);
            }
        }
    }
    public Object eliminarDelFinal() throws ExcepcionListaVacia{
        
        if(estaVacia())
            
            throw new ExcepcionListaVacia(nombre);
            
        Object elementoEliminado = ultimoNodo.datos;
            
        if(primerNodo == ultimoNodo)
            primerNodo = ultimoNodo = null;
        else{
            Nodo actual = primerNodo;
            
             
        while(actual.siguienteNodo != ultimoNodo)
            actual = actual.siguienteNodo;
        
        ultimoNodo = actual;
        actual.siguienteNodo = null;
        }
       return elementoEliminado;
    }
    public Object eliminarNpos() throws ExcepcionListaVacia{
        
        if(estaVacia())
            
            throw new ExcepcionListaVacia(nombre);
            
              
                if(pos == 1){
                    eliminarDelFrente();
                }
                else{
                if(pos == cantNodo()){
                    eliminarDelFinal();
                }
                }
                
                   Object elementoEliminado = ultimoNodo.datos;
                
              if(primerNodo.equals(ultimoNodo)){
                    primerNodo = ultimoNodo = null;
                    
                    return elementoEliminado;
              }
                
                    
                    Nodo actual = primerNodo;
                    for(int i = 1 ; i < pos ; i++){
                        actual = actual.siguienteNodo;
                         elementoEliminado  = (actual.siguienteNodo).datos;
                        actual.siguienteNodo = (actual.siguienteNodo).siguienteNodo;
                        (actual.siguienteNodo).siguienteNodo = null;
                        
                    
                    }
                
                    return elementoEliminado;
                }
                
    public void imprimir(){
        
        if(estaVacia()){
            System.out.printf("%s Vacia\n", nombre);
        return;
    }
        System.out.printf("La %s es: ", nombre);
        Nodo actual = primerNodo;
        
        while(actual != null){
            System.out.printf("%s ", actual.datos);
            actual = actual.siguienteNodo;
        }
        System.out.println("\n");
    }

    public int cantNodo() {
        Nodo actual = primerNodo;
        int cant = 0;
        while(actual != null){
            cant++;
            actual = actual;
        }
        return cant;
    }

        public class ExcepcionListaVacia extends RuntimeException{
        
         public ExcepcionListaVacia(){
            this("lista");
        }
         public ExcepcionListaVacia(String nombre){
             super(nombre + "Esta Vacia");
         }
         
    }
 }
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package adb;

/**
 *
 * @author Romina
 */
public class Nodo {
    Object datos;//los datos para este nodo
    Nodo siguienteNodo;//referencia al siguiente nodo de la lista
    
    //el constructor crea un objeto Nodo que hace referencia al objeto
    Nodo(Object objeto){
        this(objeto, null);
    }
    Nodo(Object objeto, Nodo nodo){
        datos = objeto;
        siguienteNodo = nodo;
    }
    Object obtenerObject(){
        return datos;
    }
    Nodo obtenerSiguiente(){
        return siguienteNodo;
    }
}
*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package adb;

/**
 *
 * @author Romina
 */
public class Pila extends Lista{
    
    public Pila(){
        super("pila");
    }
    public void push(Object objeto){
        insertarAlFrente(objeto);
    }
    public Object pop() throws ExcepcionListaVacia{
        return eliminarDelFrente();
    }
}
Leia Mais
Leer más »

COLA

COLA
Una cola es simplemente un lugar para almacenar cosas, donde esas cosas se insertan una detrás de otra y para extraer siempre se lo hace por adelante de la cola donde se encuentra el primer elemento. Una cola funciona como una fila o cola de personas, que esperan su turno para ser atendidas, la primera persona atendida es siempre la primera de la fila y cuando llega una persona y queremos incorporarla a cola o adicionarla debemos hacerlo por detrás de la ultima persona en la cola.




/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package estructurasdatosdinamicas;


/**
 *
 * @author Administrador
 */
public class Cola extends ListaEnlazada{
    
    public Cola(){
        super("cola 1");
    }
    public void Encolar(Object obj){
        super.InsertAtras(obj);
    }
    public Object Decolar(){
        return super.DeleteFrente();
    }
    public Boolean colaVacia(){
        return super.Lvacia();
    }
}




Una cola circular

Una cola circular o anillo es una estructura de datos en la que los elementos están de forma circular y cada elemento tiene un sucesor y un predecesor. Los elementos pueden cosultarse, añadirse y eliminarse unicamente desde la cabeza del anillo que es una posición distinguida. Existen dos operaciones de rotaciones, una en cada sentido, de manera que la cabeza del anillo pasa a ser el elemento sucesor, o el predecesor, respectivamente, de la cabeza actual.

BICOLAS

Es una cola en la se puede "sacar" y "meter" elementos tanto de la delantera de la cola como e la cola. Si una cola, como estructura de datos abstracta, tiene dos operaciones llamadas "push" (que inserta un elemento al final de la cola) y "pop" (que extrae un elemento del principio de la cola), entonces una bicola tiene dos operaciones adicionales llamadas "push_front" y "pop_back".
Toda operación debería implementarse en un tiempo amortizado constante O(1). Al igual que la cola regular, la implementación e un array no es correcta por el costo del espacio o bien el shift de desencolar.
A diferencia de la cola simple, la lista enlazada no es suficiente. La implementación es trivial en una lista doblemente enlazada pero tiene el problema del acceso aleatorio a un elemento del medio de la cola. La implementación apropiada es un buffer circular con crecimiento dinámico.
Existen implementaciones listas en todos los lenguajes de programación. c++ tiene std::deque, java tiene la interfaz java.util.Deque, perl permite las operaciones pollback y pollfront en todos los arrays, etc. etc.


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package estructurasdatosdinamicas;

/**
 *
 * @author Administrador
 */
public class Bicola extends ListaEnlazada{
    
    public Bicola(){
        super("bicola 1");
    }
    public void PushAtras(Object obj){
        super.InsertAtras(obj);
    }
    public Object PopFrente(){
        return super.DeleteFrente();
    }
    public void PushFrente(Object obj){
        super.InsertFrente(obj);
    }
    public Object PopAtras(){
        return super.DeleteAtras();
    }
    public Boolean BicolaVacia(){
        return super.Lvacia();
    }
    
}



Leia Mais

PILAS


pilas

una pila es una lista que tiene establecida ciertas restricciones en cuanto a la forma de extraer  o colocar en ella nuevo elementos. la lista se utiliza siempre se que desea recuperar una serie de elementos en orden inverso a como se introdujeron .

package estructurasdatosdinamicas;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Administrador
 */
public class Pila extends ListaEnlazada{
    
    public Pila(){
         super("Pila 1");
                 }
    public void Push(Object obj){
        super.InsertAtras(obj);
    }
    public Object Pop(){
        return super.DeleteAtras();
    }
    public Boolean PilaVacia(){
        return super.Lvacia();
    }
}



Leia Mais

LISTAS

LISTAS



Una lista es un conjunto de elementos con un
orden concreto:
– Puede tener una longitud arbitraria.
– Ofrece la posibilidad de insertar o
eliminar un elemento en cualquier
ubicación.
– Ofrece la posibilidad de recorrer la lista de
forma ordenada, de elemento en elemento.



package estructurasdatosdinamicas;


creación de Nodo




/**
 *
 * @author Administrador
 */
public class Nodo {
    
    public Object Datos;
    public Nodo sgte;
    public Nodo anterior;
    public int CI;
    public int edad;
    
    
    
        public Nodo()
        {
            Datos = sgte = anterior = null;
            
        }
    public Nodo (Object obj)
    {
        Datos = obj;
        sgte = anterior = null;
    }
    public Nodo (Object obj, Nodo sig)
    {
        Datos = obj;
        sgte = sig;
    }
    public void GetDatos(Object cd)
    {
        Datos = cd;
    }
    public void SetAnterior(Nodo ant)
    {
        anterior = ant;
    }
    public void SetSgte(Nodo sg)
    {
        sgte = sg;
    }
    public Nodo SetSgte()
    {
        return sgte;
    }
    public Nodo GetAnteruior()
    {
        return anterior;
    }
}






Lista enlazada



• Las listas enlazadas son como trenes de mercancías.
• Cada elemento que que se va a poner en la lista está
contenido en una instancia de un nuevo tipo de
objeto, llamado enlace, que equivale a un vagón
del tren.
• En una lista enlazada sencilla, el enlace no sólo
contiene el elemento de la lista, sino que
también apunta al siguiente elemento de la
lista, al igual que un vagón de mercancías está
acoplado al siguiente.
• El último enlace de la lista no apunta a nada.


package estructurasdatosdinamicas;


/**
 *
 * @author Administrador
 */
public class ListaEnlazada {
    
    protected String Nombre;
    protected Nodo Primero;
    protected Nodo Ultimo;
    
    public ListaEnlazada(String n)
    {
        Nombre = n;
        Primero = Ultimo = null;
    }
    
    public ListaEnlazada()
    {
        this.Nombre = "Lista";
        
    }
    
    public Boolean Lvacia()
    {
        return Primero ==null;
    }
    
    public String getNombre(){
      
        return Nombre;
    }
    public Nodo getPrimero(){
        
        return Primero;
        
    }


    public Nodo getUltimo(){
    
        return Ultimo;
    }


    public void InsertFrente(Object obj){
           if(Lvacia())
         Primero=Ultimo= new Nodo(obj);
           else
         Primero=new Nodo (obj, Primero);
        
    }
        
    public void InsertAtras(Object obj){
           if(Lvacia())
         Primero=Ultimo= new Nodo(obj);
           else
         Ultimo=Ultimo.sgte=new Nodo (obj);
    
    }
    
    public Object DeleteFrente(){
    
           Object DatoRemovido = null;
           
           if(Lvacia())
               System.out.println("Vacia");
           DatoRemovido= Primero.Datos;
           if(Primero.equals(Ultimo)) 
                 Primero = Ultimo = null;
           else
               Primero = Primero.sgte;
           return DatoRemovido;
    }


    public  Object DeleteAtras(){
        
        Object DatoRemovido = null;
        if (Lvacia()){
            System.out.println("Vacia");
        }
        DatoRemovido = Ultimo.Datos;
        
           if(Primero.equals(Ultimo)){
        
               Primero = Ultimo = null;
        }
           else{
           Nodo Actual = Primero;
               while (Actual.sgte != Ultimo)
                     Actual = Actual.sgte;
               Ultimo = Actual;
               Actual.sgte= null;
           }
           
           return DatoRemovido;
    }
     
    public Object getElementoDeIndice(int Posicion){
        
        if(Lvacia()){
           return null;
        }
        else{
             Nodo actual = Primero;
                  int  cont = 1;
                    while((actual != null)&& (cont < Posicion)){
                      actual = actual.sgte;
                      cont++;
                    }
                    if((actual != null) && (cont == Posicion - 1)){
                           return actual.Datos;
                    }
                    else{
                      return null;
                    }
               }
          }
        
    public void InsertarElementoEnIndice(int Posicion, Object obj){
    Nodo nuevo;
    Nodo actual;
            
              if(Lvacia()){
                 return;
              }
              else{
                  actual = Primero;
                  int cont = 1;
                    
                     while((actual != null) && (cont == Posicion -1)){
                         actual = actual.sgte;
                         cont++;
                     }
                     if ((actual != null) && (cont == Posicion - 1)){
              
               nuevo = new Nodo(obj , actual.sgte);
                 actual.sgte= nuevo;
              
          }
       }
    }


    public Object DeleteElementoDeIndice (int Posicion){
        
        Object DatoRemovido;
        Nodo actual;
        
        if(Lvacia()==true){
         return null;
        }
        else{
            if(Posicion == 1){
                  DatoRemovido=Primero.Datos;
                  Primero=Primero.sgte;
                  return DatoRemovido;
            }
            else{
             actual=Primero;
             int cont=1;
             
             while((actual != null) && (cont<Posicion-1)){
              actual=actual.sgte;
              cont++;
             }
             if((actual !=null)&&(cont==Posicion-1)){
              DatoRemovido=actual.sgte.Datos;
              
              actual.sgte=actual.sgte.sgte;
              return DatoRemovido;
             }
            }
            return null;
        }
    }
    
}


lista doble circular
Las listas doblemente enlazadas son estructuras de datos semejantes a las listas enlazadas simples
La asignación de memoria es hecha al momento de la ejecución. 

En cambio, en relación a la  listas enlazadas simples el enlace entre los elementos se hace gracias a dos punteros.



public class ListaDobleCircular {
  
    private Nodo actual;
    private Nodo ultimo;
    private long numeroElemento;
    private long posicion;
  
    public ListaDobleCircular(){
        actual = ultimo = null;
        numeroElemento = 0;
        posicion = 0;
    }
    public long tamañoLista(){
         return numeroElemento;
    }
  
public void incertarlistadobleE(Object obj){
     Nodo q;
    
      if(ultimo == null){
          ultimo = new Nodo();
          ultimo.anterior = ultimo;
          ultimo.sgte = ultimo;
          ultimo.Datos = obj;
          actual = ultimo;
          posicion = 0;
 }
      else{
     q = new Nodo();
          actual.sgte.anterior = q;
          q.sgte = actual.sgte;
          actual.sgte = q;
          q.anterior = actual;
          q.Datos = obj;
          posicion++;
     if(actual == ultimo){
          ultimo = q;
     }
         actual = q;
        numeroElemento++;
     }
 }
 public Object BorrarListaDobleE(){

     Nodo q;
     Object obj;
    
     if(ultimo == null){
         return null;
     }
       if(actual == ultimo){
           if(numeroElemento == 1){
              obj = ultimo.Datos;
              ultimo = actual=null;
              numeroElemento = 0;
              posicion = 0;
      }
           else{
              actual = ultimo.anterior;
               ultimo.sgte.anterior = actual;
               actual.sgte = ultimo.sgte;
               obj = ultimo.Datos;
               ultimo = actual;
               posicion--;
               numeroElemento--;
             }
       }
          else {
                q = actual.sgte;
                actual.anterior.sgte = q;
                q.anterior = actual.anterior;
                obj = actual.Datos;
                actual = q;
                numeroElemento--;
       }
           return obj;
    }
 public void irSgte(){
     if(posicion < numeroElemento - 1){
         actual = actual.sgte;
         posicion++;
     }
 }
 public void irAnterior(){
     if(posicion > 0){
         actual = actual.anterior;
         posicion--;
     }
 }
 public void irPrincipio(){
     actual = ultimo.sgte;
     posicion = 0;
 }
 public void irFinal(){
     actual = ultimo;
     posicion = numeroElemento - 1;
 }
 public Boolean irAl(long i){
     if(i >= numeroElemento){
         return false;
     }
     irPrincipio();
     for(long n = 0 ; n < i;n++){
         irSgte();
     }
     return true;
 }
 public Object obtener(){
     if(ultimo == null){
         return null;
     }
     return actual.Datos;
 }
 public Object obtenerDe(long i){
     if(!irAl(i)){
         return null;
     }
     return obtener();
 }
 public void Modificar(Object NuevoDato){
     if(ultimo == null){
         return;
     }
     actual.Datos = NuevoDato;
 }
}

Listas enlazadas circulares

En una lista enlazada circular, el primer y el último nodo están unidos juntos. Esto se puede hacer tanto para listas enlazadas simples como para las doblemente enlazadas. Para recorrer una lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en cualquier dirección hasta que se regrese hasta el nodo original. Desde otro punto de vista, las listas enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de listas es el más usado para dirigir buffers para “ingerir” datos, y para visitar todos los nodos de una lista a partir de uno dado.










Leia Mais

PRACTICA DE VECTORES Y MATRICES



PRACTICA


clace vector              matriz
     const                   const
     tostring                tostring
                                diagonal


                completar
                 par\impares(contar)
                 mayor\ menor
                 ordenar
                 invertir
                 comparar (2 vect o 2 mat)






/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package vectorvisual1;

/**
 *
 * @author Romina
 */
public class Vector {
    public int n;//Tam
    public int [] x; //Arreglo
  
    public Vector(int n){//SOBRECARGA DEL METODO
        this.n = n;
        x = new int[n];
            for(int i = 0 ; i < n;i++){
                x[i] = 0;
        }
    }
    public Vector(int [] x){//SOBRECARGA DEL METODO
        this.x=x;
        n= x.length;
    }
    public String toString(){//REDEFINICION DE METODO
        String texto="";
            for(int i=0;i<n;i++){
                texto += "\t"+(int)Math.round(1000*x[i])/1000;
            }
            texto += "\n";
        return texto;
    }
    public int Mayor(int v [], int n){
       int mayor = v.length;
        for(int i = 0;i < n ; i++){
               if(mayor < v[i]){
                  mayor = v[i];          
           }
       }    
       return mayor;
    }
    public int menor(int v[], int n){
        int menor = v.length;

        for(int i = 0 ; i < n ; i++){
            if(v[i] <= menor ){
             menor = v[i];
            }
        }
         return menor;
    }
    public int par(int v[], int n){
      
        int cont = 0;
        for(int i = 0; i < n; i++){
            if(v[i] % 2 == 0){
               cont = cont + 1;
              
            }
        }
        return cont;
      
    }
     public int Impar(int v[], int n){
      
        int cont = 0;
        for(int i = 0; i < n; i++){
            if(v[i] % 2 != 0){
               cont = cont + 1;
              
            }
        }
        return cont;
    }
     public void ordenar(int v[],int n){
        
         for(int i = 0 ; i < n ; i++){
             for(int j = 0 ; j < n ; j++){
                 if(v[i] < v[j]){
                     int aux = v.length;
                
                         aux = v[i];
                         v[i]= v[j];
                         v[j]= aux;
                 }
             }
         }
     }
     public void Invertir(int v[],int n){
        
         for(int i = 0 ; i < n ; i++){
             for(int j = 0 ; j < n ; j++){
                 if(v[i] > v[j]){
                     int aux = v.length;
                
                         aux = v[i];
                         v[i]= v[j];
                         v[j]= aux;
                 }
             }
         }
     }
}






package matrizvisual;

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 *
 * @author Romina
 */
public class Matriz {
    public int n;//Tam
    public int [][] x; //Arreglo

    public Matriz(int n){//SOBRECARGA DEL METODO
        this.n=n;
        x = new int[n][n];
            for(int i = 0; i < n; i++){
                for(int j = 0 ; j < n ; j++){
                x[i][j]=0;
                }
             }
   }
    public Matriz(int [][] x){//SOBRECARGA DEL METODO
        this.x=x;
        n= x.length;
    }
    public String toString(){//REDEFINICION DE METODO
        String texto=" ";
            for(int i = 0 ; i < n ; i++){
                for(int j = 0 ; j < n ; j++){
                texto += "\t   "+(int)Math.round(1100*x[i][j])/1100;
                }
                texto += " \n";
            }
            texto += " \n";
        return texto;
    }
  public static int Diagonal(int [][] x,int n){
     int diagonal=0;
     for(int i = 0 ; i < n ; i++){
        diagonal = diagonal + x[i][i];
       }
        return diagonal;
   }
      public int par(int x[][], int n){
        
        int cont = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0 ; j < n ; j++){
                if(x[i][j] % 2 == 0){
               cont = cont + 1;    
            }
            
               
            }
        }
        return cont;
        
    }
     public int Impar(int x[][], int n){
        
        int cont = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0 ; j < n ; j++){
                if(x[i][j] % 2 != 0){
               cont = cont + 1;    
            }
          }
        }
        return cont;
    }
     public void ordenar(int x[][],int n){
         
         for(int  i = 0 ; i < n ; i++){//ordena la matriz de abajo hacia arriba           
             for(int  j = 0 ; j < n ; j++){              
                 for(int l = 0 ; l < n ; l++){                  
                     for(int m = 0 ; m < n ; m++){                     
                           if(x[i][j] < x[l][m]){                       
                             int aux = x[i][j];                       
                             x[i][j] = x[l][m];                       
                             x[l][m] = aux;
                 }
             }
         }
     }
  }
}
     public void Ivertida(int x[][],int n){
         
         for(int  i = 0 ; i < n ; i++){//ordena la matriz de abajo hacia arriba           
             for(int  j = 0 ; j < n ; j++){              
                 for(int l = 0 ; l < n ; l++){                  
                     for(int m = 0 ; m < n ; m++){                     
                           if(x[i][j] > x[l][m]){                       
                             int aux = x[i][j];                       
                             x[i][j] = x[l][m];                       
                             x[l][m] = aux;
                 }
             }
         }
     }
  }
} 
     public int Mayor(int x[][], int n){
       int mayor = x.length;
        for(int i = 0;i < n ; i++){
            for(int j = 0 ; j < n ; j++){
               if(mayor < x[i][j]){
                  mayor = x[i][j];           
               }
            }
        }      
        return mayor; 
    }
    public int menor(int x[][], int n){
        int menor = x.length;

        for(int i = 0 ; i < n ; i++){
            for(int j = 0 ; j < n ; j++){
               if(x[i][j] <= menor){
                  menor = x[i][j];
                }
            }
        }
         return menor;
    }       
      public static int leer(BufferedReader buff){
        int lee=0; boolean error;
        do{
            error = false;
            try{
                lee = Integer.parseInt(buff.readLine());}
            catch (NumberFormatException ex){
                System.out.println("SE ha producido un error");
                error = true;
            }
            catch (Exception ex){ex.printStackTrace(System.err);}
        }while(error);
        return lee;
    }
    public static void cargar(int v[][]){
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        for(int i=0; i<v.length; i++){
            for(int j=0; j<v.length; j++){
            System.out.print("Ingrese un valor: = ");
            v[i][j]=leer(br);
        }
    }
 }
    public static void mostrar(int v[][]){
       for(int i=0; i<v.length; i++){
           for(int j=0; j<v.length; j++){
           System.out.println(v[i][j]+"\n");
           }
    }
}  
  public static void main(String[] args) {
        // TODO code application logic here
       int P[][] = new int[5][5];
         cargar(P);
         mostrar(P);   
    
  }
}
Leia Mais

EJEMPLOS DE VECTORES MUESTRAN Y ALMACENAN DATOS





MOSTRAR EL VALOR DE CADA VECTOR
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pract1;
import java.util.Vector;
import java.util.Arrays;
import java.io.BufferedReader;
import java.io.InputStreamReader;
/**
 *
 * @author Rominita
 */
public class Pract1 {
public static int Leer(BufferedReader buff){
    int lee=0;   boolean error;
    do{
        error = false;
        try{
            lee = Integer.parseInt(buff.readLine());
        }
        catch (NumberFormatException ex){
            System.out.println("se ha producido un error");
                 error = true;
        }
        catch (Exception ex){ex.printStackTrace(System.err);}
    }while (error);
        return lee;
  
    }
       //=====================================================
  public static void cargar (int v []){
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      for (int i =0; i<v.length;i++){
          System.out.print("Ingrese un valor:=");
          v[i] = Leer(br);
        
      }      
  }
  //=============================================================
 
  public static  void Mostrar(int v[]){
      for (int i=0; i<v.length;i++){
          System.out.print("["+i+"]="+v[i]+"|");
      }
  }
          

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int V1[]=new int [5];
        cargar(V1);
        Mostrar(V1);
    }
}






ALMACENAR DATOS DE ESTUDIANTES EN UN VECTOR

package estudiante;

/**
 *
 * @author Rominita
 */
public class Estudiante {
    private int RU;
    private String Nombre;
    private String Carrera;
  
   public Estudiante(){
       RU=0;
       Nombre = "";
       Carrera ="";
   }
   public Estudiante(int r,String n,String c){
       RU = r;
       Nombre = n;
       Carrera = c;
      
      
   }
  
   public void setRU(int r){RU = r;}
   public void setNombre(String n) {Nombre = n;}
   public void setCarrera(String c){Carrera = c;}
  
 
   public int getRU(){return RU;}
   public String getNombre(){return Nombre;}
   public String getCarrera(){return Carrera;}
  
   public String VerEstudiante(){
       return ("RU: "+RU+"\nNombre: "+Nombre+"\nCarrera: "+Carrera);
      
   }
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
    Estudiante E[] = new Estudiante[5];
    E[0] = new Estudiante (2345,"Ana Gil","Derecho\n\n======");
    E[1] = new Estudiante (654,"Juan Rocha","Pedagogia\n\n======");
    E[2] = new Estudiante (987,"Pedro Paz","Derecho\n\n======");
    E[3] = new Estudiante (6543,"Juana Arnez","Derecho\n\n======");
    E[4] = new Estudiante (653,"Ryan Ortiz","Derecho\n\n======");
 
  
    for(int i=0;i<E.length;i++){
        System.out.println(E[i].VerEstudiante());
    }
    }
}







Leia Mais
Suscribirse a: Entradas (Atom)