domingo, 24 de abril de 2011

RECORDANDO VECTORES Y MATRICES

Miercoles 20 abril 2011
Estructura de datos


VECTORES
Vectores.- unidad de almacenamiento de datos(temporal o permanente).
·         INICIALIZAR.
·         INGRESAR DATOS.
·         MOSTRAR DATOS.
OTROS ALGORITMOS:
ü  BUSQUEDA.
ü  ORDENAMIENTO.

1.- INICIALIZAR UN VECTOR

Int  V[ ] = new int [ n ]; 
Object  O[ ] = new Object[ n ];
Int  V1 [ ] = { 2, 7, 1, 9 };
Vector V2 = new Vector( 5 ); 
Int V3[  ];


2.- INGRESAR DATOS
25
0
0

      


V2.add(300); 
V2.add(200);
V2.add(10, 4);   

300
200
0
0
10


                     
BufferReader Val = (new BufferReader(new Imput SheamReader(System.In)));
// Introducimos valor desde teclado.
Int num = Integer.ParseIn(Val.readLine() ); // Captura por flujo del teclado
For( int i = 0; i < n; i ++){
            V1[ i ] = Integer.ParseIn(Val.readLine());
}


3.- MOSTRAR DATOS

Public static void Mostrar( int V[ ] ){
            For( int i = 0; i < V.length; i ++ ){ // Por propiedad o atributo(length).
                        System.out.println(“ [ ” + i + “ ] =  ” + V[ i ]);
}
}
// Invocacion en el main del metodo Mostrar
public static void main(String[] args) {
Mostrar(V);
}
Con la clase vector

Public static void MostrarV(Vector  X ){
            For( int i = 0; i < X.Size; i ++ ){
                  System.out.println(“ [ ” + i + “ ] =  ” + X.get( i ));
}
4.- OTROS ALGORITMOS 
(ORDENACION )  
.-Forma tradicional.

public static void Ordenar( int V[ ]){
 for( int i = 0; i < V.length; i ++ ){
    for( int j = 0; j < V.length; j ++ ){
     if(V[ i ] < V[ j ]){
      int aux = V[ i ];
       V[ i ] = V[j];
       V[ j ] = aux;
      }else if(V[ i ] > V[ j ]){
       int aux = V[ i ];
       V[ i ] = aux;
       V[ j ] = V[j];}
    }
   }
 }
Public static void Mostrar( int V[ ] ){
            For( int i = 0; i < V.length; i ++ ){  
System.out.println(“ [ ” + i + “ ] =  ” + V[ i ]);  }
}
.- Utilizando metodos de la clase ARRAYS.
Importamos la librería

Import  java.util.Arrrays;

Public static void Mostrar( int V[ ] ){
            For( int i = 0; i < V.length; i ++ ){ // Por propiedad o atributo(length).
                        System.out.println(“ [ ” + i + “ ] =  ” + V[ i ]);
}
}
public static void main(String[] args) {
       int v[]= {2,9,1,3};
        Arrays.sort(v);
        Mostrar(v);
    }
(BUSQUEDA )  

public static void llenar( int V[ ]){
    Scanner S= new Scanner(System.in);
    for( int i = 0; i < V.length; i ++ ){
            V[i]= S.nextInt();
    }
}
public static int buscar(int V[], int elem){
   int pos =-1;
    for( int i = 0; i < V.length; i ++ ){
        if(V[ i ] == elem){
            pos =i;
        }
    }
   return pos;
}
public static void Mostrar( int V[ ] ){
    int i;
    for( i = 0; i < V.length; i ++ ){
     out.println(" [ " + i + " ] =  " + V[i]);
     }
}
public static void main(String[] args) {

      out.println("Longitud de nuestro vector:");
       Scanner N = new Scanner(System.in);
       int n = N.nextInt();
       int v[]= new int[n];

        out.println("Llenamos nuestro vector:");
        llenar(v);

        out.println("buscamos elemento en el vector:");
        Scanner S = new Scanner(System.in);
        int elem = S.nextInt();

      out.println("Mostramos vector desordenado: ");
       Mostrar(v);
       
       out.println("Mostramos vector ordenado: ");
       Arrays.sort(v);
       Mostrar(v);

       out.println("La posicion del elemento encontrado es :"+buscar(v, elem));
       }
}
MATRICES
Matrices.-
·         INICIALIZAR.
·         INGRESAR DATOS.
·         MOSTRAR DATOS.

1.- INICIALIZAR UNA MATRIZ

·         Int  M[ ] [ ]= new int [ n ][ n ];  // El operador new es una asignacion dinamica de memoria.
·         Object  O[ ] [  ]= new Object[ n ][ n ];  // Crea una matriz de objetos de tamaño n*n.
·         Arrays[ ][ ] V2 = new Arrays[5][5];  // Es un método, asi que importamos la librería import java.util.Vecto; o : import java.util.Arrays;
·         Int M3[  ][  ]; // Esto hace una referencia no es una matriz ya que esto no es una instancia.
2.- INGRESAR DATOS

BUFFER .- Almacenamiento temporal de memoria auxiliar.
 M[ 0 ][ 2 ] = 25;  
0
0
25
0
0
0

             



·         BufferReader Val = (new BufferReader(new Imput SheamReader(System.In)));
// Introducimos valor desde teclado.
·         Int num = Integer.ParseIn(Val.readLine() ); // Captura por flujo del teclado
For( int i = 0; i < n; i ++){
For( int j = 0; j < n; j ++){
      V1[ i ] [ j ] = Integer.ParseIn(Val.readLine());
       }
}
3.- MOSTRAR DATOS

public static void Mostrar( int V[ ][ ] ){
    for( int i = 0; i < V.length; i ++ ){
        for( int j = 0; j < V.length; j ++ ){
            System.out.print( V[i][j]+"\t");
        }
        System.out.print("\n");
    }
}
// Invocacion en el main del metodo Mostrar
public static void main(String[] args) {
            int int M[ ][ ]= new int [ n ][ n ];
            System.out.println(“Mostramos elementos de la matriz: ”);
Mostrar(M);
}



V[ 0 ] = 25;

Publicado por en 2 comentarios:

PRACTICA CON VECTORES

Martes 19 abril 2011  
Estructura de datos

PRACTICANDO VECTORES

Dado el siguiente vector
2          9          1          3
a)    Ordenar el vector utilizando el metodo que vea conveniente:

public class Main {
   
public static void Ordenar( int V[ ]){
 for( int i = 0; i < V.length; i ++ ){
    for( int j = 0; j < V.length; j ++ ){
     if(V[ i ] < V[ j ]){
      int aux = V[ i ];
       V[ i ] = V[j];
       V[ j ] = aux;
      }else if(V[ i ] > V[ j ]){
       int aux = V[ i ];
       V[ i ] = aux;
       V[ j ] = V[j];
}
public static void Mostrar( int V[ ] ){
    for( int i = 0; i < V.length; i ++ ){
            System.out.println(" [ " + i + " ] =  " + V[i]); }
}
    public static void main(String[] args) {
         int v[]= {2,9,1,3};
         Mostrar(v);
         System.out.println("ordenado");
         Ordenar(v);
         Mostrar(v); }
}

b)    Ordenar el vector utilizando un metodo de la clase ARRAYS.

Public class main{
public static void Mostrar( int V[ ] ){
    for( int i = 0; i < V.length; i ++ ){
            System.out.println(" [ " + i + " ] =  " + V[i]);
     }
}
    public static void main(String[] args) {
       int v[]= {2,9,1,3};
        Arrays.sort(v);
        Mostrar(v);
    }
}

Publicado por en No hay comentarios:

domingo, 3 de abril de 2011

METODOS (VECTOR Y ARRAYS)

METODOS DE LA CLASE VECTOR
Clase Vector en Java La clase java.util.Vector deriva de Object, implementa Cloneable (para poder acceder al método clone() y también implementa Serializable (para así convertir este objeto en cadenas de caracteres).
Vector representa un array de objetos que puede crecer y reducirse, según el número de elementos, además accedemos a los elementos por medio de un subíndice pero atreves de un método llamado get(índice).
• El método add(Objeto) insertara al final del arreglo el objeto que se encuentra entre el paréntesis
• void addElement (Object miobj) // agrega mi objeto al final del vector.
• firstElement() y lastElement() // indican el primero y ultimo elemento del vector respectivamente
• El método indexOf(objeto) // encuentra la posición en la que el elemento se encuentra en el arreglo
• El método contains(objeto) // indica si el objeto se encuentra en el vector
• int lastIndexOf (Object objeto, int índice) //retorna la posición de la ultima ves que el objeto aparezca en el vector
• Object elementAt (int índice) // retorna el objeto que se encuentra en el índice
 • remove(objeto) // elimina el objeto que enviamos entre los paréntesis
• boolean removeElement (Object miobjeto) // elimina el primer miobjeto que encuentra
• void removeAllElements() // Elimina todos los elementos del Vector
• void removeElementAt(int indice) // elimina el elemento que esta en índice
• El método size() // nos indicara cual es el tamaño actual del arreglo
 • void trimToSize() // Ajusta su tamaño a los elementos que posea • void setSize(int nuevoTamaño) // establece un nuevo tamaño para el vector .
• El método capacity() // nos dirá la capacidad disponible para agregar objetos al arreglo
• isEmpty() // devolverá true si el vector esta vacio de lo contrario retornara false
• void setElementAt(Object objeto, int índice) // cambia el elemento que esta en índice por el objeto del parámetro
void insertElementAt(Object objeto, int índice) // inserta el elemento por delante de una determinada posición.
METODOS DE LA CLASE ARRAYS

  • ArrayList() // construye un ArrayList con capacidad cero por defecto, pero crecerá según le vayamos añadiendo:
  • ArrayList al = new ArrayList();
    ArrayList(int initialCapacity) // construye un ArrayList vacío con una capacidad inicial especificada:
    ArrayList al2 = new ArrayList(5);
  • IsFixedSize() // Obtiene un valor que indica si la matriz Array tiene un tamaño fijo.
  • Length() // Obtiene un entero de 32 bits que representa el número total de elementos de todas las dimensiones de Array.
  • clear() // Establece un intervalo de elementos de Array en cero, false o referencia de objeto null (Nothing en Visual Basic), en función del tipo de elemento.
  • CopyTo() // Sobrecargado. Copia todos los elementos del objeto Array unidimensional actual en el objeto Array unidimensional especificado.
  • CreateInstance() // Sobrecargado. Inicializa una nueva instancia de la clase Array.
  • LongLength() // Obtiene un entero de 64 bits que representa el número total de elementos de todas las dimensiones de Array.
  • SyncRoot() // Obtiene un objeto que se puede utilizar para sincronizar el acceso a la matriz Array.
  • Rank() // Obtiene el rango (número de dimensiones) de Array.
  • System.Collections.IList.Add () // Implementa IList.Add Produce una excepción NotSupportedException en todos los casos.
  • System.Collections.IList.Clear() // Establece todos los elementos de Array en cero, false o referencia de objeto null (Nothing en Visual Basic), en función del tipo de elemento.
  • System.Collections.IList.contains() // Determina si un elemento se encuentra en Array.
  • System.Collections.IList.IndexOf() // Busca el objeto especificado y devuelve el índice de la primera aparición dentro de la instancia unidimensional actual.
  • System.Collections.IList.Insert() // Implementa IList.Insert. Produce una excepción NotSupportedException en todos los casos.
  • System.Collections.IList.Remove() // Implementa IList.Remove. Produce una excepción NotSupportedException en todos los casos.
  • System.Collections.IList.RemoveAt() // Implementa RemoveAt. Produce una excepción NotSupportedException en todos los casos
  • System.Collections.ICollections.count() // Obtiene el número de elementos incluidos en Array.
  • System.Collections.IList.Item() //  Obtiene o establece el elemento que se encuentra en el índice especificado.
  • Finalize() // Permite que un objeto Object intente liberar recursos y realizar otras operaciones de limpieza antes de que el objeto Object sea reclamado por el recolector de elementos no utilizados. (Se hereda de Object).
  • MemberWiseClone() // Crea una copia superficial del objeto Object actual. (Se hereda de de Object).
Publicado por en No hay comentarios:
Suscribirse a: Entradas (Atom)