El documento explica los conceptos básicos de los arreglos en Java, incluyendo cómo declarar y acceder a elementos de un arreglo, y métodos comunes para trabajar con arreglos como búsqueda, ordenamiento y eliminación de elementos. También describe los algoritmos de búsqueda lineal y binaria, explicando que la búsqueda binaria es más eficiente para arreglos ordenados. Finalmente, presenta el método de ordenamiento por burbuja como una opción simple pero lenta para ordenar arreglos.

1. Arregl
os
De
Java

2. Que es un arreglo
Un arreglo es un grupo de posiciones de
memorias contiguas, todas las cuales tienen el
mismo nombre y el mismo tipo.
Para referirnos a una posición o elemento en
particular del arreglo, especificamos el nombre
del arreglo y el numero de posición de ese
elemento en el arreglo.
Ejemplo:

3. Nombre del arreglo(observen que
todos los elementos de este
arreglo tiene el mismo nombre, c)
-45
6
0
72
1543
-89
0
62
-3
1
6453
78
C[0]
C[1]
C[2]
C[3]
C[4]
C[5]
C[6]
C[7]
C[8]
C[9]
C[10
]
C[11]
Numero de posición del
elemento dentro del arreglo c

4. Nombre del arreglo(observen que
todos los elementos de este
arreglo tiene el mismo nombre, c)
-45
6
0
72
1543
-89
0
62
-3
1
6453
78
C[0]
C[1]
C[2]
C[3]
C[4]
C[5]
C[6]
C[7]
C[8]
C[9]
C[10
]
C[11]
Numero de posición del
elemento dentro del arreglo c

5. Cual es la sintaxis para declarar un
arreglo
El programador especifica el tipo de los
elementos y usa el operador new para asignar
espacio de almacenamiento al numero de
elementos requerido por cada arreglo. Para
asignar a la memoria a los 12 elementos del
arreglo c usamos la declaración:
Int c[] = new int [ 12 ];

6. Tipo de arreglo para dos pasos
El enunciado anterior también puede realizarse
en dos pasos como sigue:
Int c[] ; // declarar el arreglo
C = new int [ 12 ] ; //asigna memoria al
arreglo
66

7. culés son las operaciones básicas
para trabajar en arreglos
• - Insertar elementos
• - Búsqueda de elementos
• - Eliminar elementos
• - Mostrar los elementos
• - Ordenar los elementos
• - Modificar algún elemento
77

8. Como se arregla
88

9. Como se elimina
• Entiendo que por arreglo te refieres a un array.
• Estos elementos son memoria estatica, es decir, se
reserva un espacio en memoria para ese array del
tamaño que sea y no se libera hasta que acaba la
ejecución. Por lo que no puedes eliminar un dato de
un array, pues esa memoria permanece ahí.
99

10. • Pero lo que sí puedes hacer es sobreescribir
ese valor por otro, por ejemplo si es un array
de objetos, puedes poner la posicion a
eliminar con valor null, ejemplo suponiendo
que quieras eliminar el 5º elemento:
• Objeto[] array = new
Objeto[10];//Inicializamos el arrayfor(int i = 0;
i < array.length; i++) array[i]=new
Objeto();//Eliminamos el quinto
elementoarray[4]=null;

11. • Si el array no es de objetos y es de tipos
primitivos (int, byte, char, float,
double,boolean) no lo puedes poner a null,
pero puedes elegir tu algún valor que sepas
que significa "eliminado", por ejemplo en el
caso de int un valor negativo puede significar
eliminado para ti. O puedes tener un array
secundario de tipo boolean que se llame
eliminiados y de la misma longitud que el
original, de tal manera que si un dato ya no es
válido, lo marques como true en el array
"eliminados".Ejemplo:

12. • int[] array = new int[10];boolean[] eliminados
= new boolean[10];//Inicializamos el
arrayfor(int i = 0; i < array.length; i++){
array[i]=i; eliminados[i]=false;}//Eliminamos
el quinto elementoeliminados[4]=true;
• Luego cuando vayas usar los datos, harías una
comprobación del tipo:
• if(!eliminados[x])....else System.out.println("El
dato "+x+" ha sido eliminado!");

13. Como se accede un arreglo...
1133

14. Los métodos de ordenamiento y
búsqueda ( lineal y binaria )
En esta sección veremos la técnica de búsqueda : la técnica simple de
búsqueda lineal y la técnica de búsqueda binaria mas eficiente, con su
método.
 Búsqueda lineal compara cada elemento del arreglo con la clave de
búsqueda ,pues que el arreglo no esta en ningún orden especifico, es
igualmente probable que el valor se encuentre en el primer elemento
que en el ultimo, por tanto el programador tendrá que comparar la
clave de búsqueda con la mitad de los elementos del arreglo.
Ejemplo:
1144

15. • // búsqueda lineal en un arreglo
• Import java.awt.*;
• Import java.applet.applet;
• Public class LinearSearch extends Applet {
• Int a[];
• Int element;
• String searchKey; // clave de búsqueda
• Label enterLabel; //rotulo para la entrada
• TextField enter; //campo de texto para la entrada
• Label resultLabel; //rotulo para resultado
• TextField result; // campo de texto para resultado
• Public void init ()
• {
• a = new int [100];
• for ( int i = 0; < a.length; i++ ) // crear los datos
• a [ i ] = 2* i ;

16. • enterLabel = new Label (‘’Teclee clave de búsqueda entera’’);
• Enter =new TextField(10);
• Resultlabel=new label (‘’Resultado’’);
• Result=new Textfield (25);
• Result.setEditable ( false );
• Add ( enterLabel);
• Add ( enter );
• Add ( resultLabel );
• Add ( result);
• }
• Public int LinearSearch ( int key ) // búsqueda lineal ( int clave )
• {
• For ( int n = 0; n < a.length ; n++ )
• if ( a [ n ] == key )
• return n ;
• return -1 ;

17. • El método de búsqueda lineal funciona bien con arreglos pequeños
o arreglos no ordenados. Sin embargo, en el caso de arreglos
grandes la búsqueda lineal no es eficiente. Si el arreglo esta
ordenado podemos usar la técnica de búsqueda binaria de alta
velocidad.

18. Búsqueda Binaria
• El algoritmo de búsqueda binaria elimina de la búsqueda la mitad de
los elementos de los arreglo que quedan después de cada
comparación. El algoritmo encuentra el elemento situado a la mitad
del arreglo y lo compara con la clave de la busqueda.Sin son iguales,
se habrá encontrado la clave y se devolverá el subíndice del elemento
en cuestión; si no , el problema se reduce buscar en la mitad del
arreglo.
• Si la clave de búsqueda es menor que el elemento del medio del
arreglo, se busca en la primera mitad del arreglo; si no, se busca en
la segunda mitad del arreglo, si la clave de brusquedad no es el
elemento que esta en la mitad del subarreglo especificado (
fragmento del arreglo original ), el algoritmo se repite con la cuarta
parte del arreglo original .

19. • La búsqueda continua hasta que la clave de búsqueda sea
igual al elemento medio de un subarreglo o hasta que el
subarreglo consista en un solo elemento que no sea igual a la
clave de búsqueda ( es decir, no se encontró la clave).
• Ejemplo:
• // búsqueda binaria de un arreglo
• import java.awt .* ;
• Import java.applet.applet;
• Public class binarysearch extends applet {
• int a [];
• int element;
• string searchkey ; // clave de búsqueda
• int xposition ; // posición horizontal para dibujar en
la applet

20. • int Y posición; // posición vertical para dibujar en la applet
• Label enterLabel ;
• Textfield enter ;
• Label resultLabel ;
• Textfield result; // campo de texto para el resultado
• Boolean timetosearch
• public void init ()
• {
• a = new int [15];
• For ( int i = 0; i < a.length; i++ ) // crear los datos
• a [ i ] = 2 + i ;
• enterLabel = new Label (´´ teclee la clave ´´ );
• Enter = new TextField ( 5 );
• resultLabel = new Label ( ´´ Resultado ´´ );
• Result .setEditable ( false );
• Add ( enterLabel );
• Add (enter );
• Add ( resultLabel );
• Add ( result );
• }

21. • Public void paint ( Graphics g )
• If (timeTosearch ) {//evitar buscar en la primera
invocacion
• element =nbinarysearch {
• Integer . Parseint ( searchkey ) , g );
• If ( element ! = -1 )
• Result.setText {
• ´´ valor hallado en elemento ´´+ element );
• }
• }
• Public boolean action ( Event event, object o )
• {

22. • If ( eveny.target == enter ) {
• timeToSearch = true ;
• Xposition = 25;
• Yposition =75;
• }
• // búsqueda binarySearch ( int key , Graphics gg )
• {
• Gg.drawstring (‘’proporciones del arreglo en que se
busco’’ , xposicion, y posición);
• Y posicion += 15;
• Int low = 0; //subindice bajo
• Int high = a. length – 1; // subindice alto
• Int middle; //subindice medio

23. • While (low <=high) {
• middlen =( low + high ) / 2;
• printRow(low, mddle, hagh, gg);
• If ( key < a[ middle ] ) // se encontro return middle;
• Else if ( key < a [ middle ] )
• High = middle -1; // buscar parte baja del arreglo else
• Low = middle + 1; // buscar parte alta del arreglo
• }
• Return -1; // no se encontro searchkey
• }
• // imprimir una fila de salida mostrndo la parte
• // del arreglo que se esta procesando ahora.

24. • Void printRow ( int low, int mid, int high, grapics
gg)
• {
• xPosicion =25;
• For ( int i = 0; i < a. Length; i++ ) {
• If ( i < low || i > high )
• Gg.draString(‘’’’, xposicion, yposicion);
• Else if ( i == mid ) // marcar valor medio
• Gg. drawString( String. valueOF ( a[ i ]) + ´’’*’’,
• xposicion, yposicion ); else
• Gg.drawString ( aString. valueOF ( a [ i ] ) ,
• xposition, yposition );
• Xposition += 20;

25. • }
• Yposition += 15;
• }
• })
• Public boolean action ( event , object o )
• {
• If ( event.target ==enter ) {
• Searchkey = event .arg.tostring( );o en el elemento ‘’
• Element = linearsearch _( interger.parseInt (
seachkey ) );
• If ( element != -1 )
• Result . setText ( ‘’valor hallad

26. Método de Burbuja
El ordenamiento de burbuja consiste es decir, colocar
los datos en un orden especifico, como ascendente o
descendente es una de la aplicaciones computacionales
mas importantes .
El método de burbuja es también llamado intercambiar
según sea necesario para intercambiar dos elementos
del arreglo.
La principal virtud del ordenamiento de burbuja es que
es fácil de programar. Sin embargo. Este ordenamiento
se ejecuta con lentitud, cosa que se hace evidente si
ordenamos arreglos grandes.