Guia Introductoria para Empezar A Programar V 1.2

Estructura
de Datos
Guía de estudio
Mtra. Beatriz Arias Espinoza
ESTRUCTURA DE DATOS
GUÍA DE INICIO A LA ASIGNATURA
M. BEATRIZ ARIAS ESPINOZA
Índice
INTRODUCCIÓN A JAVA....................................................................................................................... 3
INSTALACIÓN DEL ENTORNO DE PROGRAMACIÓN ............................................................................ 5
PRIMEROS PROGRAMAS ..................................................................................................................... 7
Crear un proyecto ........................................................................................................................... 7
Hola mundo ................................................................................................................................... 10
Solicitar un número entero, guardarlo y mostrarlo en consola .................................................... 11
Solicitar un número flotante, guardarlo y mostrarlo en consola .................................................. 11
Solicitar una cadena de caracteres, guardarla y mostrarla en consola ........................................ 12
Mostrar un mensaje en modo gráfico (Ventana) .......................................................................... 12
Solicitar una variable en una ventana y después desplegarla en modo gráfico ........................... 13
SENTENCIAS DE CONTROL ................................................................................................................. 14
IF .................................................................................................................................................... 14
IF.. ELSE.......................................................................................................................................... 15
Switch ............................................................................................................................................ 18
Ciclo while ..................................................................................................................................... 20
Ciclo do while ................................................................................................................................ 21
Ciclo for ......................................................................................................................................... 25
ARREGLOS ......................................................................................................................................... 28
Declaración de arreglos................................................................................................................. 29
Inicialización de arreglos ............................................................................................................... 29
Definir tamaño de arreglos: .......................................................................................................... 30
Asignación de valores a elementos del array ................................................................................ 30
¿Cómo insertar desde consola, elementos en un arreglo?........................................................... 32
¿Cómo muestran en consola los elementos de un arreglo? ......................................................... 32
Notas adicionales: ......................................................................................................................... 33
Recorrido de arreglos .................................................................................................................... 35
CREACIÓN DE ARCHIVOS ................................................................................................................... 39
ORDENACION .................................................................................................................................... 41
Burbuja .......................................................................................................................................... 41
1
ESTRUCTURA DE DATOS
QuickSort ....................................................................................................................................... 43
2
ESTRUCTURA DE DATOS
INTRODUCCIÓN A JAVA
Java, el lenguaje orientado a objetos diseñado para ser multiplataforma y poder ser empleado el
mismo programa en diversos sistemas operativos.
Como cualquier lenguaje de programación, el lenguaje Java tiene su propia estructura, reglas de
sintaxis y paradigma de programación1. El paradigma de programación del lenguaje Java se basa
en el concepto de programación orientada a objetos (POO), que las funciones del lenguaje
soportan. En la POO, el comportamiento del programa es llevado a cabo por objetos, entidades
que representan elementos del problema a resolver y tienen atributos y comportamiento.
El lenguaje Java es un derivado del lenguaje C, por lo que sus reglas de sintaxis se parecen mucho a
C: por ejemplo, los bloques de códigos se modularizan en métodos y se delimitan con llaves ({ y })
y las variables se declaran antes de que se usen.
Estructuralmente, el lenguaje Java comienza con paquetes. Un paquete es el mecanismo de

espacio de nombres del lenguaje Java. Dentro de los paquetes se encuentran las clases y dentro de
las clases se encuentran métodos, variables, constantes, entre otros.
El compilador Java
Cuando programas para la plataforma Java, escribes el código de origen en archivos .java y luego
los compilas. El compilador verifica el código con las reglas de sintaxis del lenguaje, luego escribe
los códigos byte en archivos .class. Los códigos byte son instrucciones estándar destinadas a
ejecutarse en una Java Virtual Machine (JVM). Al agregar este nivel de abstracción, el compilador
Java difiere de los otros compiladores de lenguaje, que escriben instrucciones apropiadas para el
chipset de la CPU en el que el programa se ejecutará.
La JVM
Al momento de la ejecución, la JVM lee e interpreta archivos .class y ejecuta las instrucciones del
programa en la plataforma de hardware nativo para la que se escribió la JVM. La JVM interpreta
los códigos byte del mismo modo en que una CPU interpretaría las instrucciones del lenguaje del
conjunto. La diferencia es que la JVM es un software escrito específicamente para una plataforma
particular. La JVM es el corazón del principio "escrito una vez, ejecutado en cualquier lugar" del
1
Un paradigma de programación puede ser entendido como una forma o un estilo de programar. Podemos
hablar de un paradigma como un conjunto de creencias, prácticas y conocimientos que guían el desarrollo
de una disciplina durante un período de tiempo.
3
ESTRUCTURA DE DATOS
lenguaje Java. Su código se puede ejecutar en cualquier chipset para el cual una implementación
apropiada de la JVM está disponible. Las JVM están disponibles para plataformas principales como
Linux y Windows y se han implementado subconjuntos del lenguaje Java en las JVM para teléfonos
móviles y aficionados de chips.
El kit de desarrollo de Java
Cuando descargas un kit de desarrollo de Java (JDK), obtienes (además del compilador y otras
herramientas), una librería de clase completa de programas de utilidad preconstruidos que lo
ayudan a cumplir cualquier tarea común al desarrollo de aplicaciones. El mejor modo para tener
una idea del ámbito de los paquetes y bibliotecas JDK es verificar la documentación API JDK
(https://docs.oracle.com/javase/7/docs/api/).
El Java Runtime Environment
El Java Runtime Environment (JRE, también conocido como el Java Runtime) incluye las bibliotecas
de códigos de la JVM y los componentes que son necesarios para programas en ejecución escritos
en el lenguaje Java. Está disponible para múltiples plataformas. Puede redistribuir libremente el
JRE con sus aplicaciones, de acuerdo a los términos de la licencia del JRE, para darles a los usuarios
de la aplicación una plataforma en la cual ejecutar su software. El JRE se incluye en el JDK.
4
ESTRUCTURA DE DATOS
INSTALACIÓN DEL ENTORNO DE PROGRAMACIÓN
Durante la asignatura realizarás códigos en un entorno de programación (Integrated Development

Environment- IDE). Un IDE es un programa o conjunto de programas que engloban todas las tareas
necesarias para el desarrollo de un programa o aplicación. Estas tareas son:
 Edición del programa.

 Compilación y enlazado.
 Ejecución.
 Depuración.
Este tipo de entornos incorporan numerosas herramientas, utilidades, aplicaciones ya

desarrolladas, ejemplos, tutoriales, etc. Todas ellas encaminadas a facilitar y mejorar el desarrollo.
En el curso estaremos utilizando NetBeans, para descargarlo es necesario ir a la página:

https://netbeans.org/downloads/8.1/ y descargar el paquete de Java SE (en este momento, no
requerimos de más características).
Después deberás realizar la descarga del JDK de java (Java Development Kit), que no es más que
un conjunto de herramientas (librerías y programas) que permiten desarrollar programas en
lenguaje Java. Cuando hablamos de desarrollar esto incluye compilar, ejecutar, generar
documentación, etc.
El JDK lo puedes descargar en el link:

https://www.oracle.com/technetwork/es/java/javase/downloads/index.html
5
ESTRUCTURA DE DATOS
Te redirigirá a un apartado donde deberás elegir el JDK más adecuado para tu computadora
personal.
Para verificar características de tu equipo, puedes abrir cualquier explorador de archivos, dar clic
derecho en equipo y seleccionar propiedades:
Esto te ayudará a obtener una ventana como la siguiente. En la ventana de propiedades del
Sistema lo que nos interesa es conocer el tipo de sistema (aunque la mayoría de las computadoras
ya trabajan a 64 bits).
6
ESTRUCTURA DE DATOS
Si tu computadora coincide con el ejemplo de la imagen, deberás dar clic en Aceptar Licencia y
seleccionar jdk-8u201-windows-x64.exe.
Ya que tengas descargados los dos ejecutables en tu computadora deberás iniciar con el jdk y
después instalar el NetBeans.
Una vez instalados los dos elementos podrás iniciar a programar.
PRIMEROS PROGRAMAS
Crear un proyecto
En NetBeans se trabaja
Lo primero que debes hacer será dirigirte al menú File y seleccionar New Project.
Aparecerá una pantalla como la siguiente. Selecciona los elementos como lo muestra la imagen:
7
ESTRUCTURA DE DATOS
Deberás nombrar al proyecto que vayas a realizar e identificar la ruta donde se guardará tus
programas:
Si en algún momento quisieras guardar en usb el programa. Deberás ir a la ruta que marca y copiar
toda la carpeta que tiene el nombre del proyecto. Por ejemplo:
8
ESTRUCTURA DE DATOS
Ahora es momento de empezar a crear el primer programa. Identifica el área de trabajo:
Toda aplicación de consola en Java básica, contiene una clase principal con un método main. El
método main es lo primero que se ejecuta cuando se inicia la aplicación desde la línea de
comandos, es decir que la ejecución del programa comienza desde allí. De esta forma podemos
deducir que cualquier llamado, declaración o método que no sea utilizado de manera directa o
indirecta desde el método main nunca se ejecutará.
La estructura básica de un programa desarrollado usando Java es la siguiente:
9
ESTRUCTURA DE DATOS
Hola mundo
A continuación se muestran algunos ejemplos de programas en NetBeans:
10
ESTRUCTURA DE DATOS
Solicitar un número entero, guardarlo y mostrarlo en consola
Solicitar un número flotante, guardarlo y mostrarlo en consola
11
ESTRUCTURA DE DATOS
Solicitar una cadena de caracteres, guardarla y mostrarla en consola
Mostrar un mensaje en modo gráfico (Ventana)
12
ESTRUCTURA DE DATOS
Solicitar una variable en una ventana y después desplegarla en modo gráfico
Al ejecutar el programa resultará:
13
ESTRUCTURA DE DATOS
SENTENCIAS DE CONTROL
Los ejemplos de esta sección se enfocan en el proceso de desarrollo de programas. Se exponen los
tipos primitivos de instrucciones de control para la tomas de decisiones (if, else, if… else, while,
do…while, for, switch, etc.). Los ejemplos también muestran el manejo de la repetición controlada
por contador y por centinela, y se introducen los operadores de incremento, decremento y
asignación de Java y las instrucciones break y switch.
IF
Es la instrucción condicional más usada en los diversos lenguajes de programación, su formato de
trabajo en JAVA es :
//cargar o asignar la variable de condición;
if (condición)
grupo cierto de instrucciones;
Ejemplo: El siguiente programa solicita una calificación y después indica si ésta es reprobatoria
14
ESTRUCTURA DE DATOS
La salida de este programa sería:
IF.. ELSE
Es la instrucción condicional más usada en los diversos lenguajes de programación, su formato
completo y de trabajo en JAVA es :
//cargar o asignar la variable de condición;
if (condición)
else
15
ESTRUCTURA DE DATOS
Ejemplo:
Continuando con el ejemplo anterior, se puede agregar otra posible respuesta al ingreso de una
calificación.
La ejecución sería:
16
ESTRUCTURA DE DATOS
Ejemplo 2: Un ejemplo completo del if else se muestra a continuación.
Supongamos que se desea escribir un programa que clasifique según el contenido de una variable
valor, asigne una letra a una variable clasificación:
A para un valor del 100-91,
B de 90-81,
C para 80-71 y
F si no es ninguno de los anteriores:
El resultado sería:
17
ESTRUCTURA DE DATOS
Switch
La instrucción switch() es una instrucción de decisión múltiple, donde el compilador prueba o

busca el valor contenido en una variable contra una lista de constantes ints o chars, cuando el
computador encuentra el valor de igualdad entre variable y constante, entonces ejecuta el grupo
de instrucciones asociados a dicha constante, si no encuentra el valor de igualdad entre variable y
constante, entonces ejecuta un grupo de instrucciones asociados a un default, aunque este último
es opcional.
En JAVA el formato de esta instrucción es el siguiente;
//capturar o asignar variable de condición;
switch( condición)
case 1:
instrucción(es);
break;
case 2:
instrucción(es);
break;
default:
instrucción(es);
18
ESTRUCTURA DE DATOS
Ejemplo de switch: Se crea un programa donde el usuario ingresa un mes en número y el

programa le dirá en literal de qué mes se trata.
La salida del programa es:
19
ESTRUCTURA DE DATOS
Ciclo while
En este ciclo el cuerpo de instrucciones se ejecuta mientras una condición permanezca como
verdadera, en el momento en que la condición se convierte en falsa el ciclo termina.
Su formato general es :
//cargar o inicializar variable de condición;
while(condición)
instrucción(es) para salir del ciclo;
};
Ejemplo de while: A continuación se muestra el código para la impresión en pantalla de los

números impares comprendidos entre el 1 y el 10.
Observa que se inicializa una variable j en uno y después viene la condición while, es decir,
mientras la variable j sea menor que diez, se imprimirá en pantalla el valor de dicha variable.
20
ESTRUCTURA DE DATOS
La ejecución del programa sería:
Ciclo do while
Su diferencia básica con el ciclo while es que la prueba de condición es hecha al finalizar el
ciclo, es decir las instrucciones se ejecutan cuando menos una vez, porque primero ejecuta las
instrucciones y al final evalúa la condición;
También se le conoce por esta razón como ciclo de condición de salida.
Su formato general es :
//cargar o inicializar variable de condición;
do {
//grupo cierto de instrucción(es);
} while (condición);
Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo menos una vez se
ejecutará el bloque repetitivo.
La condición de la estructura está abajo del bloque a repetir, a diferencia del while o del for que
está en la parte superior.
Representación gráfica:
21
ESTRUCTURA DE DATOS
Ejemplo: Escribir un programa que solicite la carga de un número entre 0 y 999, y nos muestre un
mensaje de cuántos dígitos tiene el mismo. Finalizar el programa cuando se cargue el valor 0.
No hay que confundir los rombos de las estructuras condicionales con los de las estructuras
repetitivas do while.
22
ESTRUCTURA DE DATOS
En este problema por lo menos se carga un valor. Si se carga un valor mayor o igual a 100 se trata
de un número de tres cifras, si es mayor o igual a 10 se trata de un valor de dos dígitos, en caso
contrario se trata de un valor de un dígito. Este bloque se repite hasta que se ingresa en la variable
valor el número 0 con lo que la condición de la estructura do while retorna falso y sale del bloque
repetitivo finalizando el programa.
El programa sería:
Observa la salida del programa anterior, nota que el programa termina en el momento en el que el
usuario ingresa un número cero, mientras no lo haga, el programa solicita un valor entre 0 y 999
una y otra vez.
23
ESTRUCTURA DE DATOS
El ciclo do while lo podemos utilizar cuando requerimos de la repetición de una tarea, por ejemplo
un menú (switch). Observa el siguiente ejemplo:
El resultado del programa anterior sería:
24
ESTRUCTURA DE DATOS
Ciclo for
Cualquier problema que requiera una estructura repetitiva se puede resolver empleando la
estructura while. Pero hay otra estructura repetitiva cuyo planteo es más sencillo en ciertas
situaciones.
En general, la estructura for se usa en aquellas situaciones en las cuales CONOCEMOS la cantidad
de veces que queremos que se ejecute el bloque de instrucciones. Ejemplo: cargar 10 números,
ingresar 5 notas de alumnos, etc. Conocemos de antemano la cantidad de veces que queremos
que el bloque se repita. Veremos, sin embargo, que en el lenguaje Java la estructura for puede
usarse en cualquier situación repetitiva, porque en última instancia no es otra cosa que una
estructura while generalizada.
Representación gráfica:
25
ESTRUCTURA DE DATOS
En su forma más típica y básica, esta estructura requiere una variable entera que cumple la
función de un CONTADOR de vueltas. En la sección indicada como "inicialización contador", se
suele colocar el nombre de la variable que hará de contador, asignándole a dicha variable un valor
inicial. En la sección de "condición" se coloca la condición que deberá ser verdadera para que el
ciclo continúe (en caso de un falso, el ciclo se detendrá). Y finalmente, en la sección de
"incremento contador" se coloca una instrucción que permite modificar el valor de la variable que
hace de contador (para permitir que alguna vez la condición sea falsa)
Cuando el ciclo comienza, antes de dar la primera vuelta, la variable del for toma el valor indicado
en la sección de de "inicialización contador". Inmediatamente se verifica, en forma automática, si
la condición es verdadera. En caso de serlo se ejecuta el bloque de operaciones del ciclo, y al
finalizar el mismo se ejecuta la instrucción que se haya colocado en la tercer sección.
Seguidamente, se vuelve a controlar el valor de la condición, y así prosigue hasta que dicha
condición entregue un falso.
Si conocemos la cantidad de veces que se repite el bloque es muy sencillo emplear un for, por
ejemplo si queremos que se repita 50 veces el bloque de instrucciones puede hacerse así:
La variable del for puede tener cualquier nombre. En este ejemplo se la ha definido con el nombre
f.
Analicemos el ejemplo:
26
ESTRUCTURA DE DATOS
La variable f puede ser modificada dentro del bloque de operaciones del for, aunque esto podría
causar problemas de lógica si el programador es inexperto.
La variable f puede ser inicializada en cualquier valor y finalizar en cualquier valor. Además, no es
obligatorio que la instrucción de modificación sea un incremento del tipo contador (f++).
Cualquier instrucción que modifique el valor de la variable es válida. Si por ejemplo se escribe
f=f+2 en lugar de f++, el valor de f será incrementado de a 2 en cada vuelta, y no de a 1. En este
caso, esto significará que el ciclo no efectuará las 50 vueltas sino sólo 25.
La Sintaxis empleada por el ciclo for es la siguiente:
//instrucciones;
}
 Las tres partes del ciclo se encuentran separadas por ; (punto y coma)
 La primer parte del ciclo especifica valores previos a su inicio.
 La segunda parte indica la condición de terminación para el ciclo, la cual está directamente
relacionada con los valores iniciales.
 Finalmente, la última parte especifica cómo serán manipulados los valores iniciales en
cada iteración del ciclo.
Cada parte del ciclo debe incluir al menos un elemento, a la cual es posible agregar otros
elementos a partir de una , (coma).
Ejemplo: A continuación se utiliza un ciclo for para mostrar los números pares comprendidos
entre el 1 y el 10.
27
ESTRUCTURA DE DATOS
Al ejecutar el programa, el resultado es el siguiente:
INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS
ARREGLOS
Los arreglos (arrays) son estructuras de datos que guardan datos del mismo tipo. Cada uno de los
elementos del array tiene asignado un índice numérico de acuerdo con su posición, siendo 0 el
índice del primero.
Por ejemplo:
A 12 2 3 5 77 4
0 1 2 3 4 5
El arreglo se llama A, guarda 6 elementos de tipo entero (int).
G a e i o u
0 1 2 3 4
El arreglo se llama G, y guarda 5 elementos de tipo char.
28
ESTRUCTURA DE DATOS
0 1
0
Nombres Diana Juan
1
Maria Rosy
2
Edgar Luis
3
Diego Aldo
El arreglo se llama Nombres y guarda 8 elementos de tipo String en 4 filas y 2
columnas.
Existen varios tipos de arreglos, en los que encontramos: una dimensión (vectores), dos
dimensiones (matrices) y multidimensionales (3, 4 o más dimensiones)
Declaración de arreglos
La declaración de un arreglo, significa crear casillas en “blanco”, esperando a que se llenen con
datos. Para poder declarar un arreglo existen dos formas:
1. Se declara una variable tipo array y después se le indica el tamaño:
2. Se declara el array y su tamaño en una sola línea de código:
Inicialización de arreglos
Inicializar un arreglo significa que se le darán valores por default al arreglo.
29
ESTRUCTURA DE DATOS
Los arreglos se pueden definir como objetos en los que podemos guardar más de una variable, es
decir, al tener un único arreglo, este puede guardar múltiples variables de acuerdo a su tamaño o
capacidad, es importante recordar que las variables guardadas deben ser del mismo tipo, por
ejemplo: Si tenemos un arreglo de tipo Numérico que puede almacenar 10 variables, solo podrá
almacenar 10 números diferentes, no otras variables como caracteres o Strings.
Existen 2 tipos de arreglos, los unidimensionales, y los multidimensionales (generalmente 2

dimensiones y se les denomina matrices), en esta lección veremos como declarar y utilizar los
arreglos unidimensionales, estos son más sencillos y fáciles de comprender, y pueden servirnos
para muchas aplicaciones.
Definir tamaño de arreglos:

Para asignar a un arreglo su tamaño o capacidad, se hace de la siguiente forma:
arreglo = new tipo_dedato[capacidad];
Ejemplo:
Para realizar una declaración de un arreglo y definir su tamaño en una misma línea se puede usar
la siguiente estructura:
Asignación de valores a elementos del array

Una vez se tiene declarado un arreglo, y al mismo se le ha asignado un tamaño o capacidad,
podemos tener acceso a los datos dentro del mismo y asignarle valores. Para hacer esto es
necesario proceder de la siguiente forma:
arreglo[indicador]=valor;
Ejemplos:
30
ESTRUCTURA DE DATOS
Es importante recordar que para accesar a los datos guardados en un arreglo se utilizan
indicadores iniciando desde el "0", si un arreglo tiene un tamaño de 10 variables, entonces se
puede accesar a sus elementos con los indicadores del 0 al 9.
31
ESTRUCTURA DE DATOS
¿Cómo insertar desde consola, elementos en un arreglo?
¿Cómo muestran en consola los elementos de un arreglo?
Nota: Obsérvese que para leer datos o insertar datos en un arreglo, forzosamente debemos
recorrerlo posición por posición haciendo uso del ciclo for.
32
ESTRUCTURA DE DATOS
Notas adicionales:
33
ESTRUCTURA DE DATOS
34
ESTRUCTURA DE DATOS
Recorrido de arreglos
Recorrer un arreglo significa que se pasará posición por posición y se realizarán operaciones con
cada elemento. Las operaciones a realizar pueden ser:
35
ESTRUCTURA DE DATOS
a. Lectura
b. Escritura
c. Ordenación
d. Búsqueda
El siguiente bloque de código utiliza un ciclo for que va desde la posición 0 del arreglo hasta la
posición tamaño-1, para recorrer un arreglo y después con número pares enteros positivos
(empezando por el cero).
Los siguientes bloques de código permiten leer datos de un arreglo:
Salida:
36
ESTRUCTURA DE DATOS
Salida:
Si al código anterior se le pide agregar la búsqueda de números 5 en la matriz e imprimir cuántos

de estos números fueron encontrados, sería:
37
ESTRUCTURA DE DATOS
Salida:
38
ESTRUCTURA DE DATOS
CREACIÓN DE ARCHIVOS
El paquete java.io contiene casi todas las clases que podamos necesitar para llevar a cabo la
entrada y salida (I/O) de datos en Java. En el caso de la lectura y escritura de archivos, se usan los
llamados streams para poder leer y escribir datos.
Un stream puede ser definido como una secuencia de datos. El InputStream se utiliza para leer
datos de una fuente y el OutputStream se utiliza para escribir datos en un destino.
ESCRITURA
Para poder escribir en un archivo necesitamos:
 Importar el paquete java.io.*

 El nombre del archivo
 El texto que deseamos que se escriba en el archivo
 La clase FileWriter de Java para acceder al archivo
 Un atrapador (try) y un controlador de excepciones (catch)
39
ESTRUCTURA DE DATOS
En el caso de que se quisiera enviar los elementos de un arreglo al archivo, el código sería:
Para ver el archivo deberás revisar la carpeta NetBeansProjects/tu proyecto
40
ESTRUCTURA DE DATOS
ORDENACION
Burbuja
El funcionamiento del algoritmo de ordenación burbuja, únicamente va recorriendo los elementos
del arreglo comparando si es más grande o más chico un elemento que el de al lado, dependiendo
si queremos ordenar de forma ascendente o descendente, se realizan las cantidad de vueltas
necesarias hasta tener todos los elementos ordenados.
El siguiente ejemplo muestra el proceso de forma gráfica:
41
ESTRUCTURA DE DATOS
Salida:
42
ESTRUCTURA DE DATOS
QuickSort
El ordenamiento rápido (quicksort en inglés) es un algoritmo basado en la técnica de divide y

vencerás, que permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n.
Esta es la técnica de ordenamiento más rápida conocida. Fue desarrollada por C. Antony R. Hoare
en 1960. El algoritmo original es recursivo, pero se utilizan versiones iterativas para mejorar su
rendimiento (los algoritmos recursivos son en general más lentos que los iterativos, y consumen
más recursos).
El algoritmo fundamental es el siguiente:
 Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.
 Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un lado
queden todos los menores que él, y al otro los mayores. En este momento, el pivote ocupa
exactamente el lugar que le corresponderá en la lista ordenada.
 La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del
pivote, y otra por los elementos a su derecha.
 Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más
de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.
Como se puede suponer, la eficiencia del algoritmo depende de la posición en la que
termine el pivote elegido.
 En el mejor caso, el pivote termina en el centro de la lista, dividiéndola en dos sublistas de

igual tamaño. En este caso, el orden de complejidad del algoritmo es O(n·log n).
 En el peor caso, el pivote termina en un extremo de la lista. El orden de complejidad del

algoritmo es entonces de 0(n²). El peor caso dependerá de la implementación del
algoritmo, aunque habitualmente ocurre en listas que se encuentran ordenadas, o casi
ordenadas.
 En el caso promedio, el orden es O(n·log n).
43
ESTRUCTURA DE DATOS
Si lo creamos en Java con clases y objetos:
44
ESTRUCTURA DE DATOS
Ejercicios:
1. Crea un arreglo y guarda en él, los primeros 100 números pares.

2. Crea un arreglo y guarda en él, los primeros 50 números impares.
3. Crea una matriz de n x m, llénala con números aleatorios (números entre el 10 y el 50).
Mándala a un txt (cuida la estética).
4. Crea mediante el uso de for las siguientes figuras:
***** 
**** 
*** 
** 
*
5. Solicita al usuario que ingrese palabras entre llaves y validar que todas las palabras
queden entre paréntesis. Por ejemplo: {casa}, {escuela},{edificio},{museo}.
Entregar los ejercicios escritos en hojas blancas (usar por ambas caras) el día del examen.
45

Guia Introductoria para Empezar A Programar V 1.2

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia Introductoria para Empezar A Programar V 1.2

Cargado por

Copyright:

Formatos disponibles

Estructura

Estructuralmente, el lenguaje Java comienza con paquetes. Un paquete es el mecanismo de

El kit de desarrollo de Java

El Java Runtime Environment

INSTALACIÓN DEL ENTORNO DE PROGRAMACIÓN

Durante la asignatura realizarás códigos en un entorno de programación (Integrated Development

 Edición del programa.

Este tipo de entornos incorporan numerosas herramientas, utilidades, aplicaciones ya

En el curso estaremos utilizando NetBeans, para descargarlo es necesario ir a la página:

El JDK lo puedes descargar en el link:

Una vez instalados los dos elementos podrás iniciar a programar.

Ahora es momento de empezar a crear el primer programa. Identifica el área de trabajo:

La estructura básica de un programa desarrollado usando Java es la siguiente:

A continuación se muestran algunos ejemplos de programas en NetBeans:

Solicitar un número entero, guardarlo y mostrarlo en consola

Solicitar un número flotante, guardarlo y mostrarlo en consola

Solicitar una cadena de caracteres, guardarla y mostrarla en consola

Mostrar un mensaje en modo gráfico (Ventana)

Solicitar una variable en una ventana y después desplegarla en modo gráfico

Al ejecutar el programa resultará:

//cargar o asignar la variable de condición;

grupo cierto de instrucciones;

La salida de este programa sería:

grupo cierto de instrucciones;

grupo cierto de instrucciones;

Ejemplo 2: Un ejemplo completo del if else se muestra a continuación.

A para un valor del 100-91,

F si no es ninguno de los anteriores:

La instrucción switch() es una instrucción de decisión múltiple, donde el compilador prueba o

En JAVA el formato de esta instrucción es el siguiente;

//capturar o asignar variable de condición;

Ejemplo de switch: Se crea un programa donde el usuario ingresa un mes en número y el

La salida del programa es:

//cargar o inicializar variable de condición;

grupo cierto de instrucciones;

instrucción(es) para salir del ciclo;

Ejemplo de while: A continuación se muestra el código para la impresión en pantalla de los

La ejecución del programa sería:

También se le conoce por esta razón como ciclo de condición de salida.

//cargar o inicializar variable de condición;

//grupo cierto de instrucción(es);

El resultado del programa anterior sería:

La Sintaxis empleada por el ciclo for es la siguiente:

Al ejecutar el programa, el resultado es el siguiente:

INTRODUCCIÓN A LAS ESTRUCTURAS DE DATOS

El arreglo se llama A, guarda 6 elementos de tipo entero (int).

El arreglo se llama G, y guarda 5 elementos de tipo char.

1. Se declara una variable tipo array y después se le indica el tamaño:

2. Se declara el array y su tamaño en una sola línea de código:

Existen 2 tipos de arreglos, los unidimensionales, y los multidimensionales (generalmente 2

Definir tamaño de arreglos:

arreglo = new tipo_dedato[capacidad];

Asignación de valores a elementos del array

¿Cómo insertar desde consola, elementos en un arreglo?

¿Cómo muestran en consola los elementos de un arreglo?

Los siguientes bloques de código permiten leer datos de un arreglo:

Si al código anterior se le pide agregar la búsqueda de números 5 en la matriz e imprimir cuántos

Para poder escribir en un archivo necesitamos:

 Importar el paquete java.io.*

Para ver el archivo deberás revisar la carpeta NetBeansProjects/tu proyecto

El siguiente ejemplo muestra el proceso de forma gráfica:

El ordenamiento rápido (quicksort en inglés) es un algoritmo basado en la técnica de divide y