Qué son y qué no son las estructuras de datos

Estructuras de datos

En la vida práctica se puede encontrar una cantidad enorme de información en forma de datos, mismos que se encuentran organizados de tal manera que se puede disponer de la información que estos arrojan, estando organizados facilitan el acceso a su manejo. Toda la información obtenida de los datos y que pasa por nuestros ojos se encuentra organizada de manera tal que, facilita la productividad y competitividad.

Una estructura de datos es una colección de datos que se caracterizan por la forma en cómo están organizados los datos, así como, las relaciones y operaciones posibles que por ellos se definen con base a reglas previamente definidas. Durante el curso se definieron diferentes tipos de estructuras, para este caso, las estructuras de datos en cadena, tal es el caso de los vectores de números ordenados en forma sucesiva y las estructuras en forma de matriz, en las cuales los datos se encuentran ordenados en filas y columnas. Las estructuras de datos son indispensables en la programación a fin de proporcionar un panorama claro del resultado que se espera como resultado.

Tipos de datos

Existen diferentes tipos de datos que a su vez pueden ser de tipo int, float, char, byte, double, long. y formar diferentes tipos de estructuras de datos, como pueden ser estáticas o dinámicas, siendo las estáticas aquellas en las que el tamaño de de memoria ocupado es definido antes que sea arrancado el programa que los usa. Por otro lado, las estructuras dinámicas no tienen limitación por su tamaño, a excepción de la memoria disponible en la computadora en la que vaya a ser utilizada.

Estructura de datos en cadena

En el caso de las estructuras en cadena como en el ejemplo inicial del curso, pueden estar definidas como fijas o variables, para el caso práctico, se toman caracteres numéricos o alfanuméricos, como pueden ser   una palabra, una frase, una matrícula, etc. La manera de concatenar en el caso práctico del curso fue por medio de comilla simple, ejemplo: {'H','O','L','A'};

Arreglos

Los arreglos son conjuntos de datos del mismo tipo, lo cual es su principal característica y se encuentran almacenados en forma adyacente. Cada uno de los datos contenidos son llamados elementos y se encierran entre corchetes [ ] indicando de esta manera que hablamos de un arreglo, estos elementos pueden ser procesados de manera separada, solo es necesario indicar la posición del elemento dentro del arreglo; el número de elementos dentro de un arreglo se especifica desde que es creado una vez que se declara desde el main.

Existen tres tipos de arreglos, a saber: unidimensionales, bidimensionales y multidimiensionales.

Los unidimensionales, en estos los elementos se encuentran ordenados en forma contínua o lineal para este caso.

Los bidimensionales, son aquellos que están estructurados por elementos del mismo tipo al igual que los anteriores, pero están ordenados en filas y columnas y se leen en ese orden, primeramente las filas y enseguida las columnas, esto para ubicar un elemento en específico.

Los multidimensionales,  estos son similares a los bidimensionales, con la particularidad de que los elementos (virtualmente) son apilados unos sobre otros formando una especie de cubos, pero el programa nos los muestra como si fueran tablas para ubicar a cada uno de los elementos.

Litas   simples

Las listas con conjuntos de datos ordenados en la cual cada elemento tiene un predecesor, a excepción del primer elemento    y un único sucesor, a excepción del último; en el caso de las listas, se utiliza el procedimiento de últimas entradas, primeras salidas; la longitud de las listas puede reducirse o aumentarse según lo crea necesario el usuario, cada elemento recibe el nombre de nodo, el cual contiene un campo para almacenar el dato y un puntero en un extremo, a través del cual podrá enlazarse a otro nodo formando la secuencia de elementos.

Listas simples enlazadas

Una lista enlazada es una de las estructuras de datos, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos a elección del usuario y una o dos referencias o punteros al nodo anterior o posterior. El principal beneficio de las listas enlazadas respecto a las simples es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento. La lista enlazada básica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo y si se refiere al último, su valor será null.

Pilas

Las pilas son estructuras lineales a las que se puede acceder a sus datos solo por un extremo, que es el último elemento que haya sido ingresado, el método para acceder es de últimas entradas, primeras salidas. A estas estructuras se les puede afectar solo por dos operaciones, estas son: añadir elemento y eliminar elemento. Se manejan dos punteros, uno para indicar en donde empieza la pila y el otro en donde termina o cual es el último elemento, que a su vez, será el primero en salir en caso de hacer una eliminación. Si se desea eliminar un elemento de la pila, es necesario verificar que la estructura tenga elementos, de lo contrario, el programa nos enviará un mensaje de que la pila está vacía.

Colas

Las colas son estructuras lineales en la que los datos van siendo ingresados por el final y los eliminados por el frente, a diferencia de las pilas, en las colas se eliminan los elementos partiendo desde el primero en entrar a la estructura, es decir; primeras entradas primeras salidas. Para las colas, se necesitan dos variables, que son: frente y fin que son representados por punteros, uno a cada lado del elemento

frente

dato

fin

Las colas facilitan la interconexión entre un ordenador y una impresora por ejemplo, en donde la información a imprimir se va guardando en el orden que va entrando a la memoria de la impresora.

Árboles

Los árboles son estructuras no lineales en las que cada elemento o nodo está unido a otros o por debajo de él; un árbol uno o dos nodos denominados hijos. Al nodo principal se le llama raíz, al momento de ingresar un nodo, se debe evaluar si el valor del nodo a ingresar es mayor o menor que raíz, si en menor se aloja del lado izquierdo y si es mayor, se aloja del lado derecho, si debajo del no hijo, hay necesidad de alojar más nodos, se sigue el mismo procedimiento, considerando el valor del nodo a agregar, para saber si va por los de menor o mayor valor, para colocarlo ya sea a la izquierda o a la derecha, según sea el caso; y si ya no hubiera más nodos por agregar, al último o últimos en la jerarquía, se los denomina nodos hijos o simplemente hojas. Los árboles se utilizan para  realizar bases de datos en donde la búsqueda y almacenamiento sean los más óptimos.

Para recorrer un árbol se debe llevar un procedimiento de manera sistemática, procedimientos conocidos como pre orden, in orden y post orden, el procedimiento de cada uno es el siguiente:

Pre orden.-

1.    Se visita la raíz

2.    Recorrer el subárbol izquierdo en pre orden

3.    Recorrer el subárbol derecho en pre orden

In orden.-

1.    Recorrer el subárbol izquierdo in orden

2.    Visitar la raíz

3.    Recorrer el subárbol derecho

Post orden.-

1.    Recorrer el subárbol izquierdo en post orden

2.    Recorrer el subárbol derecho en post orden

3.    Visitar la raíz

La característica de los árboles es que en ellos cada nodo puede estar conectado a subárboles, que a su vez tienen una estructura similar, en la misma forma de árbol.

Teoría de grafos

Los grafos tienen como objetivos estudiar las interrelaciones entre elementos que interactúan unos con otros y obtener con ellos el mayor aprovechamiento en la solución a problemas de la vida cotidiana, estos están formados por vértices, nodos y flechas.

La teoría de grafos es aplicada a diferentes campos como lo pueden ser las redes de alcantarillado, redes eléctricas, rutas aéreas, terrestres, marítimas, logística, en la geografía, etc. En fin, en donde haya necesidad de organizar elementos para maximizar recursos.

Conclusión

Las estructuras de datos son elementales en todos los campos la de computación y aun cuando no se implemente como tales, estructurar de manera ordenada los elementos en cualquiera de las áreas a trabajar, éstos deben ser ordenados con claridad y de manera sistemática. El conocimiento aprendido es de valor en todos los ámbitos de la vida cotidiana y más en el campo del manejo de la información, considerando que existe un acervo muy amplio en materia de la informática, acrecentando las posibilidades de aportar un mejor aprovechamiento de los recursos que nos provee la información, pues para cada situación existe un procedimiento adecuado y óptimo con el fin de reducir tiempos y otros recursos de suma importancia que si se saben aprovechar, se traducen en desarrollo y crecimiento.

El estudioso de la computación habrá de engrandecer lo que hasta ahora se tiene recorrido y aportar en la medida de las posibilidades al desarrollo de nuevas y mejores herramientas, pues no solo se trata de jugar con dispositivos de manera virtual, sino, como se vio en el caso de los temas tratados, que son aplicaciones de la vida cotidiana y con los que todos de manera directa o indirecta tenemos poco o mucho que ver y hacer, el conocimiento se extiende en la medida que se sumerge en la aventura de buscar y encontrar nuevas y mejores cosas.

Las estructura de datos no son solo ejercicios informáticos que tengan como objetivo el desarrollo de la inteligencia y las habilidades lógicas, como tampoco son herramientas que sean aplicables a los mismos casos, pues para cada caso deberá elegirse correctamente los programas adecuados para la solución de problemas, pues no es la misma medicina para todos los males.

Listadoble

import java.util.Scanner;
class Nodo{
int elemento;
Nodo siguiente;
Nodo anterior;
public Nodo (int x)
{
elemento=x;
siguiente=null;
anterior=null;
}
}
public class Listadoble {
     
    /**
     * Creates a new instance of <code>Listadoble</code>.
     */
     private static Nodo frente=null, fin=null;
    public Listadoble() {
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int  opcion;
   
      Scanner ent=new Scanner(System.in);
   
      do
      {
      System.out.println("1) Insertar");
      System.out.println("2) Eliminar");
      System.out.println("3) Presentar");
      System.out.println("4) Reversa");
      System.out.println("5) Limpiar");
      System.out.println("6) Salir");
      opcion=ent.nextInt();
      switch (opcion)
         {
     
      case 1 : Insertar();
      break;
        case 2 : Eliminar ();
      break;
      case 3 : Presentar();
      break;
      case 4 : Reversa ();
      break;
      case 5 : Limpiar ();
      break;  
      case 6 : break;
      default : System.out.println("Opción equivocada");
      break;
         }      
        } while(opcion !=6);
    }
 
    public static void Insertar ()
    {
    Scanner ent=new Scanner(System.in);
    int valor;
    Nodo aux;
   
    System.out.print("Ingrese el dato");
      valor=ent.nextInt();
      aux=new Nodo(valor);
      if (frente==null)
      {
     
      frente=aux;
      }
      else
      {
     
         fin.siguiente=aux;
      aux.anterior=fin;
     
      }
      fin=aux;
   
    }
    // Método para ELIMINAR UN ELEMENTO

    public static void Eliminar()
    {
        Nodo aux;
       
         if (frente==null)
      System.out.println("Lista vacía");
      else
      {
            if(frente==fin)
                      frente=fin=null;
               else
                   {
                      aux=fin.anterior;
                      fin.anterior=null;
                      aux.siguiente=null;
                      fin=aux;
                    }
           
            }
           
     
       
    }
    //Método para PRESENTAR LOS ELEMENTOS DE UNA COLA CIRCULAR

   public static void Presentar()
    {
    Nodo aux;
     if (frente==null)
      System.out.println("Lista vacía");
     else
        for (aux=frente; aux!=null;)
        {
        System.out.println("Elemento: "+aux.elemento);
        aux=aux.siguiente;
        }  
   
    }
    public static void Reversa()
    {
    Nodo aux;
     if (frente==null)
      System.out.print("Lista vacía");
     else
        for (aux=fin; aux!=null;)
        {
        System.out.println("Elemento: "+aux.elemento);
        aux=aux.anterior;
        }  
   
    }
    // Método para limpiar lista
    public static void Limpiar ()
    {
           if (frente==null)
            System.out.println(" !!! Lista Vacia!!!");
            else
               
                     {
                        frente=null;
                        fin=null;

                      }
                      Presentar();

                }
   
    }

Listasimple

import java.util.Scanner;
class Nodo{

int elemento;
Nodo siguiente;

public Nodo(int x)
{
elemento=x;
siguiente=null;
}
}


public class Listasimple {


private static Nodo frente=null;
private static Nodo fin=null;
       
    /**
     * Creates a new instance of <code>Listasimple</code>.
     */
    public Listasimple() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
      int  opcion;
   
      Scanner ent=new Scanner(System.in);
     
      do
      {
      System.out.print("1) Insertar");
      System.out.print("2) Eliminar");
      System.out.print("3) Presentar");
      System.out.print("4) Limpiar");
      System.out.print("5) Salir ");
      opcion=ent.nextInt();
      switch (opcion)
         {
     
      case 1 : Insertar();
      break;
        case 2 : Eliminar ();
      break;
      case 3 : Presentar();
      break;
      case 4 : Limpiar();
      break;
      case 5 : break;
      default : System.out.println("Opción equivocada");
      break;
         }      
        } while(opcion !=5);
    }
   
   
     
     public static void Insertar()
     {
      int valor;
      Nodo aux;
      Scanner ent=new Scanner(System.in);
      System.out.print("Ingrese elemento");
      valor=ent.nextInt();
      aux=new Nodo(valor);
      if (frente==null)
      frente=aux;
      else
         fin.siguiente=aux;
      fin=aux;
     
     }
    // Método para ELIMINAR UN ELEMENTO

    public static void Eliminar()
    {
        Nodo aux;
        aux=frente;
        fin=aux;
         if (frente==null)
      System.out.println("Lista vacía");
      else
      {
             System.out.println("Eliminando el elemento"+fin.elemento);
             frente=frente.siguiente;
            }
            while(aux!=null&&aux!=fin)
            {
            frente=aux;
            aux=aux.siguiente;
            }
       
       
    }
    //Método para PRESENTAR LOS ELEMENTOS DE UNA COLA CIRCULAR

   public static void Presentar()
    {
    Nodo aux;
     if (frente==null)
      System.out.println("Lista vacía");
     else
        for (aux=frente; aux!=null;)
        {
        System.out.println("Elemento: "+aux.elemento);
        aux=aux.siguiente;
        }    
     
    }
    // Método para limpiar lista
    public static void Limpiar ()
    {
           Nodo aux;
           if (frente==null)
            System.out.println(" !!! Lista Vacia!!!");
            else{
           
                 for(aux=frente; frente!=null;)

                     {
                      frente=null;
                      fin=null;
                      }
                      Presentar();
            }
                     

                }
   
    }

Cola circular

import java.util.Scanner;
public class Colacircular {
       
    /**
     * Creates a new instance of <code>Colacircular</code>.
     */
    public Colacircular()
    {
    }
   
    /**
     * @param args the command line arguments
     */
    public static int frente=0, fin=0;
   
    public static void main(String[] args) {
        // TODO code application logic here
      int max, opcion;
      int [] colacirc;
      Scanner ent=new Scanner(System.in);
      System.out.print("Tamaño de la cola");
      max=ent.nextInt();
      colacirc=new int[max];
      do
      {
      System.out.print("1) Insertar");
      System.out.print("2) Eliminar");
      System.out.print("3) Presentar");
      System.out.print("4) Limpiar");
      System.out.print("5) Salir");
      opcion=ent.nextInt();
      switch (opcion)
         {
     
      case 1 : Insertar(colacirc, max);
      break;
      case 2 : Eliminar (colacirc, max);
      break;
      case 3 : Presentar(colacirc, max);
      break;
      case 4 : frente=0;
              fin=max;
      case 5 : break;
      default : System.out.println("Opción equivocada");
      break;
         }      
        } while(opcion !=5);
    }
   
     public static int siguiente(int posicion, int m)
     {
      return (posicion+1) % m;
     }
     
     public static void Insertar(int []c, int max)
     {
      Scanner ent=new Scanner (System.in);
     if(frente==siguiente(siguiente(fin,max),max))
      System.out.println("        !!!DESBORDAMIENTO DE COLA!!!!      ");
     else{
      fin = siguiente(fin,max);
      System.out.print("Ingrese elemento <<"+fin+">> de la cola :");
      c[fin] = ent.nextInt();
      }
     }
    // Método para ELIMINAR UN ELEMENTO

    public static void Eliminar(int []c, int max)
    {
     if(frente==siguiente(fin,max))
      System.out.println(" !!! COLA VACIA!!!");
     else{
      System.out.println("Eliminando el elemento <<"+frente+">> = "+c[frente]);
      frente=siguiente(frente,max);
     }
    }
    //Método para PRESENTAR LOS ELEMENTOS DE UNA COLA CIRCULAR

    public static void Presentar(int []c, int max){
   
     for(int i=frente; i!=siguiente(fin,max); i=siguiente(i,max))
       System.out.println("Cola["+i+"] = "+c[i]);
     
     }
    }

La cola circular a diferencia de la cola simple, nos permite de manera contínua y finita ingeresar y eliminar elementos, tantos como se haya declarado un arreglo, los espacios se puedes reutilizar constantemente.

Colas

import java.util.Scanner;
public class Cola {
       
    /**
     * Creates a new instance of <code>Cola</code>.
     */
    public Cola() {
    }
    public static int frente=0, fin=0;
    /**
     * @param args the command line arguments
     */
     
    public static void main(String[] args) {
        // TODO code application logic here
        int max, opcion;
        int [] cola;
        Scanner  ent=new Scanner(System.in);
        System.out.print("Tamano de la cola:");
        max=ent.nextInt();
        cola=new int[max];
       
        do {
       
        System.out.println("1)Insertar en cola");
        System.out.println("2)Eliminar elemento");
        System.out.println("3)Presentar cola");
        System.out.println("4)Limpiar cola");
        System.out.println("5)Salir");
        opcion = ent.nextInt();
        switch (opcion)
        {
        case 1: insertar(cola,max);
        break;
        case 2: eliminar(cola);
        break;
        case 3: presentar(cola);
        break;
        case 4: frente=0;
        fin=0;
        break;
        case 5: break;
        default:
        System.out.println("Opción equivocada");
        }      
        } while (opcion !=5);
     }
       
     public static void insertar(int[]c, int m)
        {
        Scanner ent=new Scanner(System.in);
        if (fin<m)
        {
           System.out.print("ingrese valor:");
        c[fin]=ent.nextInt();
        fin++;
        if(fin==1)
        {
        frente=fin;
        }
        }
        else
        {
        System.out.println("!!!DESBORDAMIENTO DE COLA ");
            }
       
        }
        public static void eliminar(int[]c)
        {
       
        if(frente>fin||fin==0)
        {
        System.out.println("!!!COLA SIN DATOS");
        }
        else
        {
        System.out.println("eliminando elemento"+frente);
        System.out.println("c["+frente+"]="+c[frente-1]);
        frente++;
        }
       
        }
       
        public static void presentar (int []c)
        {
         if (frente>fin||fin==0)
        {
        System.out.println("COLA VACIA");
        }
        else
        {
        for(int i=frente;i<=fin; i++)
        {
        System.out.println("cola["+ i +"]"+c[i-1]);
        }
       
          }
       
        }
     
}

La particularidad de una estructura de datos de cola es el hecho de que sólo podemos acceder al primer y al último elemento de la estructura. Así mismo, los elementos sólo se pueden eliminar por el principio y sólo se pueden añadir por el final de la cola.

Pilas

import java.util.Scanner;
public class Pilas {
       
    /**
     * Creates a new instance of <code>Pilas</code>.
     */
    public Pilas() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
               
        int n, opcion, cima=0;
        int [] pilas;
        Scanner  ent=new Scanner(System.in);
        System.out.print("Tamano de la pila:");
        n=ent.nextInt();
        pilas=new int[n];
       
        do {
       
        System.out.println("1)Push");
        System.out.println("2)Pop");
        System.out.println("3)Presentar Pila");
        System.out.println("4)Limpiar Pila");
        System.out.println("5)Salir");
        opcion = ent.nextInt();
        switch (opcion)
        {
        case 1: cima=push(pilas,cima);
        break;
        case 2: pop(pilas, cima);
        break;
        case 3: presentar(pilas,cima);
        break;
        case 4: cima=0;
        break;
        case 5: break;
        default:
        System.out.println("Opcion equivocada");
        }      
        } while (opcion !=5);
     }
       
     public static int push(int[]p, int c)
        {
        Scanner ent=new Scanner(System.in);
        if (c<p.length)
        {
        c++;
        System.out.print("ingrese elemento "+c+":");
        p[c-1]=ent.nextInt();
        }
        else
        {
        System.out.println("!!!PILA LLENA");
        System.out.println("elimine un elemento");
        }
        return c;
        }
        public static int pop(int[]p,int c)
        {
        Scanner ent=new Scanner(System.in);
        if(c!=0)
        {
        System.out.println("Se elimino el elemento"+c+"= "+p[c-1]);
        c--;
        }
        else
        {
        System.out.println("!!!PILA SIN DATOS");
        }
        return c;
       
        }
        public static void presentar (int []p, int c)
        {
        if (c!=0)
        {
        System.out.println("Mostrando datos de pila");
        for (int i=c-1; i>=0; i--)
        {
        System.out.println("elemento" + i +":"+p[i]);
        }
        }
        else
        {
        System.out.println("PILA VACIA");
        }
        }
         
}

Una pila es una lista ordenada de datos en la que el modo de acceso a sus elementos es el último en entrar, primero en salir que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de la informática debido a su simplicidad y ordenación implícita de la propia estructura.

Programa método de la burbuja

import java.util.Scanner;
public class ArregloOrdenado {  
    /**
     * Creates a new instance of <code>ArregloOrdenado</code>.
     */
    public ArregloOrdenado() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
     
        int n;
        int [] x;
        Scanner entrada = new Scanner (System.in);
        System.out.print("Tamaño del arreglo\n");
        n=entrada.nextInt();
        x=new int [n];
        leedatos(x);
        muestradatos(x);
        ordenadatos(x);        
}
    public static void leedatos(int[]a)
    {
    Scanner ent=new Scanner (System.in);
    for (int i=0; i<a.length; i++)
    {
   
    System.out.print("Ingresa elemento a["+i+"]");
    a[i]=ent.nextInt();
    }
   
    }
public static void muestradatos(int []a)
{
for (int i=0; i<a.length; i++)
{
System.out.println("Muestra datos a["+i+"]"+a[i]);
}
}
// ordenamiento con el método de la burbuja
public static void ordenadatos(int[ ]a)
{
             int aux;
for(int i = 0; i < a.length; i++)
{
for (int j = i + 1; j < a.length; j++){
if(a[j]< a[i]){
aux = a[i];
a[i]=a[j];
a[j]=aux;
                 
                     }
            }          
        }
        System.out.println("El arreglo ordenado es: ");
                    for (int i = 0; i < a.length; i++)
                    {              
                    System.out.println("En forma ascendente a["+i+"]="+a[i]);
                    }
                   
         }
       
}

Este es un programa de arreglo que nos muestra los datos ingresados al programas y nos los ordena de manera ascendente con el método de la burbuja, el cual de manera muy sencilla nos permite realizar la acción de ordenar con un mínimo de código, para el caso de ordenar en forma descendente, solo será necesario cambiar el símbolo de menor a mayor. El método de la burbuja utiliza un auxiliara para almacenar los datos de manera provisional para escalar los datos que serán movidos para se ordenados de acuerdo a necesidad del usuario.

Arreglo multidimensional

import java.util.Scanner;
public class ArregloMultidimensional {
       
    /**
     * Creates a new instance of <code>ArregloMultidimensional</code>.
     */
    public ArregloMultidimensional() {
    }
   
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int [][]x;
        int n, m;
        Scanner  ent=new Scanner (System.in);
        System.out.print ("Ingrese numero de renglones");
        n=ent.nextInt();
        System.out.print ("Ingrese numero de columnas");
        m=ent.nextInt();
        x=new int[n][m];
        leerdatos(x);
        presentar (x);
    }
    public static void leerdatos(int[][]a)
    {
    Scanner ent=new Scanner(System.in);
    System.out.println("Ingrese los datos");
    for (int i=0; i<a.length; i++)
    {
   
for(int j=0; j<a[i].length; j++ )
{
System.out.print("a["+i+"]["+j+"]=");
a[i][j]=ent.nextInt();
}
}
    }
    public static void presentar(int[][]a)
    {
   
   
    for (int i=0; i<a.length; i++)
    {
   
for(int j=0; j<a[i].length; j++ )
{
System.out.print(a[i][j]+ "  ");
}
System.out.println();
}
    }
}

Este es un programa arreglo de dos dimensiones, es decir, mediante índices nos permite conocer la ubicación de un elemento dentro del arreglo, razón por la que desde el main se declaran dos variables y doble corchete en una misma variable para indicar que se trata de un arreglo bidimensional.

Arreglo con instrucciones desde el main

public ArregloVersion2() {

    }

    

    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

        // TODO code application logic here

        int n;

        int [] x;

        Scanner entrada = new Scanner (System.in);

        System.out.print("Tamaño del arreglo");

        n=entrada.nextInt();

        x=new int [n];

        leedatos(x);

        muestradatos(x);

        

        System.out.println("el menor es: "+menor(x));

        System.out.println("el mayor es: "+mayor(x));

        System.out.println("el promedio es: "+promedio(x));

    }    

    

    public static void leedatos(int[]a)

    {

    Scanner ent=new Scanner (System.in);

    for (int i=0; i<a.length; i++)

    {

    

    System.out.print("Ingresa elemento a["+i+"]");

    a[i]=ent.nextInt();

    }

    

    }

 public static void muestradatos(int []a)

 {

 for (int i=0; i<a.length; i++)

 {

 System.out.println("Muestra datos a["+i+"]"+a[i]);

 }

 }

 public static int menor (int[]a)

 {

  int min= a[0];

  for (int i=0; i< a.length; i++)

  { 

  if (a[i]<min)

   min=a[i];

  }

  return min;

 } 

 public static int mayor (int[]a)

 {

  int may= a[0];

  for (int i=0; i< a.length; i++)

  {

  if (a[i]>may)

   may=a[i];

  }

  return may;

    }

    public static double promedio (int[]a)

    {

        double prom=0, suma=0;     

     for (int i=0; i<a.length; i++)

         

      suma+=a[i];

      prom=(suma/a.length);

    

     return prom;

    

    } 

}

En este programa desde el main se declaran las variables y el código para realizar las operaciones o acciones deseadas mediante la sentencia for en donde esta sentencia me permite repetir n veces un ciclo, en donde se debe determinar  el valor inicial y cuantas veces se va a repetir. Así no es necesario repetir tanto código, lo anterior aunado a lo práctico que es un arreglo con "n" posiciones, minimizando la cantidad de código a escribir. Desde el main se declara la acción a ejecutar.

Arreglo

public ArregloUni() {

    }

    

    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

        // TODO code application logic here

        int n;

        int [] x;

        Scanner entrada = new Scanner (System.in);

        System.out.print("Tamaño del arreglo");

        n=entrada.nextInt();

        x=new int [n];

        System.out.println ("Arreglo creado de "+n+ "posiciones");

        

        for (int i=0; i<n; i++)

        {

        

         System.out.print("Elemento x["+i+"]=");

         x[i]= entrada.nextInt();

        }

        for (int i=0; i<n; i++)

        {

         System.out.println("x["+i+"]="+x[i]);

        

        

        }  

        // Mostrar el elemento menor y elemento mayor

        

        int menor=0, mayor=0;

        

        for (int i=0; i<n; i++)

        {

         if (i==0)

         {

          menor=x[i];

          mayor=x[i];

         }

         else

         {

          if(x[i]<menor)

           menor=x[i];

          if(x[i] > mayor)

           mayor = x[i];

         }

         }

  System.out.println("menor="+ menor);

  System.out.println("mayor="+ mayor);

      double suma=0, promedio=0;

      for (int i=0; i<n; i++)

      {

        suma=suma +x[i];

        promedio=(suma/n);

      }

     System.out.print("El promedio es:"+promedio);    

}

}

Este es un programa de array o arreglo que nos permite almacenar un "n" número de datos sin necesidad de extender el código de un programa y mediante métodos específicos, podemos realizar las operaciones deseadas con solo definir en el método la cantidad de posiciones que se deseen en el arreglo y solicitar nos indique cual de los elemento es el menor, mayor o el promedio de ellos.