TALLER DE PROGRAMACION

LORENA LUENGAS BENAVIDES

U1803506
JUAN CAMILO MARTINEZ ROCHA
U1803504

Prof:BYRON PEREZ

UNIVERSIDAD MILITAR NUEVA GRANADA

PROGRAMA DE INGENIERIA MECATRONICA
BOGOTA.D.C
2019
1) Algoritmo MergeSort

public class Margensort {

private static void printArray(int[] array) {
for(int i: array) {
System.out.print(i + " ");
}
System.out.println();
}.
private static int[] mergeSort(int[] array) {
if(array.length <= 1) {
return array;
}
int mipunto = array.length / 2;
// DECLARAR Y INICIALIZAR
int[] arreglo1 = new int[mipunto];
int[] arreglo2;
if(array.length % 2 == 0) {
arreglo2 = new int[mipunto];
} else {
arreglo2 = new int[mipunto + 1];
}
for(int i=0; i < mipunto; i++) {
arreglo1[i] = array[i];
}
for(int j=0; j < arreglo2.length; j++) {

arreglo2[j] = array[mipunto+j];
}
 int[] result = new int[array.length];
// SE LLAMA
arreglo1 = mergeSort(arreglo1);
arreglo2 = mergeSort(arreglo2);
result = merge(arreglo1, arreglo2);
// DEVUELVE RESULTADO
return result;
}
private static int[] merge(int[] arreglo1, int[] arreglo2) {
// resultado
int[] result = new int[arreglo1.length + arreglo2.length];
//declaración y inicialización.
int izquierdo, derecho, resultP;
izquierdo= derecho = resultP = 0;
while(izquierdo < arreglo1.length || derecho< arreglo2.length) {
if(izquierdo < arreglo1.length && derecho < arreglo2.length) {
if(arreglo1[izquierdo] < arreglo2[derecho]) {
result[resultP++] = arreglo1[izquierdo++];
} else {
result[resultP++] = arreglo2[derecho++];
}
}
else if(izquierdo < arreglo1.length) {
result[resultP++] = arreglo1[izquierdo++];
}
else if(derecho< arreglo2.length) {
result[resultP++] = arreglo2[derecho++];
}
 }
return result;
}
public static void main(String args[]) {
int[] array = { 5, 4, 3, 2, 1 ,10,15,0};
System.out.println("Initial Array: ");
printArray(array);
array = mergeSort(array);
System.out.println("Sorted Array: ");
printArray(array);
}
}

2) como declarar arreglos

Creación de arreglos explícita (Unidimensional )

Para crear un arreglo de forma explícita se creará siguiendo la siguiente sintaxis:

int array[]=new int[20]

- Donde de int array[]Es la definición de la referencia la cual dice que

se creará un arreglo de tipo entero uní dimensional.

Int[20]:Es el operador new para crealos,el numero 20 define que el

-
arreglo tendrá una capacidad de 20 elementos de tipo entero.
Creación de arreglos de forma implícita

Para crear un arreglo de forma implícita se seguirá la siguiente sintaxis:

int array[]={1,2,3,4,5,6};
-int array[]:Define una referencia unidimensional a un arreglo de enteros.
-{1,2,3,4,5]: se esta creando de forma implícita, ya que solo se definen los elementos
que contendrá .
Bidimensional:
Creación de arreglos explícita (Bidimensional )
Tipo_de_dato nombre[][]= new Tipo_de_dato[20][20];
Creación de arreglos de forma implícita

Tipo_de_dato nombre[][]=new Tipo_de_dato[1,2,3,4][5,6,7,8];

Tridimensionales

Creación de arreglos explícita (Tridimensional )

int[][][] arreglo=new int [10][10][10];

Creación de arreglos de forma implícita:

Int[][][] arreglo=new int[2][3][5]

{1,2,3,4,5}

{2,1,3,4,5}

{1,4,3,2,5}

}{

{5,4,3,2,1}

{3,4,2,5,1}

{1,5,4,2,3}

3) Defina cada uno de los conceptos enumerados a continuación:

-Objetos: entidad existente en la memoria del ordenador que tiene unas propiedades
(atributos o datos sobre sí mismo almacenados por el objeto) y unas operaciones
disponibles específicas (métodos).
-Clase: abstracción que define un tipo de objeto especificando qué propiedades
(atributos) y operaciones disponibles va a tener.
-Atributos: Los atributos son las características individuales que diferencian un
objeto de otro y determinan su apariencia. Los atributos se guardan en variables
denominadas de instancia, y cada objeto particular puede tener valores distintos
para estas variables
-Métodos: Un método en java es un conjunto de instrucciones definidas dentro de
una clase, que realizan una determinada tarea y a las que podemos invocar
mediante un nombre.

Algunos métodos que hemos utilizado hasta ahora:

– Math.pow()
– Math.sqrt()
– Character.isDigit()
- System.out.println();

- Paquetes: Los paquetes sirven para agrupar clases relacionadas y definen un

espacio de nombres (namespace) para las clases que contienen.
b). Cada miembro está precedido del especificador de acceso que le corresponde:

-Public: define miembros públicos, aquellos a los que se puede acceder por
cualquier método desde fuera de la clase.

-Private: sólo se puede acceder por métodos de la misma clase.

-Protected: se puede ingresar por aquellos de la misma clase o de clases derivadas,
así como por métodos de otras clases que se encuentran en el mismo paquete.

c) Un método miembro de un objeto está asociado al objeto. Cuando este se está

ejecutando podemos usar this, para conseguir una referencia al objeto asociado. En
donde se debe usar this.variable para así poder interactuar con el objeto.

d) Un recolector de basura: Es un mecanismo implícito de gestión de

memoria implementado en algunos lenguajes de programación de
tipo interpretado .
e) Constructor : Es un método especial de una clase que se llama automáticamente
siempre que se declara un objeto de esa clase.
-Constructor por defecto: es un constructor sin parámetros que no hace nada. Los
atributos del objeto son iniciados con los valores predeterminados por el sistema.
-Constructor sobrecargado: a sobrecarga de métodos es la creación de varios
métodos con el mismo nombre pero con diferente lista de tipos de parámetros. Java
utiliza el número y tipo de parámetros para seleccionar cuál definición de método
ejecutar.

f) la variable estática en Java: Es una variable que pertenece a la clase y se

inicializa solo una vez al inicio de la ejecución.
 Es una variable que pertenece a la clase y no al objeto (instancia)
  Las variables estáticas se inicializan solo una vez, al inicio de la
ejecución. Estas variables se inicializarán primero, antes de la inicialización de
cualquier variable de instancia

-Método : El método estático en Java es un método que pertenece a la clase y no

al objeto. Un método estático solo puede acceder a datos estáticos.

 Es un método que pertenece a la clase y no al objeto (instancia)

 Un método estático solo puede acceder a datos estáticos. No puede acceder
a datos no estáticos (variables de instancia)

Programa de numeros complejo

4) Números complejos:

CODIGO:
/**
*
* @author camil
*/
public class Complejo {

private double reala;

private double realb;
private double imaginario;
private double escalar;

public Complejo(double a){

reala = 0;
realb = 0;
imaginario = 0; // i = raiz (-1)
escalar = 0;
}
public Complejo(double a, double b, double i, double e){
reala = a;
realb = b;
imaginario = i;
escalar = e;
}
public void setreala(double a){
reala = a;
}
public void setrealb(double b){
realb = b;
}
public void setimaginario(double i){
imaginario = i;
}
public void setescalar(double e){
escalar = e;
 }
public double getreala(){
return reala;
}
public double getrealb(){
return realb;
}
public double getimaginario(){
return imaginario;
}
public double getescalar(){
return escalar;
}
public Complejo suma(Complejo x){ // a+bi
double a = reala + x.getreala();
double b = realb + x.getrealb();
double i = imaginario + x.getimaginario();
return new Complejo(a);
// return new Complejo(reala + x.getreala(),realb +
x.getrealb(),imaginario + x.getimaginario());
}
public Complejo resta(Complejo x){
double a = reala - x.getreala();
double b = realb - x.getrealb();
double i = imaginario - x.getimaginario();
return new Complejo(a);
// return new Complejo(reala - x.getreala(),realb -
x.getrealb(),imaginario - x.getimaginario());
}
public Complejo multiplicacionescalar(Complejo x){
double e = escalar * x.getescalar();
return new Complejo(e);

}
public Complejo multiplicacioncomplejos(Complejo x){
double i = imaginario * x.getimaginario();
return new Complejo(i);
}

Punto 5 : Arreglos

CODIGO:
package calculadoramedia;
import java.util.Scanner;
/**

* @author Lorena
*/
public class CalculadoraMedia {
static double numero;
static double varianza;

static double media;

static int n;
static double desviacion;
static double mediana;

public static void main(String[] args) {

Scanner leer= new Scanner(System.in);
System.out.println("Dijite la cantidad de numeros a digitar ");
n=leer.nextInt();
// crear arreglo
double numeros []= new double [n];
for( int i=0;i < n;i++)
{

System.out.println("ingrese el numero");
numeros[i]=leer.nextDouble();
}
// media

double suma=0;
for ( double i: numeros )
{
suma = suma+ i;

}
media= suma/n;
System.out.println(" la media de estos numeros es :"+media);
//varianza

double sumatoria;
for( int i=0;i < n;i++) {
sumatoria= Math.pow(numeros[i] - media,2);
varianza=varianza + sumatoria;

}
varianza=varianza/(n-1);
 // desviacion estandar

desviacion=Math.sqrt(varianza);
double valor=Math.rint(desviacion*100)/100;
System.out.println(" la desviacion estandar es de :"+valor);
// mediana

int i, j, aux;
int a[] = new int[n];
for(i = 0; i < n; i++){
System.out.print("Ingresa los numeros anteriores de nuevo ");
a[i] = leer.nextInt();
}//fin for

for(i = 1; i < n; i++){

for(j = 0; j < n - i; j++){

if(a[j] > a[j + 1]){
aux = a[j];
a[j] = a[j + 1];

a[j + 1] = aux;
}//fin if
}//fin for
}//fin for

System.out.printf("La mediana es: %d\n",a[2]);

}
}
Punto 6 :

Pinto 7:

Burbuja:
Es un algoritmo de ordenamiento. Este funciona revisando cada elemento de la lista que va a ser
ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es
necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios También
es conocido como el método del intercambio directo. Dado que solo usa comparaciones para
operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de
implementar.

Código:

package burbujas;

import java.util.Scanner;

import javax.swing.JOptionPane;

public class Burbujas {

public static void main(String[] args ) {

Scanner leer=new Scanner (System.in);

int arreglo[],elementos;

int aux;

elementos=Integer.parseInt(JOptionPane.showInputDialog("digite la cantidad de elementos"));

 arreglo=new int [elementos];

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

System.out.println((i+1)+"digite un numero");

arreglo[i]=leer.nextInt();

//método burbuja

for(int i=0;i<(elementos-1);i++)

for(int j=0;i<(elementos-1);j++)

if(arreglo[j]> arreglo[j+1]){

aux=arreglo[j];

arreglo[j]=arreglo[j+1];

arreglo[j+1]=aux;

// método ordenado

System.out.println("\n arreglo ordenado ");

for(int i=0;i<(elementos-1);i++){

System.out.println(arreglo[i]+" - ");

System.out.println("\n arreglo ordenado decreciente");

for(int i=(elementos-1);i>=0;i--){

System.out.print(arreglo[i]+ " - ");

System.out.println(" ");

}
}

Intersección:

el método de ordenación por inserción consiste en recorrer todo el array comenzando

desde el segundo elemento hasta el final. Para cada elemento, se trata de colocarlo en
el lugar correcto entre todos los elementos anteriores a él o sea entre los elementos a
su izquierda en el array.
Selección:

El método de ordenación por selección consiste en repetir los siguientes pasos:

Se busca el elemento más pequeño del array y se coloca en la primera posición.
Entre los restantes, se busca el elemento más pequeño y se coloca en la segunda
posición.
Entre los restantes se busca el elemento más pequeño y se coloca en la tercera posición.

Bibliografía:
https://es.wikipedia.org/wiki/Ordenamiento_de_burbuja

http://puntocomnoesunlenguaje.blogspot.com/2015/02/ordenamiento-insercion-directa-
java.html

http://puntocomnoesunlenguaje.blogspot.com/2012/12/java-metodo-ordenacion-seleccion.html